{
public:
- typedef Dali::AccessibilityManager::AccessibilityActionSignalV2 AccessibilityActionSignalV2;
- typedef Dali::AccessibilityManager::AccessibilityActionScrollSignalV2 AccessibilityActionScrollSignalV2;
+ typedef Dali::AccessibilityManager::AccessibilityActionSignalType AccessibilityActionSignalType;
+ typedef Dali::AccessibilityManager::AccessibilityActionScrollSignalType AccessibilityActionScrollSignalType;
// Creation
/**
* @copydoc Dali::AccessibilityManager::StatusChangedSignal
*/
- AccessibilityActionSignalV2& StatusChangedSignal()
+ AccessibilityActionSignalType& StatusChangedSignal()
{
- return mStatusChangedSignalV2;
+ return mStatusChangedSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionNextSignal
*/
- AccessibilityActionSignalV2& ActionNextSignal()
+ AccessibilityActionSignalType& ActionNextSignal()
{
- return mActionNextSignalV2;
+ return mActionNextSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionPreviousSignal
*/
- AccessibilityActionSignalV2& ActionPreviousSignal()
+ AccessibilityActionSignalType& ActionPreviousSignal()
{
- return mActionPreviousSignalV2;
+ return mActionPreviousSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionActivateSignal
*/
- AccessibilityActionSignalV2& ActionActivateSignal()
+ AccessibilityActionSignalType& ActionActivateSignal()
{
- return mActionActivateSignalV2;
+ return mActionActivateSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionOverSignal
*/
- AccessibilityActionSignalV2& ActionOverSignal()
+ AccessibilityActionSignalType& ActionOverSignal()
{
- return mActionOverSignalV2;
+ return mActionOverSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionReadSignal
*/
- AccessibilityActionSignalV2& ActionReadSignal()
+ AccessibilityActionSignalType& ActionReadSignal()
{
- return mActionReadSignalV2;
+ return mActionReadSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionReadNextSignal
*/
- AccessibilityActionSignalV2& ActionReadNextSignal()
+ AccessibilityActionSignalType& ActionReadNextSignal()
{
- return mActionReadNextSignalV2;
+ return mActionReadNextSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionReadPreviousSignal
*/
- AccessibilityActionSignalV2& ActionReadPreviousSignal()
+ AccessibilityActionSignalType& ActionReadPreviousSignal()
{
- return mActionReadPreviousSignalV2;
+ return mActionReadPreviousSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionUpSignal
*/
- AccessibilityActionSignalV2& ActionUpSignal()
+ AccessibilityActionSignalType& ActionUpSignal()
{
- return mActionUpSignalV2;
+ return mActionUpSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionDownSignal
*/
- AccessibilityActionSignalV2& ActionDownSignal()
+ AccessibilityActionSignalType& ActionDownSignal()
{
- return mActionDownSignalV2;
+ return mActionDownSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionClearFocusSignal
*/
- AccessibilityActionSignalV2& ActionClearFocusSignal()
+ AccessibilityActionSignalType& ActionClearFocusSignal()
{
- return mActionClearFocusSignalV2;
+ return mActionClearFocusSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionBackSignal
*/
- AccessibilityActionSignalV2& ActionBackSignal()
+ AccessibilityActionSignalType& ActionBackSignal()
{
- return mActionBackSignalV2;
+ return mActionBackSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionScrollSignal
*/
- AccessibilityActionScrollSignalV2& ActionScrollSignal()
+ AccessibilityActionScrollSignalType& ActionScrollSignal()
{
- return mActionScrollSignalV2;
+ return mActionScrollSignal;
}
private:
Indicator* mIndicator; ///< The indicator
bool mIndicatorFocused; ///< Whether the Indicator is focused
- AccessibilityActionSignalV2 mStatusChangedSignalV2;
- AccessibilityActionSignalV2 mActionNextSignalV2;
- AccessibilityActionSignalV2 mActionPreviousSignalV2;
- AccessibilityActionSignalV2 mActionActivateSignalV2;
- AccessibilityActionSignalV2 mActionOverSignalV2;
- AccessibilityActionSignalV2 mActionReadSignalV2;
- AccessibilityActionSignalV2 mActionReadNextSignalV2;
- AccessibilityActionSignalV2 mActionReadPreviousSignalV2;
- AccessibilityActionSignalV2 mActionUpSignalV2;
- AccessibilityActionSignalV2 mActionDownSignalV2;
- AccessibilityActionSignalV2 mActionClearFocusSignalV2;
- AccessibilityActionSignalV2 mActionBackSignalV2;
- AccessibilityActionScrollSignalV2 mActionScrollSignalV2;
+ AccessibilityActionSignalType mStatusChangedSignal;
+ AccessibilityActionSignalType mActionNextSignal;
+ AccessibilityActionSignalType mActionPreviousSignal;
+ AccessibilityActionSignalType mActionActivateSignal;
+ AccessibilityActionSignalType mActionOverSignal;
+ AccessibilityActionSignalType mActionReadSignal;
+ AccessibilityActionSignalType mActionReadNextSignal;
+ AccessibilityActionSignalType mActionReadPreviousSignal;
+ AccessibilityActionSignalType mActionUpSignal;
+ AccessibilityActionSignalType mActionDownSignal;
+ AccessibilityActionSignalType mActionClearFocusSignal;
+ AccessibilityActionSignalType mActionBackSignal;
+ AccessibilityActionScrollSignalType mActionScrollSignal;
public:
// let the core know the surface size has changed
mCore->SurfaceResized(positionSize.width, positionSize.height);
- mResizedSignalV2.Emit( mAdaptor );
+ mResizedSignal.Emit( mAdaptor );
}
void Adaptor::NotifyLanguageChanged()
{
- mLanguageChangedSignalV2.Emit( mAdaptor );
+ mLanguageChangedSignal.Emit( mAdaptor );
}
void Adaptor::RequestUpdateOnce()
}
Adaptor::Adaptor(Dali::Adaptor& adaptor, RenderSurface* surface, const DeviceLayout& baseLayout)
-: mResizedSignalV2(),
- mLanguageChangedSignalV2(),
+: mResizedSignal(),
+ mLanguageChangedSignal(),
mAdaptor(adaptor),
mState(READY),
mCore(NULL),
{
public:
- typedef Dali::Adaptor::AdaptorSignalV2 AdaptorSignalV2;
+ typedef Dali::Adaptor::AdaptorSignalType AdaptorSignalType;
/**
* Creates a New Adaptor
/**
* @copydoc Dali::Adaptor::SignalResized
*/
- AdaptorSignalV2& ResizedSignal()
+ AdaptorSignalType& ResizedSignal()
{
- return mResizedSignalV2;
+ return mResizedSignal;
}
/**
* @copydoc Dali::Adaptor::LanguageChangedSignal
*/
- AdaptorSignalV2& LanguageChangedSignal()
+ AdaptorSignalType& LanguageChangedSignal()
{
- return mLanguageChangedSignalV2;
+ return mLanguageChangedSignal;
}
private: // From Dali::Internal::Adaptor::CoreEventInterface
private: // Data
- AdaptorSignalV2 mResizedSignalV2; ///< Resized signal.
- AdaptorSignalV2 mLanguageChangedSignalV2; ///< Language changed signal.
+ AdaptorSignalType mResizedSignal; ///< Resized signal.
+ AdaptorSignalType mLanguageChangedSignal; ///< Language changed signal.
Dali::Adaptor& mAdaptor; ///< Reference to public adaptor instance.
State mState; ///< Current state of the adaptor
return mImpl->AddIdle(callBack);
}
-Adaptor::AdaptorSignalV2& Adaptor::ResizedSignal()
+Adaptor::AdaptorSignalType& Adaptor::ResizedSignal()
{
return mImpl->ResizedSignal();
}
-Adaptor::AdaptorSignalV2& Adaptor::LanguageChangedSignal()
+Adaptor::AdaptorSignalType& Adaptor::LanguageChangedSignal()
{
return mImpl->LanguageChangedSignal();
}
#include "window.h"
#include "application-configuration.h"
#include "tts-player.h"
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
#include <dali/public-api/math/rect.h>
#include <dali/public-api/events/touch-event.h>
{
public:
- typedef SignalV2< void (Adaptor&) > AdaptorSignalV2; ///< Generic Type for adaptor signals
+ typedef Signal< void (Adaptor&) > AdaptorSignalType; ///< Generic Type for adaptor signals
public:
/**
*
* @return The signal to connect to
*/
- AdaptorSignalV2& ResizedSignal();
+ AdaptorSignalType& ResizedSignal();
/**
* @brief This signal is emitted when the language is changed on the device.
*
* @return The signal to connect to
*/
- AdaptorSignalV2& LanguageChangedSignal();
+ AdaptorSignalType& LanguageChangedSignal();
private:
}
Application::Application( int* argc, char** argv[], const std::string& name, const DeviceLayout& baseLayout, Dali::Application::WINDOW_MODE windowMode)
-: mInitSignalV2(),
- mTerminateSignalV2(),
- mPauseSignalV2(),
- mResumeSignalV2(),
- mResetSignalV2(),
- mResizeSignalV2(),
- mLanguageChangedSignalV2(),
+: mInitSignal(),
+ mTerminateSignal(),
+ mPauseSignal(),
+ mResumeSignal(),
+ mResetSignal(),
+ mResizeSignal(),
+ mLanguageChangedSignal(),
mEventLoop( NULL ),
mFramework( NULL ),
mCommandLineOptions( NULL ),
mAdaptor->Stop();
Dali::Application application(this);
- mTerminateSignalV2.Emit( application );
+ mTerminateSignal.Emit( application );
mFramework->Quit();
// This will trigger OnTerminate(), below, after the main loop has completed.
LanguageChangedSignal().Connect( &GetImplementation( lifecycleController ), &LifecycleController::OnLanguageChanged );
Dali::Application application(this);
- mInitSignalV2.Emit( application );
+ mInitSignal.Emit( application );
Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).GetCore().SceneCreated();
}
{
mAdaptor->Pause();
Dali::Application application(this);
- mPauseSignalV2.Emit( application );
+ mPauseSignal.Emit( application );
}
void Application::OnResume()
{
mAdaptor->Resume();
Dali::Application application(this);
- mResumeSignalV2.Emit( application );
+ mResumeSignal.Emit( application );
}
void Application::OnReset()
* because Application class already handled initialization in OnInit(), OnReset do nothing.
*/
Dali::Application application(this);
- mResetSignalV2.Emit( application );
+ mResetSignal.Emit( application );
mWindow.Raise();
}
void Application::OnResize(Dali::Adaptor& adaptor)
{
Dali::Application application(this);
- mResizeSignalV2.Emit( application );
+ mResizeSignal.Emit( application );
}
bool Application::AddIdle(boost::function<void(void)> callBack)
{
public:
- typedef Dali::Application::AppSignalV2 AppSignalV2;
+ typedef Dali::Application::AppSignalType AppSignalType;
/**
* Constructor
/**
* @copydoc Dali::Application::InitSignal()
*/
- Dali::Application::AppSignalV2& InitSignal() { return mInitSignalV2; }
+ Dali::Application::AppSignalType& InitSignal() { return mInitSignal; }
/**
* @copydoc Dali::Application::TerminateSignal()
*/
- Dali::Application::AppSignalV2& TerminateSignal() { return mTerminateSignalV2; }
+ Dali::Application::AppSignalType& TerminateSignal() { return mTerminateSignal; }
/**
* @copydoc Dali::Application::PauseSignal()
*/
- Dali::Application::AppSignalV2& PauseSignal() { return mPauseSignalV2; }
+ Dali::Application::AppSignalType& PauseSignal() { return mPauseSignal; }
/**
* @copydoc Dali::Application::ResumeSignal()
*/
- Dali::Application::AppSignalV2& ResumeSignal() { return mResumeSignalV2; }
+ Dali::Application::AppSignalType& ResumeSignal() { return mResumeSignal; }
/**
* @copydoc Dali::Application::ResetSignal()
*/
- Dali::Application::AppSignalV2& ResetSignal() { return mResetSignalV2; }
+ Dali::Application::AppSignalType& ResetSignal() { return mResetSignal; }
/**
* @copydoc Dali::Application::ResizeSignal()
*/
- Dali::Application::AppSignalV2& ResizeSignal() { return mResizeSignalV2; }
+ Dali::Application::AppSignalType& ResizeSignal() { return mResizeSignal; }
/**
* @copydoc Dali::Application::LanguageChangedSignal()
*/
- Dali::Application::AppSignalV2& LanguageChangedSignal() { return mLanguageChangedSignalV2; }
+ Dali::Application::AppSignalType& LanguageChangedSignal() { return mLanguageChangedSignal; }
private:
private:
- AppSignalV2 mInitSignalV2;
- AppSignalV2 mTerminateSignalV2;
- AppSignalV2 mPauseSignalV2;
- AppSignalV2 mResumeSignalV2;
- AppSignalV2 mResetSignalV2;
- AppSignalV2 mResizeSignalV2;
- AppSignalV2 mLanguageChangedSignalV2;
+ AppSignalType mInitSignal;
+ AppSignalType mTerminateSignal;
+ AppSignalType mPauseSignal;
+ AppSignalType mResumeSignal;
+ AppSignalType mResetSignal;
+ AppSignalType mResizeSignal;
+ AppSignalType mLanguageChangedSignal;
EventLoop* mEventLoop;
Framework* mFramework;
void ClipboardEventNotifier::EmitContentSelectedSignal()
{
- if ( !mContentSelectedSignalV2.Empty() )
+ if ( !mContentSelectedSignal.Empty() )
{
Dali::ClipboardEventNotifier handle( this );
- mContentSelectedSignalV2.Emit( handle );
+ mContentSelectedSignal.Emit( handle );
}
}
{
public:
- typedef Dali::ClipboardEventNotifier::ClipboardEventSignalV2 ClipboardEventSignalV2;
+ typedef Dali::ClipboardEventNotifier::ClipboardEventSignalType ClipboardEventSignalType;
// Creation
/**
* @copydoc Dali::ClipboardEventNotifier::ContentSelectedSignal
*/
- ClipboardEventSignalV2& ContentSelectedSignal()
+ ClipboardEventSignalType& ContentSelectedSignal()
{
- return mContentSelectedSignalV2;
+ return mContentSelectedSignal;
}
private:
std::string mContent; ///< The current selected content.
- ClipboardEventSignalV2 mContentSelectedSignalV2;
+ ClipboardEventSignalType mContentSelectedSignal;
public:
{
}
-Dali::LifecycleController::LifecycleSignalV2& LifecycleController::InitSignal()
+Dali::LifecycleController::LifecycleSignalType& LifecycleController::InitSignal()
{
return mInitSignal;
}
}
}
-Dali::LifecycleController::LifecycleSignalV2& LifecycleController::TerminateSignal()
+Dali::LifecycleController::LifecycleSignalType& LifecycleController::TerminateSignal()
{
return mTerminateSignal;
}
}
}
-Dali::LifecycleController::LifecycleSignalV2& LifecycleController::PauseSignal()
+Dali::LifecycleController::LifecycleSignalType& LifecycleController::PauseSignal()
{
return mPauseSignal;
}
}
}
-Dali::LifecycleController::LifecycleSignalV2& LifecycleController::ResumeSignal()
+Dali::LifecycleController::LifecycleSignalType& LifecycleController::ResumeSignal()
{
return mResumeSignal;
}
}
}
-Dali::LifecycleController::LifecycleSignalV2& LifecycleController::ResetSignal()
+Dali::LifecycleController::LifecycleSignalType& LifecycleController::ResetSignal()
{
return mResetSignal;
}
}
}
-Dali::LifecycleController::LifecycleSignalV2& LifecycleController::ResizeSignal()
+Dali::LifecycleController::LifecycleSignalType& LifecycleController::ResizeSignal()
{
return mResizeSignal;
}
}
}
-Dali::LifecycleController::LifecycleSignalV2& LifecycleController::LanguageChangedSignal()
+Dali::LifecycleController::LifecycleSignalType& LifecycleController::LanguageChangedSignal()
{
return mLanguageChangedSignal;
}
/**
* @copydoc Dali::StyleMonitor::InitSignal()
*/
- Dali::LifecycleController::LifecycleSignalV2& InitSignal();
+ Dali::LifecycleController::LifecycleSignalType& InitSignal();
/**
* @copydoc Dali::StyleMonitor::TerminateSignal()
*/
- Dali::LifecycleController::LifecycleSignalV2& TerminateSignal();
+ Dali::LifecycleController::LifecycleSignalType& TerminateSignal();
/**
* @copydoc Dali::StyleMonitor::PauseSignal()
*/
- Dali::LifecycleController::LifecycleSignalV2& PauseSignal();
+ Dali::LifecycleController::LifecycleSignalType& PauseSignal();
/**
* @copydoc Dali::StyleMonitor::ResumeSignal()
*/
- Dali::LifecycleController::LifecycleSignalV2& ResumeSignal();
+ Dali::LifecycleController::LifecycleSignalType& ResumeSignal();
/**
* @copydoc Dali::StyleMonitor::ResetSignal()
*/
- Dali::LifecycleController::LifecycleSignalV2& ResetSignal();
+ Dali::LifecycleController::LifecycleSignalType& ResetSignal();
/**
* @copydoc Dali::StyleMonitor::ResizeSignal()
*/
- Dali::LifecycleController::LifecycleSignalV2& ResizeSignal();
+ Dali::LifecycleController::LifecycleSignalType& ResizeSignal();
/**
* @copydoc Dali::StyleMonitor::LanguageChangedSignal()
*/
- Dali::LifecycleController::LifecycleSignalV2& LanguageChangedSignal();
+ Dali::LifecycleController::LifecycleSignalType& LanguageChangedSignal();
public:
private:
// Signals
- Dali::LifecycleController::LifecycleSignalV2 mInitSignal;
- Dali::LifecycleController::LifecycleSignalV2 mTerminateSignal;
- Dali::LifecycleController::LifecycleSignalV2 mPauseSignal;
- Dali::LifecycleController::LifecycleSignalV2 mResumeSignal;
- Dali::LifecycleController::LifecycleSignalV2 mResetSignal;
- Dali::LifecycleController::LifecycleSignalV2 mResizeSignal;
- Dali::LifecycleController::LifecycleSignalV2 mLanguageChangedSignal;
+ Dali::LifecycleController::LifecycleSignalType mInitSignal;
+ Dali::LifecycleController::LifecycleSignalType mTerminateSignal;
+ Dali::LifecycleController::LifecycleSignalType mPauseSignal;
+ Dali::LifecycleController::LifecycleSignalType mResumeSignal;
+ Dali::LifecycleController::LifecycleSignalType mResetSignal;
+ Dali::LifecycleController::LifecycleSignalType mResizeSignal;
+ Dali::LifecycleController::LifecycleSignalType mLanguageChangedSignal;
};
return Math::PI * (float)mOrientation / 180.0f;
}
-Orientation::OrientationSignalV2& Orientation::ChangedSignal()
+Orientation::OrientationSignalType& Orientation::ChangedSignal()
{
return mChangedSignal;
}
{
public:
- typedef Dali::Orientation::OrientationSignalV2 OrientationSignalV2;
+ typedef Dali::Orientation::OrientationSignalType OrientationSignalType;
static Orientation* New(Window* window);
/**
* @copydoc Dali::Orientation::ChangedSignal()
*/
- OrientationSignalV2& ChangedSignal();
+ OrientationSignalType& ChangedSignal();
private:
/**
Window* mWindow;
- OrientationSignalV2 mChangedSignal;
+ OrientationSignalType mChangedSignal;
int mOrientation;
int mWindowWidth;
/**
* @copydoc Dali::PhysicalKeyboard::StatusChangedSignal()
*/
- Dali::PhysicalKeyboard::Signal& StatusChangedSignal() { return mStatusChangedSignal; }
+ Dali::PhysicalKeyboard::PhysicalKeyboardSignalType& StatusChangedSignal() { return mStatusChangedSignal; }
protected:
private:
- Dali::PhysicalKeyboard::Signal mStatusChangedSignal; ///< Status changed signal
+ Dali::PhysicalKeyboard::PhysicalKeyboardSignalType mStatusChangedSignal; ///< Status changed signal
bool mAttached; ///< true if the physical keyboard is attached, false otherwise
};
mPlugin.StopSound( handle );
}
-SoundPlayer::SoundPlayFinishedSignalV2& SoundPlayer::SoundPlayFinishedSignal()
+SoundPlayer::SoundPlayFinishedSignalType& SoundPlayer::SoundPlayFinishedSignal()
{
- return mSoundPlayFinishedSignalV2;
+ return mSoundPlayFinishedSignal;
}
bool SoundPlayer::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
{
// Emit SoundPlayFinished signal
- if ( !mSoundPlayFinishedSignalV2.Empty() )
+ if ( !mSoundPlayFinishedSignal.Empty() )
{
Dali::SoundPlayer handle( this );
- mSoundPlayFinishedSignalV2.Emit( handle );
+ mSoundPlayFinishedSignal.Emit( handle );
}
}
public:
- typedef Dali::SoundPlayer::SoundPlayFinishedSignalV2 SoundPlayFinishedSignalV2;
+ typedef Dali::SoundPlayer::SoundPlayFinishedSignalType SoundPlayFinishedSignalType;
/**
* Create a SoundPlayer.
/**
* @copydoc Dali::SoundPlayer::SoundPlayFinishedSignal()
*/
- SoundPlayFinishedSignalV2& SoundPlayFinishedSignal();
+ SoundPlayFinishedSignalType& SoundPlayFinishedSignal();
/**
* Connects a callback function with the object's signals.
private:
FeedbackPluginProxy mPlugin;
- SoundPlayFinishedSignalV2 mSoundPlayFinishedSignalV2;
+ SoundPlayFinishedSignalType mSoundPlayFinishedSignal;
};
} // namespace Adaptor
EmitStyleChangeSignal(styleChange);
}
-Dali::StyleMonitor::StyleChangeSignalV2& StyleMonitor::StyleChangeSignal()
+Dali::StyleMonitor::StyleChangeSignalType& StyleMonitor::StyleChangeSignal()
{
- return mStyleChangeSignalV2;
+ return mStyleChangeSignal;
}
void StyleMonitor::EmitStyleChangeSignal(StyleChange styleChange)
{
- if( !mStyleChangeSignalV2.Empty() )
+ if( !mStyleChangeSignal.Empty() )
{
Dali::StyleMonitor handle( this );
- mStyleChangeSignalV2.Emit( handle, styleChange );
+ mStyleChangeSignal.Emit( handle, styleChange );
}
}
/**
* @copydoc Dali::StyleMonitor::StyleChangeSignal()
*/
- Dali::StyleMonitor::StyleChangeSignalV2& StyleChangeSignal();
+ Dali::StyleMonitor::StyleChangeSignalType& StyleChangeSignal();
protected:
private:
- Dali::StyleMonitor::StyleChangeSignalV2 mStyleChangeSignalV2; ///< Emitted when the style changes
+ Dali::StyleMonitor::StyleChangeSignalType mStyleChangeSignal; ///< Emitted when the style changes
Integration::PlatformAbstraction& mPlatformAbstraction; ///< Reference to the PlatformAbstraction (for retrieving defaults)
std::string mUserDefinedThemeFilePath;///< String containing the user defined theme file path
return retVal;
}
-Dali::Timer::TimerSignalV2& Timer::TickSignal()
+Dali::Timer::TimerSignalType& Timer::TickSignal()
{
return mTickSignal;
}
public: // Signals
- Dali::Timer::TimerSignalV2& TickSignal();
+ Dali::Timer::TimerSignalType& TickSignal();
private: // Implementation
private: // Data
- Dali::Timer::TimerSignalV2 mTickSignal;
+ Dali::Timer::TimerSignalType mTickSignal;
// To hide away implementation details
struct Impl;
void InputPanelLanguageChangeCallback( void* data, Ecore_IMF_Context* context, int value );
// Signals
-Dali::VirtualKeyboard::StatusSignalV2 gKeyboardStatusSignalV2;
-Dali::VirtualKeyboard::VoidSignalV2 gKeyboardResizeSignalV2;
-Dali::VirtualKeyboard::VoidSignalV2 gKeyboardLanguageChangedSignalV2;
+Dali::VirtualKeyboard::StatusSignalType gKeyboardStatusSignal;
+Dali::VirtualKeyboard::VoidSignalType gKeyboardResizeSignal;
+Dali::VirtualKeyboard::VoidSignalType gKeyboardLanguageChangedSignal;
Dali::VirtualKeyboard::ReturnKeyType gReturnKeyType = Dali::VirtualKeyboard::DEFAULT; // the currently used return key type.
{
DALI_LOG_INFO( gLogFilter, Debug::General, "VKB ECORE_IMF_INPUT_PANEL_STATE_SHOW\n" );
- gKeyboardStatusSignalV2.Emit( true );
+ gKeyboardStatusSignal.Emit( true );
break;
}
{
DALI_LOG_INFO( gLogFilter, Debug::General, "VKB ECORE_IMF_INPUT_PANEL_STATE_HIDE\n" );
- gKeyboardStatusSignalV2.Emit( false );
+ gKeyboardStatusSignal.Emit( false );
break;
}
DALI_LOG_INFO( gLogFilter, Debug::General, "VKB InputPanelLanguageChangeCallback" );
// Emit the signal that the language has changed
- gKeyboardLanguageChangedSignalV2.Emit();
+ gKeyboardLanguageChangedSignal.Emit();
}
void InputPanelGeometryChangedCallback ( void *data, Ecore_IMF_Context *context, int value )
DALI_LOG_INFO( gLogFilter, Debug::General, "VKB InputPanelGeometryChangedCallback\n" );
// Emit signal that the keyboard is resized
- gKeyboardResizeSignalV2.Emit();
+ gKeyboardResizeSignal.Emit();
}
} // unnamed namespace
return Rect<int>(xPos,yPos,width,height);
}
-Dali::VirtualKeyboard::StatusSignalV2& StatusChangedSignal()
+Dali::VirtualKeyboard::StatusSignalType& StatusChangedSignal()
{
- return gKeyboardStatusSignalV2;
+ return gKeyboardStatusSignal;
}
-Dali::VirtualKeyboard::VoidSignalV2& ResizedSignal()
+Dali::VirtualKeyboard::VoidSignalType& ResizedSignal()
{
- return gKeyboardResizeSignalV2;
+ return gKeyboardResizeSignal;
}
-Dali::VirtualKeyboard::VoidSignalV2& LanguageChangedSignal()
+Dali::VirtualKeyboard::VoidSignalType& LanguageChangedSignal()
{
- return gKeyboardLanguageChangedSignalV2;
+ return gKeyboardLanguageChangedSignal;
}
Dali::VirtualKeyboard::TextDirection GetTextDirection()
/**
* @copydox Dali::VirtualKeyboard::StatusChangedSignal()
*/
-Dali::VirtualKeyboard::StatusSignalV2& StatusChangedSignal();
+Dali::VirtualKeyboard::StatusSignalType& StatusChangedSignal();
/**
* @copydox Dali::VirtualKeyboard::ResizedSignal()
*/
-Dali::VirtualKeyboard::VoidSignalV2& ResizedSignal();
+Dali::VirtualKeyboard::VoidSignalType& ResizedSignal();
/**
* @copydox Dali::VirtualKeyboard::LanguageChangedSignal()
*/
-Dali::VirtualKeyboard::VoidSignalV2& LanguageChangedSignal();
+Dali::VirtualKeyboard::VoidSignalType& LanguageChangedSignal();
/**
* @copydoc Dali::VirtualKeyboard::GetTextDirection
class Window : public Dali::BaseObject, public Indicator::Observer, public LifeCycleObserver
{
public:
- typedef Dali::Window::IndicatorSignalV2 IndicatorSignalV2;
+ typedef Dali::Window::IndicatorSignalType IndicatorSignalType;
/**
* Create a new Window. This should only be called once by the Application class
/**
* The user should connect to this signal to get a timing when indicator was shown / hidden.
*/
- IndicatorSignalV2& IndicatorVisibilityChangedSignal() { return mIndicatorVisibilityChangedSignalV2; }
+ IndicatorSignalType& IndicatorVisibilityChangedSignal() { return mIndicatorVisibilityChangedSignal; }
private:
Dali::Window::WindowOrientation mPreferredOrientation;
// Signals
- IndicatorSignalV2 mIndicatorVisibilityChangedSignalV2;
+ IndicatorSignalType mIndicatorVisibilityChangedSignal;
};
} // namespace Adaptor
Internal::Adaptor::AccessibilityManager::GetImplementation(*this).HandleActionDisableEvent();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::StatusChangedSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::StatusChangedSignal()
{
return Internal::Adaptor::AccessibilityManager::GetImplementation(*this).StatusChangedSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionNextSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionNextSignal()
{
return Internal::Adaptor::AccessibilityManager::GetImplementation(*this).ActionNextSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionPreviousSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionPreviousSignal()
{
return Internal::Adaptor::AccessibilityManager::GetImplementation(*this).ActionPreviousSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionActivateSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionActivateSignal()
{
return Internal::Adaptor::AccessibilityManager::GetImplementation(*this).ActionActivateSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionOverSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionOverSignal()
{
return Internal::Adaptor::AccessibilityManager::GetImplementation(*this).ActionOverSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionReadSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionReadSignal()
{
return Internal::Adaptor::AccessibilityManager::GetImplementation(*this).ActionReadSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionReadNextSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionReadNextSignal()
{
return Internal::Adaptor::AccessibilityManager::GetImplementation(*this).ActionReadNextSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionReadPreviousSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionReadPreviousSignal()
{
return Internal::Adaptor::AccessibilityManager::GetImplementation(*this).ActionReadPreviousSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionUpSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionUpSignal()
{
return Internal::Adaptor::AccessibilityManager::GetImplementation(*this).ActionUpSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionDownSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionDownSignal()
{
return Internal::Adaptor::AccessibilityManager::GetImplementation(*this).ActionDownSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionClearFocusSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionClearFocusSignal()
{
return Internal::Adaptor::AccessibilityManager::GetImplementation(*this).ActionClearFocusSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionBackSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionBackSignal()
{
return Internal::Adaptor::AccessibilityManager::GetImplementation(*this).ActionBackSignal();
}
-AccessibilityManager::AccessibilityActionScrollSignalV2& AccessibilityManager::ActionScrollSignal()
+AccessibilityManager::AccessibilityActionScrollSignalType& AccessibilityManager::ActionScrollSignal()
{
return Internal::Adaptor::AccessibilityManager::GetImplementation(*this).ActionScrollSignal();
}
#include <boost/function.hpp>
#include <dali/public-api/object/base-handle.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
#include <dali/public-api/events/touch-event.h>
namespace Dali
*
* Signal connected callback should return the result
*/
- typedef SignalV2< bool ( AccessibilityManager& ) > AccessibilityActionSignalV2; ///< Generic signal type
- typedef SignalV2< bool (AccessibilityManager&, const Dali::TouchEvent&)> AccessibilityActionScrollSignalV2; ///< Scroll signal type
+ typedef Signal< bool ( AccessibilityManager& ) > AccessibilityActionSignalType; ///< Generic signal type
+ typedef Signal< bool (AccessibilityManager&, const Dali::TouchEvent&)> AccessibilityActionScrollSignalType; ///< Scroll signal type
/**
* @brief Create an uninitialized handle.
* @endcode
* @return The signal to connect to.
*/
- AccessibilityActionSignalV2& StatusChangedSignal();
+ AccessibilityActionSignalType& StatusChangedSignal();
/**
* @brief This is emitted when accessibility action is received to move focus to the next
* @endcode
* @return The signal to connect to.
*/
- AccessibilityActionSignalV2& ActionNextSignal();
+ AccessibilityActionSignalType& ActionNextSignal();
/**
* @brief This is emitted when accessibility action is received to move focus to the previous
* @endcode
* @return The signal to connect to.
*/
- AccessibilityActionSignalV2& ActionPreviousSignal();
+ AccessibilityActionSignalType& ActionPreviousSignal();
/**
* @brief This is emitted when accessibility action is received to activate the current focused
* @endcode
* @return The signal to connect to.
*/
- AccessibilityActionSignalV2& ActionActivateSignal();
+ AccessibilityActionSignalType& ActionActivateSignal();
/**
* @brief This is emitted when accessibility action is received to focus and read the actor
* @endcode
* @return The signal to connect to.
*/
- AccessibilityActionSignalV2& ActionReadSignal();
+ AccessibilityActionSignalType& ActionReadSignal();
/**
* @brief This is emitted when accessibility action is received to focus and read the actor
* @endcode
* @return The signal to connect to.
*/
- AccessibilityActionSignalV2& ActionOverSignal();
+ AccessibilityActionSignalType& ActionOverSignal();
/**
* @brief This is emitted when accessibility action is received to move focus to the next
* @endcode
* @return The signal to connect to.
*/
- AccessibilityActionSignalV2& ActionReadNextSignal();
+ AccessibilityActionSignalType& ActionReadNextSignal();
/**
* @brief This is emitted when accessibility action is received to move focus to the previous
* @endcode
* @return The signal to connect to.
*/
- AccessibilityActionSignalV2& ActionReadPreviousSignal();
+ AccessibilityActionSignalType& ActionReadPreviousSignal();
/**
* @brief This is emitted when accessibility action is received to change the value when the
* @endcode
* @return The signal to connect to.
*/
- AccessibilityActionSignalV2& ActionUpSignal();
+ AccessibilityActionSignalType& ActionUpSignal();
/**
* @brief This is emitted when accessibility action is received to change the value when the
* @endcode
* @return The signal to connect to.
*/
- AccessibilityActionSignalV2& ActionDownSignal();
+ AccessibilityActionSignalType& ActionDownSignal();
/**
* @brief This is emitted when accessibility action is received to clear the focus from the
* @endcode
* @return The signal to connect to.
*/
- AccessibilityActionSignalV2& ActionClearFocusSignal();
+ AccessibilityActionSignalType& ActionClearFocusSignal();
/**
* @brief This is emitted when accessibility action is received to navigate back (by two
* @endcode
* @return The signal to connect to.
*/
- AccessibilityActionSignalV2& ActionBackSignal();
+ AccessibilityActionSignalType& ActionBackSignal();
/**
* @brief This is emitted when accessibility action is received to handle scroll event (by two
* @endcode
* @return The signal to connect to.
*/
- AccessibilityActionScrollSignalV2& ActionScrollSignal();
+ AccessibilityActionScrollSignalType& ActionScrollSignal();
public: // Not intended for application developers
return Internal::Adaptor::GetImplementation(*this).GetStereoBase();
}
-Application::AppSignalV2& Application::InitSignal()
+Application::AppSignalType& Application::InitSignal()
{
return Internal::Adaptor::GetImplementation(*this).InitSignal();
}
-Application::AppSignalV2& Application::TerminateSignal()
+Application::AppSignalType& Application::TerminateSignal()
{
return Internal::Adaptor::GetImplementation(*this).TerminateSignal();
}
-Application::AppSignalV2& Application::PauseSignal()
+Application::AppSignalType& Application::PauseSignal()
{
return Internal::Adaptor::GetImplementation(*this).PauseSignal();
}
-Application::AppSignalV2& Application::ResumeSignal()
+Application::AppSignalType& Application::ResumeSignal()
{
return Internal::Adaptor::GetImplementation(*this).ResumeSignal();
}
-Application::AppSignalV2& Application::ResetSignal()
+Application::AppSignalType& Application::ResetSignal()
{
return Internal::Adaptor::GetImplementation(*this).ResetSignal();
}
-Application::AppSignalV2& Application::ResizeSignal()
+Application::AppSignalType& Application::ResizeSignal()
{
return Internal::Adaptor::GetImplementation(*this).ResizeSignal();
}
-Application::AppSignalV2& Application::LanguageChangedSignal()
+Application::AppSignalType& Application::LanguageChangedSignal()
{
return Internal::Adaptor::GetImplementation(*this).LanguageChangedSignal();
}
{
public:
- typedef SignalV2< void (Application&) > AppSignalV2;
+ typedef Signal< void (Application&) > AppSignalType;
/**
* Decides whether a Dali application window is opaque or transparent.
* The user should connect to this signal to determine when they should initialise
* their application.
*/
- AppSignalV2& InitSignal();
+ AppSignalType& InitSignal();
/**
* The user should connect to this signal to determine when they should terminate
* their application
*/
- AppSignalV2& TerminateSignal();
+ AppSignalType& TerminateSignal();
/**
* The user should connect to this signal if they need to perform any special
* activities when the application is about to be paused.
*/
- AppSignalV2& PauseSignal();
+ AppSignalType& PauseSignal();
/**
* The user should connect to this signal if they need to perform any special
* activities when the application has resumed.
*/
- AppSignalV2& ResumeSignal();
+ AppSignalType& ResumeSignal();
/**
* This signal is sent when the system requires the user to reinitialise itself.
*/
- AppSignalV2& ResetSignal();
+ AppSignalType& ResetSignal();
/**
* This signal is emitted when the window the application is rendering on is resized.
*/
- AppSignalV2& ResizeSignal();
+ AppSignalType& ResizeSignal();
/**
* This signal is emitted when the language is changed on the device.
*/
- AppSignalV2& LanguageChangedSignal();
+ AppSignalType& LanguageChangedSignal();
public: // Not intended for application developers
/**
Internal::Adaptor::ClipboardEventNotifier::GetImplementation(*this).EmitContentSelectedSignal();
}
-ClipboardEventNotifier::ClipboardEventSignalV2& ClipboardEventNotifier::ContentSelectedSignal()
+ClipboardEventNotifier::ClipboardEventSignalType& ClipboardEventNotifier::ContentSelectedSignal()
{
return Internal::Adaptor::ClipboardEventNotifier::GetImplementation(*this).ContentSelectedSignal();
}
#include <boost/function.hpp>
#include <dali/public-api/object/base-handle.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
/**
* @brief Clipboard event
*/
- typedef SignalV2< void ( ClipboardEventNotifier& ) > ClipboardEventSignalV2;
+ typedef Signal< void ( ClipboardEventNotifier& ) > ClipboardEventSignalType;
/**
* @brief Create an uninitialized handle.
* @endcode
* @return The signal to connect to.
*/
- ClipboardEventSignalV2& ContentSelectedSignal();
+ ClipboardEventSignalType& ContentSelectedSignal();
public: // Not intended for application developers
#include <boost/function.hpp>
#include <dali/public-api/object/base-handle.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
// Typedefs
- typedef SignalV2< void ( DragAndDropDetector ) > DragAndDropSignal; ///< Drag & Drop signal
+ typedef Signal< void ( DragAndDropDetector ) > DragAndDropSignal; ///< Drag & Drop signal
/**
* @brief Create an uninitialized handle.
return Internal::Adaptor::ImfManager::GetImplementation(*this).GetSurroundingText();
}
-ImfManager::ImfManagerSignalV2& ImfManager::ActivatedSignal()
+ImfManager::ImfManagerSignalType& ImfManager::ActivatedSignal()
{
return Internal::Adaptor::ImfManager::GetImplementation(*this).ActivatedSignal();
}
-ImfManager::ImfEventSignalV2& ImfManager::EventReceivedSignal()
+ImfManager::ImfEventSignalType& ImfManager::EventReceivedSignal()
{
return Internal::Adaptor::ImfManager::GetImplementation(*this).EventReceivedSignal();
}
// EXTERNAL INCLUDES
#include <dali/public-api/object/base-handle.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
bool preeditResetRequired; ///< flag if preedit reset is required.
};
- typedef SignalV2< void (ImfManager&) > ImfManagerSignalV2; ///< Keyboard actived signal
+ typedef Signal< void (ImfManager&) > ImfManagerSignalType; ///< Keyboard actived signal
- typedef SignalV2< ImfCallbackData ( ImfManager&, const ImfEventData& ) > ImfEventSignalV2; ///< keyboard events
+ typedef Signal< ImfCallbackData ( ImfManager&, const ImfEventData& ) > ImfEventSignalType; ///< keyboard events
public:
*
* @return The IMF Activated signal.
*/
- ImfManagerSignalV2& ActivatedSignal();
+ ImfManagerSignalType& ActivatedSignal();
/**
* @brief This is emitted when the IMF manager receives an event from the IMF.
*
* @return The Event signal containing the event data.
*/
- ImfEventSignalV2& EventReceivedSignal();
+ ImfEventSignalType& EventReceivedSignal();
// Construction & Destruction
{
}
-LifecycleController::LifecycleSignalV2& LifecycleController::InitSignal()
+LifecycleController::LifecycleSignalType& LifecycleController::InitSignal()
{
return GetImplementation(*this).InitSignal();
}
-LifecycleController::LifecycleSignalV2& LifecycleController::TerminateSignal()
+LifecycleController::LifecycleSignalType& LifecycleController::TerminateSignal()
{
return GetImplementation(*this).TerminateSignal();
}
-LifecycleController::LifecycleSignalV2& LifecycleController::PauseSignal()
+LifecycleController::LifecycleSignalType& LifecycleController::PauseSignal()
{
return GetImplementation(*this).PauseSignal();
}
-LifecycleController::LifecycleSignalV2& LifecycleController::ResumeSignal()
+LifecycleController::LifecycleSignalType& LifecycleController::ResumeSignal()
{
return GetImplementation(*this).ResumeSignal();
}
-LifecycleController::LifecycleSignalV2& LifecycleController::ResetSignal()
+LifecycleController::LifecycleSignalType& LifecycleController::ResetSignal()
{
return GetImplementation(*this).ResetSignal();
}
-LifecycleController::LifecycleSignalV2& LifecycleController::ResizeSignal()
+LifecycleController::LifecycleSignalType& LifecycleController::ResizeSignal()
{
return GetImplementation(*this).ResizeSignal();
}
-LifecycleController::LifecycleSignalV2& LifecycleController::LanguageChangedSignal()
+LifecycleController::LifecycleSignalType& LifecycleController::LanguageChangedSignal()
{
return GetImplementation(*this).LanguageChangedSignal();
}
// EXTERNAL INCLUDES
#include <dali/public-api/object/base-handle.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
{
public: // Typedefs
- typedef SignalV2< void (void) > LifecycleSignalV2; ///< Lifecycle Signal type
+ typedef Signal< void (void) > LifecycleSignalType; ///< Lifecycle Signal type
public: // Creation & Destruction
* The user should connect to this signal to determine when they should initialise
* their application.
*/
- LifecycleSignalV2& InitSignal();
+ LifecycleSignalType& InitSignal();
/**
* The user should connect to this signal to determine when they should terminate
* their application
*/
- LifecycleSignalV2& TerminateSignal();
+ LifecycleSignalType& TerminateSignal();
/**
* The user should connect to this signal if they need to perform any special
* activities when the application is about to be paused.
*/
- LifecycleSignalV2& PauseSignal();
+ LifecycleSignalType& PauseSignal();
/**
* The user should connect to this signal if they need to perform any special
* activities when the application has resumed.
*/
- LifecycleSignalV2& ResumeSignal();
+ LifecycleSignalType& ResumeSignal();
/**
* This signal is sent when the system requires the user to reinitialise itself.
*/
- LifecycleSignalV2& ResetSignal();
+ LifecycleSignalType& ResetSignal();
/**
* This signal is emitted when the window the application is rendering on is resized.
*/
- LifecycleSignalV2& ResizeSignal();
+ LifecycleSignalType& ResizeSignal();
/**
* This signal is emitted when the language is changed on the device.
*/
- LifecycleSignalV2& LanguageChangedSignal();
+ LifecycleSignalType& LanguageChangedSignal();
public: // Operators
return Internal::Adaptor::GetImplementation(*this).GetRadians();
}
-Orientation::OrientationSignalV2& Orientation::ChangedSignal()
+Orientation::OrientationSignalType& Orientation::ChangedSignal()
{
return Internal::Adaptor::GetImplementation(*this).ChangedSignal();
}
// EXTERNAL INCLUDES
#include <boost/function.hpp>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
#include <dali/public-api/object/base-handle.h>
namespace Dali
{
public:
- typedef SignalV2< void (Orientation) > OrientationSignalV2; ///< Orientation changed signal type
+ typedef Signal< void (Orientation) > OrientationSignalType; ///< Orientation changed signal type
/**
* @brief Create an unintialized handle.
*
* @return The orientation change signal.
*/
- OrientationSignalV2& ChangedSignal();
+ OrientationSignalType& ChangedSignal();
public: // Not intended for application developers
/**
return GetImplementation( *this ).IsAttached();
}
-PhysicalKeyboard::Signal& PhysicalKeyboard::StatusChangedSignal()
+PhysicalKeyboard::PhysicalKeyboardSignalType& PhysicalKeyboard::StatusChangedSignal()
{
return GetImplementation( *this ).StatusChangedSignal();
}
// EXTERNAL INCLUDES
#include <dali/public-api/object/base-handle.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
{
public:
- typedef SignalV2< void (PhysicalKeyboard) > Signal;
+ typedef Signal< void (PhysicalKeyboard) > PhysicalKeyboardSignalType;
public:
* @pre The PhysicalKeyboard has been initialized.
* @return The status changed signal.
*/
- Signal& StatusChangedSignal();
+ PhysicalKeyboardSignalType& StatusChangedSignal();
// Not intended for application developers
GetImplementation(*this).Stop(handle);
}
-SoundPlayer::SoundPlayFinishedSignalV2& SoundPlayer::SoundPlayFinishedSignal()
+SoundPlayer::SoundPlayFinishedSignalType& SoundPlayer::SoundPlayFinishedSignal()
{
return GetImplementation(*this).SoundPlayFinishedSignal();
}
// EXTERNAL INCLUDES
#include <dali/public-api/object/base-handle.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
{
public:
- typedef SignalV2< void (SoundPlayer&) > SoundPlayFinishedSignalV2; ///< Sound play finished signal
+ typedef Signal< void (SoundPlayer&) > SoundPlayFinishedSignalType; ///< Sound play finished signal
/**
* @brief Create an uninitialized handle.
*
* @note The signal name is "sound-play-finished" if using BaseHandle::ConnectSignal()
*/
- SoundPlayFinishedSignalV2& SoundPlayFinishedSignal();
+ SoundPlayFinishedSignalType& SoundPlayFinishedSignal();
public: // Not intended for application developers
return GetImplementation(*this).SetTheme(themFilePath);
}
-StyleMonitor::StyleChangeSignalV2& StyleMonitor::StyleChangeSignal()
+StyleMonitor::StyleChangeSignalType& StyleMonitor::StyleChangeSignal()
{
return GetImplementation(*this).StyleChangeSignal();
}
#include <string>
#include <dali/public-api/object/base-handle.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
// INTERNAL INCLUDES
#include "style-change.h"
{
public: // Typedefs
- typedef SignalV2< void (StyleMonitor, StyleChange) > StyleChangeSignalV2; ///< StyleChange Signal type
+ typedef Signal< void (StyleMonitor, StyleChange) > StyleChangeSignalType; ///< StyleChange Signal type
public: // Creation & Destruction
* @endcode
* @return The signal to connect to.
*/
- StyleChangeSignalV2& StyleChangeSignal();
+ StyleChangeSignalType& StyleChangeSignal();
public: // Operators
return GetImplementation(*this).GetRotation();
}
-TiltSensor::TiltedSignalV2& TiltSensor::TiltedSignal()
+TiltSensor::TiltedSignalType& TiltSensor::TiltedSignal()
{
return GetImplementation(*this).TiltedSignal();
}
#include <boost/function.hpp>
#include <dali/public-api/object/base-handle.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
{
public:
- typedef SignalV2< void (const TiltSensor&) > TiltedSignalV2;
+ typedef Signal< void (const TiltSensor&) > TiltedSignalType;
static const float DEFAULT_UPDATE_FREQUENCY; // 60 hertz
*
* @note The signal name is "tilted" if using BaseHandle::ConnectSignal()
*/
- TiltedSignalV2& TiltedSignal();
+ TiltedSignalType& TiltedSignal();
/**
* Set the sensor update frequency.
return Internal::Adaptor::GetImplementation(*this).IsRunning();
}
-Timer::TimerSignalV2& Timer::TickSignal()
+Timer::TimerSignalType& Timer::TickSignal()
{
return Internal::Adaptor::GetImplementation(*this).TickSignal();
}
// EXTERNAL INCLUDES
#include <dali/public-api/object/base-handle.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
{
public: // Signal typedefs
- typedef SignalV2< bool () > TimerSignalV2; ///< Timer finished signal callback type
+ typedef Signal< bool () > TimerSignalType; ///< Timer finished signal callback type
public: // API
* This return value is ignored for one-shot events, which will always stop after the first execution.
* @returns The signal to Connect() with.
*/
- TimerSignalV2& TickSignal();
+ TimerSignalType& TickSignal();
public: // Not intended for application developers
explicit DALI_INTERNAL Timer(Internal::Adaptor::Timer* timer);
Internal::Adaptor::VirtualKeyboard::RotateTo(angle);
}
-StatusSignalV2& StatusChangedSignal()
+StatusSignalType& StatusChangedSignal()
{
return Internal::Adaptor::VirtualKeyboard::StatusChangedSignal();
}
-VoidSignalV2& ResizedSignal()
+VoidSignalType& ResizedSignal()
{
return Internal::Adaptor::VirtualKeyboard::ResizedSignal();
}
-VoidSignalV2& LanguageChangedSignal()
+VoidSignalType& LanguageChangedSignal()
{
return Internal::Adaptor::VirtualKeyboard::LanguageChangedSignal();
}
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
#include <dali/public-api/math/rect.h>
namespace Dali
// Types
-typedef SignalV2< void () > VoidSignalV2;
-typedef SignalV2< void (bool) > StatusSignalV2;
+typedef Signal< void () > VoidSignalType;
+typedef Signal< void (bool) > StatusSignalType;
// Enumerations
* has just been hidden.
* @return The signal to connect to.
*/
-DALI_IMPORT_API StatusSignalV2& StatusChangedSignal();
+DALI_IMPORT_API StatusSignalType& StatusChangedSignal();
/**
* @brief Connect to this signal to be notified when the virtual keyboard is resized.
* User can get changed size by using GetSizeAndPosition() in the callback
* @return The signal to connect to.
*/
-DALI_IMPORT_API VoidSignalV2& ResizedSignal();
+DALI_IMPORT_API VoidSignalType& ResizedSignal();
/**
* @brief Connect to this signal to be notified when the virtual keyboard's language is changed.
* User can get the text direction of the language by calling GetTextDirection() in the callback.
* @return The signal to connect to.
*/
-DALI_IMPORT_API VoidSignalV2& LanguageChangedSignal();
+DALI_IMPORT_API VoidSignalType& LanguageChangedSignal();
} // namespace VirtualKeyboard
GetImplementation(*this).ShowIndicator( visibleMode );
}
-Window::IndicatorSignalV2& Window::IndicatorVisibilityChangedSignal()
+Window::IndicatorSignalType& Window::IndicatorVisibilityChangedSignal()
{
return GetImplementation(*this).IndicatorVisibilityChangedSignal();
}
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/object/any.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
class DALI_IMPORT_API Window : public BaseHandle
{
public:
- typedef SignalV2< void (bool) > IndicatorSignalV2;
+ typedef Signal< void (bool) > IndicatorSignalType;
public:
/**
* The user should connect to this signal to get a timing when indicator was shown / hidden.
*/
- IndicatorSignalV2& IndicatorVisibilityChangedSignal();
+ IndicatorSignalType& IndicatorVisibilityChangedSignal();
public: // Not intended for application developers
/**
*/
if ( !mIndicatorFocused )
{
- if( !mActionClearFocusSignalV2.Empty() )
+ if( !mActionClearFocusSignal.Empty() )
{
- mActionClearFocusSignalV2.Emit( handle );
+ mActionClearFocusSignal.Emit( handle );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionScrollSignalV2.Empty() )
+ if( !mActionScrollSignal.Empty() )
{
- mActionScrollSignalV2.Emit( handle, event );
+ mActionScrollSignal.Emit( handle, event );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionBackSignalV2.Empty() )
+ if( !mActionBackSignal.Empty() )
{
- mActionBackSignalV2.Emit( handle );
+ mActionBackSignal.Emit( handle );
}
}
//emit status changed signal
Dali::AccessibilityManager handle( this );
- mStatusChangedSignalV2.Emit( handle );
+ mStatusChangedSignal.Emit( handle );
}
}
//emit status changed signal
Dali::AccessibilityManager handle( this );
- mStatusChangedSignalV2.Emit( handle );
+ mStatusChangedSignal.Emit( handle );
// Destroy the TtsPlayer if exists.
if ( Adaptor::IsAvailable() )
return mRotation;
}
-TiltSensor::TiltedSignalV2& TiltSensor::TiltedSignal()
+TiltSensor::TiltedSignalType& TiltSensor::TiltedSignal()
{
- return mTiltedSignalV2;
+ return mTiltedSignal;
}
void TiltSensor::SetUpdateFrequency( float frequencyHertz )
mPitch = newPitch;
mRotation = newRotation;
- if ( !mTiltedSignalV2.Empty() )
+ if ( !mTiltedSignal.Empty() )
{
Dali::TiltSensor handle( this );
- mTiltedSignalV2.Emit( handle );
+ mTiltedSignal.Emit( handle );
}
}
{
public:
- typedef Dali::TiltSensor::TiltedSignalV2 TiltedSignalV2;
+ typedef Dali::TiltSensor::TiltedSignalType TiltedSignalType;
/**
* Create a TiltSensor.
/**
* @copydoc Dali::TiltSensor::TiltedSignal()
*/
- TiltedSignalV2& TiltedSignal();
+ TiltedSignalType& TiltedSignal();
/**
* @copydoc Dali::TiltSensor::SetUpdateFrequency()
std::deque<float> mRollValues;
std::deque<float> mPitchValues;
- TiltedSignalV2 mTiltedSignalV2;
+ TiltedSignalType mTiltedSignal;
};
} // namespace Adaptor
*/
if ( !mIndicatorFocused )
{
- if( !mActionClearFocusSignalV2.Empty() )
+ if( !mActionClearFocusSignal.Empty() )
{
- mActionClearFocusSignalV2.Emit( handle );
+ mActionClearFocusSignal.Emit( handle );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionScrollSignalV2.Empty() )
+ if( !mActionScrollSignal.Empty() )
{
- mActionScrollSignalV2.Emit( handle, event );
+ mActionScrollSignal.Emit( handle, event );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionBackSignalV2.Empty() )
+ if( !mActionBackSignal.Empty() )
{
- mActionBackSignalV2.Emit( handle );
+ mActionBackSignal.Emit( handle );
}
}
//emit status changed signal
Dali::AccessibilityManager handle( this );
- mStatusChangedSignalV2.Emit( handle );
+ mStatusChangedSignal.Emit( handle );
}
}
//emit status changed signal
Dali::AccessibilityManager handle( this );
- mStatusChangedSignalV2.Emit( handle );
+ mStatusChangedSignal.Emit( handle );
// Destroy the TtsPlayer if exists.
if ( Adaptor::IsAvailable() )
*/
if( !mIndicatorFocused )
{
- if( !mActionNextSignalV2.Empty() )
+ if( !mActionNextSignal.Empty() )
{
- mActionNextSignalV2.Emit( handle );
+ mActionNextSignal.Emit( handle );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionPreviousSignalV2.Empty() )
+ if( !mActionPreviousSignal.Empty() )
{
- mActionPreviousSignalV2.Emit( handle );
+ mActionPreviousSignal.Emit( handle );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionActivateSignalV2.Empty() )
+ if( !mActionActivateSignal.Empty() )
{
- mActionActivateSignalV2.Emit( handle );
+ mActionActivateSignal.Emit( handle );
}
}
*/
if( !mIndicatorFocused )
{
- if ( !mActionReadSignalV2.Empty() )
+ if ( !mActionReadSignal.Empty() )
{
- mActionReadSignalV2.Emit( handle );
+ mActionReadSignal.Emit( handle );
}
}
}
*/
if( !mIndicatorFocused )
{
- if ( !mActionOverSignalV2.Empty() )
+ if ( !mActionOverSignal.Empty() )
{
- mActionOverSignalV2.Emit( handle );
+ mActionOverSignal.Emit( handle );
}
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionReadNextSignalV2.Empty() )
+ if( !mActionReadNextSignal.Empty() )
{
- mActionReadNextSignalV2.Emit( handle );
+ mActionReadNextSignal.Emit( handle );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionReadPreviousSignalV2.Empty() )
+ if( !mActionReadPreviousSignal.Empty() )
{
- mActionReadPreviousSignalV2.Emit( handle );
+ mActionReadPreviousSignal.Emit( handle );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionUpSignalV2.Empty() )
+ if( !mActionUpSignal.Empty() )
{
- mActionUpSignalV2.Emit( handle );
+ mActionUpSignal.Emit( handle );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionDownSignalV2.Empty() )
+ if( !mActionDownSignal.Empty() )
{
- mActionDownSignalV2.Emit( handle );
+ mActionDownSignal.Emit( handle );
}
}
{
public:
- typedef Dali::AccessibilityManager::AccessibilityActionSignalV2 AccessibilityActionSignalV2;
- typedef Dali::AccessibilityManager::AccessibilityActionScrollSignalV2 AccessibilityActionScrollSignalV2;
+ typedef Dali::AccessibilityManager::AccessibilityActionSignalType AccessibilityActionSignalType;
+ typedef Dali::AccessibilityManager::AccessibilityActionScrollSignalType AccessibilityActionScrollSignalType;
// Creation
/**
* @copydoc Dali::AccessibilityManager::StatusChangedSignal
*/
- AccessibilityActionSignalV2& StatusChangedSignal()
+ AccessibilityActionSignalType& StatusChangedSignal()
{
- return mStatusChangedSignalV2;
+ return mStatusChangedSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionNextSignal
*/
- AccessibilityActionSignalV2& ActionNextSignal()
+ AccessibilityActionSignalType& ActionNextSignal()
{
- return mActionNextSignalV2;
+ return mActionNextSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionPreviousSignal
*/
- AccessibilityActionSignalV2& ActionPreviousSignal()
+ AccessibilityActionSignalType& ActionPreviousSignal()
{
- return mActionPreviousSignalV2;
+ return mActionPreviousSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionActivateSignal
*/
- AccessibilityActionSignalV2& ActionActivateSignal()
+ AccessibilityActionSignalType& ActionActivateSignal()
{
- return mActionActivateSignalV2;
+ return mActionActivateSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionOverSignal
*/
- AccessibilityActionSignalV2& ActionOverSignal()
+ AccessibilityActionSignalType& ActionOverSignal()
{
- return mActionOverSignalV2;
+ return mActionOverSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionReadSignal
*/
- AccessibilityActionSignalV2& ActionReadSignal()
+ AccessibilityActionSignalType& ActionReadSignal()
{
- return mActionReadSignalV2;
+ return mActionReadSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionReadNextSignal
*/
- AccessibilityActionSignalV2& ActionReadNextSignal()
+ AccessibilityActionSignalType& ActionReadNextSignal()
{
- return mActionReadNextSignalV2;
+ return mActionReadNextSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionReadPreviousSignal
*/
- AccessibilityActionSignalV2& ActionReadPreviousSignal()
+ AccessibilityActionSignalType& ActionReadPreviousSignal()
{
- return mActionReadPreviousSignalV2;
+ return mActionReadPreviousSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionUpSignal
*/
- AccessibilityActionSignalV2& ActionUpSignal()
+ AccessibilityActionSignalType& ActionUpSignal()
{
- return mActionUpSignalV2;
+ return mActionUpSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionDownSignal
*/
- AccessibilityActionSignalV2& ActionDownSignal()
+ AccessibilityActionSignalType& ActionDownSignal()
{
- return mActionDownSignalV2;
+ return mActionDownSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionClearFocusSignal
*/
- AccessibilityActionSignalV2& ActionClearFocusSignal()
+ AccessibilityActionSignalType& ActionClearFocusSignal()
{
- return mActionClearFocusSignalV2;
+ return mActionClearFocusSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionBackSignal
*/
- AccessibilityActionSignalV2& ActionBackSignal()
+ AccessibilityActionSignalType& ActionBackSignal()
{
- return mActionBackSignalV2;
+ return mActionBackSignal;
}
/**
* @copydoc Dali::AccessibilityManager::ActionScrollSignal
*/
- AccessibilityActionScrollSignalV2& ActionScrollSignal()
+ AccessibilityActionScrollSignalType& ActionScrollSignal()
{
- return mActionScrollSignalV2;
+ return mActionScrollSignal;
}
private:
Indicator* mIndicator; ///< The indicator
bool mIndicatorFocused; ///< Whether the Indicator is focused
- AccessibilityActionSignalV2 mStatusChangedSignalV2;
- AccessibilityActionSignalV2 mActionNextSignalV2;
- AccessibilityActionSignalV2 mActionPreviousSignalV2;
- AccessibilityActionSignalV2 mActionActivateSignalV2;
- AccessibilityActionSignalV2 mActionOverSignalV2;
- AccessibilityActionSignalV2 mActionReadSignalV2;
- AccessibilityActionSignalV2 mActionReadNextSignalV2;
- AccessibilityActionSignalV2 mActionReadPreviousSignalV2;
- AccessibilityActionSignalV2 mActionUpSignalV2;
- AccessibilityActionSignalV2 mActionDownSignalV2;
- AccessibilityActionSignalV2 mActionClearFocusSignalV2;
- AccessibilityActionSignalV2 mActionBackSignalV2;
- AccessibilityActionScrollSignalV2 mActionScrollSignalV2;
+ AccessibilityActionSignalType mStatusChangedSignal;
+ AccessibilityActionSignalType mActionNextSignal;
+ AccessibilityActionSignalType mActionPreviousSignal;
+ AccessibilityActionSignalType mActionActivateSignal;
+ AccessibilityActionSignalType mActionOverSignal;
+ AccessibilityActionSignalType mActionReadSignal;
+ AccessibilityActionSignalType mActionReadNextSignal;
+ AccessibilityActionSignalType mActionReadPreviousSignal;
+ AccessibilityActionSignalType mActionUpSignal;
+ AccessibilityActionSignalType mActionDownSignal;
+ AccessibilityActionSignalType mActionClearFocusSignal;
+ AccessibilityActionSignalType mActionBackSignal;
+ AccessibilityActionScrollSignalType mActionScrollSignal;
public:
return mRotation;
}
-TiltSensor::TiltedSignalV2& TiltSensor::TiltedSignal()
+TiltSensor::TiltedSignalType& TiltSensor::TiltedSignal()
{
- return mTiltedSignalV2;
+ return mTiltedSignal;
}
void TiltSensor::SetUpdateFrequency( float frequencyHertz )
mPitch = newPitch;
mRotation = newRotation;
- if ( !mTiltedSignalV2.Empty() )
+ if ( !mTiltedSignal.Empty() )
{
Dali::TiltSensor handle( this );
- mTiltedSignalV2.Emit( handle );
+ mTiltedSignal.Emit( handle );
}
}
{
public:
- typedef Dali::TiltSensor::TiltedSignalV2 TiltedSignalV2;
+ typedef Dali::TiltSensor::TiltedSignalType TiltedSignalType;
/**
* Create a TiltSensor.
/**
* @copydoc Dali::TiltSensor::TiltedSignal()
*/
- TiltedSignalV2& TiltedSignal();
+ TiltedSignalType& TiltedSignal();
/**
* @copydoc Dali::TiltSensor::SetUpdateFrequency()
std::deque<float> mRollValues;
std::deque<float> mPitchValues;
- TiltedSignalV2 mTiltedSignalV2;
+ TiltedSignalType mTiltedSignal;
};
} // namespace Adaptor
*/
if( !mIndicatorFocused )
{
- if( !mActionNextSignalV2.Empty() )
+ if( !mActionNextSignal.Empty() )
{
- mActionNextSignalV2.Emit( handle );
+ mActionNextSignal.Emit( handle );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionPreviousSignalV2.Empty() )
+ if( !mActionPreviousSignal.Empty() )
{
- mActionPreviousSignalV2.Emit( handle );
+ mActionPreviousSignal.Emit( handle );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionActivateSignalV2.Empty() )
+ if( !mActionActivateSignal.Empty() )
{
- mActionActivateSignalV2.Emit( handle );
+ mActionActivateSignal.Emit( handle );
}
}
*/
if( !mIndicatorFocused )
{
- if ( !mActionReadSignalV2.Empty() )
+ if ( !mActionReadSignal.Empty() )
{
- mActionReadSignalV2.Emit( handle );
+ mActionReadSignal.Emit( handle );
}
}
}
*/
if( !mIndicatorFocused )
{
- if ( !mActionOverSignalV2.Empty() )
+ if ( !mActionOverSignal.Empty() )
{
- mActionOverSignalV2.Emit( handle );
+ mActionOverSignal.Emit( handle );
}
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionReadNextSignalV2.Empty() )
+ if( !mActionReadNextSignal.Empty() )
{
- mActionReadNextSignalV2.Emit( handle );
+ mActionReadNextSignal.Emit( handle );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionReadPreviousSignalV2.Empty() )
+ if( !mActionReadPreviousSignal.Empty() )
{
- mActionReadPreviousSignalV2.Emit( handle );
+ mActionReadPreviousSignal.Emit( handle );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionUpSignalV2.Empty() )
+ if( !mActionUpSignal.Empty() )
{
- mActionUpSignalV2.Emit( handle );
+ mActionUpSignal.Emit( handle );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionDownSignalV2.Empty() )
+ if( !mActionDownSignal.Empty() )
{
- mActionDownSignalV2.Emit( handle );
+ mActionDownSignal.Emit( handle );
}
}
class ImfManager : public Dali::BaseObject
{
public:
- typedef Dali::ImfManager::ImfManagerSignalV2 ImfManagerSignalV2;
- typedef Dali::ImfManager::ImfEventSignalV2 ImfEventSignalV2;
+ typedef Dali::ImfManager::ImfManagerSignalType ImfManagerSignalType;
+ typedef Dali::ImfManager::ImfEventSignalType ImfEventSignalType;
public:
/**
* @copydoc Dali::ImfManager::ActivatedSignal()
*/
- ImfManagerSignalV2& ActivatedSignal() { return mActivatedSignalV2; }
+ ImfManagerSignalType& ActivatedSignal() { return mActivatedSignal; }
/**
* @copydoc Dali::ImfManager::EventReceivedSignal()
*/
- ImfEventSignalV2& EventReceivedSignal() { return mEventSignalV2; }
+ ImfEventSignalType& EventReceivedSignal() { return mEventSignal; }
protected:
std::vector<Dali::Integration::KeyEvent> mKeyEvents; ///< Stores key events to be sent from idle call-back.
- ImfManagerSignalV2 mActivatedSignalV2;
- ImfEventSignalV2 mEventSignalV2;
+ ImfManagerSignalType mActivatedSignal;
+ ImfEventSignalType mEventSignal;
public:
void Window::IndicatorVisibilityChanged(bool isVisible)
{
- mIndicatorVisibilityChangedSignalV2.Emit(isVisible);
+ mIndicatorVisibilityChangedSignal.Emit(isVisible);
}
void Window::SetIndicatorActorRotation()
*/
if( !mIndicatorFocused )
{
- if( !mActionNextSignalV2.Empty() )
+ if( !mActionNextSignal.Empty() )
{
- mActionNextSignalV2.Emit( handle );
+ mActionNextSignal.Emit( handle );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionPreviousSignalV2.Empty() )
+ if( !mActionPreviousSignal.Empty() )
{
- mActionPreviousSignalV2.Emit( handle );
+ mActionPreviousSignal.Emit( handle );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionActivateSignalV2.Empty() )
+ if( !mActionActivateSignal.Empty() )
{
- mActionActivateSignalV2.Emit( handle );
+ mActionActivateSignal.Emit( handle );
}
}
*/
if( !mIndicatorFocused )
{
- if ( !mActionReadSignalV2.Empty() )
+ if ( !mActionReadSignal.Empty() )
{
- mActionReadSignalV2.Emit( handle );
+ mActionReadSignal.Emit( handle );
}
}
}
*/
if( !mIndicatorFocused )
{
- if ( !mActionOverSignalV2.Empty() )
+ if ( !mActionOverSignal.Empty() )
{
- mActionOverSignalV2.Emit( handle );
+ mActionOverSignal.Emit( handle );
}
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionReadNextSignalV2.Empty() )
+ if( !mActionReadNextSignal.Empty() )
{
- mActionReadNextSignalV2.Emit( handle );
+ mActionReadNextSignal.Emit( handle );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionReadPreviousSignalV2.Empty() )
+ if( !mActionReadPreviousSignal.Empty() )
{
- mActionReadPreviousSignalV2.Emit( handle );
+ mActionReadPreviousSignal.Emit( handle );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionUpSignalV2.Empty() )
+ if( !mActionUpSignal.Empty() )
{
- mActionUpSignalV2.Emit( handle );
+ mActionUpSignal.Emit( handle );
}
}
*/
if ( !mIndicatorFocused )
{
- if( !mActionDownSignalV2.Empty() )
+ if( !mActionDownSignal.Empty() )
{
- mActionDownSignalV2.Emit( handle );
+ mActionDownSignal.Emit( handle );
}
}
// emit keyboard activated signal
Dali::ImfManager handle( this );
- mActivatedSignalV2.Emit( handle );
+ mActivatedSignal.Emit( handle );
}
}
Dali::ImfManager handle( this );
Dali::ImfManager::ImfEventData imfEventData ( Dali::ImfManager::PREEDIT, keyString, cursorPosition, numberOfChars );
- Dali::ImfManager::ImfCallbackData callbackData = mEventSignalV2.Emit( handle, imfEventData );
+ Dali::ImfManager::ImfCallbackData callbackData = mEventSignal.Emit( handle, imfEventData );
if ( callbackData.update )
{
Dali::ImfManager handle( this );
Dali::ImfManager::ImfEventData imfEventData ( Dali::ImfManager::COMMIT, keyString, cursorOffset, numberOfChars );
- Dali::ImfManager::ImfCallbackData callbackData = mEventSignalV2.Emit( handle, imfEventData );
+ Dali::ImfManager::ImfCallbackData callbackData = mEventSignal.Emit( handle, imfEventData );
if ( callbackData.update )
{
Dali::ImfManager::ImfEventData imfData ( Dali::ImfManager::GETSURROUNDING , keyString, cursorOffset, numberOfChars );
Dali::ImfManager handle( this );
- mEventSignalV2.Emit( handle, imfData );
+ mEventSignal.Emit( handle, imfData );
if ( text )
{
Dali::ImfManager::ImfEventData imfData ( Dali::ImfManager::DELETESURROUNDING , keyString, cursorOffset, numberOfChars );
Dali::ImfManager handle( this );
- mEventSignalV2.Emit( handle, imfData );
+ mEventSignal.Emit( handle, imfData );
}
}
class ImfManager : public Dali::BaseObject
{
public:
- typedef Dali::ImfManager::ImfManagerSignalV2 ImfManagerSignalV2;
- typedef Dali::ImfManager::ImfEventSignalV2 ImfEventSignalV2;
+ typedef Dali::ImfManager::ImfManagerSignalType ImfManagerSignalType;
+ typedef Dali::ImfManager::ImfEventSignalType ImfEventSignalType;
public:
/**
* @copydoc Dali::ImfManager::ActivatedSignal()
*/
- ImfManagerSignalV2& ActivatedSignal() { return mActivatedSignalV2; }
+ ImfManagerSignalType& ActivatedSignal() { return mActivatedSignal; }
/**
* @copydoc Dali::ImfManager::EventReceivedSignal()
*/
- ImfEventSignalV2& EventReceivedSignal() { return mEventSignalV2; }
+ ImfEventSignalType& EventReceivedSignal() { return mEventSignal; }
protected:
std::vector<Dali::Integration::KeyEvent> mKeyEvents; ///< Stores key events to be sent from idle call-back.
- ImfManagerSignalV2 mActivatedSignalV2;
- ImfEventSignalV2 mEventSignalV2;
+ ImfManagerSignalType mActivatedSignal;
+ ImfEventSignalType mEventSignal;
public:
void Window::IndicatorVisibilityChanged(bool isVisible)
{
- mIndicatorVisibilityChangedSignalV2.Emit(isVisible);
+ mIndicatorVisibilityChangedSignal.Emit(isVisible);
}
void Window::SetIndicatorActorRotation()
projects / platform / core / uifw / dali-adaptor.git / commitdiff