{
public:
// PushButton Pressed
- typedef SignalV2< bool ( Button ) > PressedSignalV2;
+ typedef Signal< bool ( Button ) > PressedSignalType;
- PressedSignalV2& PressedSignal();
+ PressedSignalType& PressedSignal();
/**
* Default constructor.
/**
* @return the pressed signal.
*/
- Toolkit::TETButton::PressedSignalV2& PressedSignal();
+ Toolkit::TETButton::PressedSignalType& PressedSignal();
/**
* Callback called when an interrupt events is received.
*/
void OnButtonDown();
- Toolkit::TETButton::PressedSignalV2 mPressedSignal; ///< Signal emitted when the button is pressed.
+ Toolkit::TETButton::PressedSignalType mPressedSignal; ///< Signal emitted when the button is pressed.
};
} // namespace Internal
return Control::DownCast<TETButton, Internal::TETButton>(handle);
}
-TETButton::PressedSignalV2& TETButton::PressedSignal()
+TETButton::PressedSignalType& TETButton::PressedSignal()
{
TETButton button( *this );
DALI_ASSERT_ALWAYS( button );
return tetButton;
}
-Toolkit::TETButton::PressedSignalV2& TETButton::PressedSignal()
+Toolkit::TETButton::PressedSignalType& TETButton::PressedSignal()
{
return mPressedSignal;
}
public: // Signals
- Dali::AccessibilityManager::AccessibilityActionSignalV2& StatusChangedSignal();
- Dali::AccessibilityManager::AccessibilityActionSignalV2& ActionNextSignal();
- Dali::AccessibilityManager::AccessibilityActionSignalV2& ActionPreviousSignal();
- Dali::AccessibilityManager::AccessibilityActionSignalV2& ActionActivateSignal();
- Dali::AccessibilityManager::AccessibilityActionSignalV2& ActionReadSignal();
- Dali::AccessibilityManager::AccessibilityActionSignalV2& ActionReadNextSignal();
- Dali::AccessibilityManager::AccessibilityActionSignalV2& ActionReadPreviousSignal();
- Dali::AccessibilityManager::AccessibilityActionSignalV2& ActionOverSignal();
- Dali::AccessibilityManager::AccessibilityActionSignalV2& ActionUpSignal();
- Dali::AccessibilityManager::AccessibilityActionSignalV2& ActionDownSignal();
- Dali::AccessibilityManager::AccessibilityActionSignalV2& ActionClearFocusSignal();
- Dali::AccessibilityManager::AccessibilityActionSignalV2& ActionBackSignal();
- Dali::AccessibilityManager::AccessibilityActionSignalV2& ActionControlPanelOpenSignal();
+ Dali::AccessibilityManager::AccessibilityActionSignalType& StatusChangedSignal();
+ Dali::AccessibilityManager::AccessibilityActionSignalType& ActionNextSignal();
+ Dali::AccessibilityManager::AccessibilityActionSignalType& ActionPreviousSignal();
+ Dali::AccessibilityManager::AccessibilityActionSignalType& ActionActivateSignal();
+ Dali::AccessibilityManager::AccessibilityActionSignalType& ActionReadSignal();
+ Dali::AccessibilityManager::AccessibilityActionSignalType& ActionReadNextSignal();
+ Dali::AccessibilityManager::AccessibilityActionSignalType& ActionReadPreviousSignal();
+ Dali::AccessibilityManager::AccessibilityActionSignalType& ActionOverSignal();
+ Dali::AccessibilityManager::AccessibilityActionSignalType& ActionUpSignal();
+ Dali::AccessibilityManager::AccessibilityActionSignalType& ActionDownSignal();
+ Dali::AccessibilityManager::AccessibilityActionSignalType& ActionClearFocusSignal();
+ Dali::AccessibilityManager::AccessibilityActionSignalType& ActionBackSignal();
+ Dali::AccessibilityManager::AccessibilityActionSignalType& ActionControlPanelOpenSignal();
private:
- Dali::AccessibilityManager::AccessibilityActionSignalV2 mStatusChangedSignal;
- Dali::AccessibilityManager::AccessibilityActionSignalV2 mActionNextSignal;
- Dali::AccessibilityManager::AccessibilityActionSignalV2 mActionPreviousSignal;
- Dali::AccessibilityManager::AccessibilityActionSignalV2 mActionActivateSignal;
- Dali::AccessibilityManager::AccessibilityActionSignalV2 mActionReadSignal;
- Dali::AccessibilityManager::AccessibilityActionSignalV2 mActionReadNextSignal;
- Dali::AccessibilityManager::AccessibilityActionSignalV2 mActionReadPreviousSignal;
- Dali::AccessibilityManager::AccessibilityActionSignalV2 mActionOverSignal;
- Dali::AccessibilityManager::AccessibilityActionSignalV2 mActionUpSignal;
- Dali::AccessibilityManager::AccessibilityActionSignalV2 mActionDownSignal;
- Dali::AccessibilityManager::AccessibilityActionSignalV2 mActionClearFocusSignal;
- Dali::AccessibilityManager::AccessibilityActionSignalV2 mActionBackSignal;
- Dali::AccessibilityManager::AccessibilityActionSignalV2 mActionControlPanelOpenSignal;
+ Dali::AccessibilityManager::AccessibilityActionSignalType mStatusChangedSignal;
+ Dali::AccessibilityManager::AccessibilityActionSignalType mActionNextSignal;
+ Dali::AccessibilityManager::AccessibilityActionSignalType mActionPreviousSignal;
+ Dali::AccessibilityManager::AccessibilityActionSignalType mActionActivateSignal;
+ Dali::AccessibilityManager::AccessibilityActionSignalType mActionReadSignal;
+ Dali::AccessibilityManager::AccessibilityActionSignalType mActionReadNextSignal;
+ Dali::AccessibilityManager::AccessibilityActionSignalType mActionReadPreviousSignal;
+ Dali::AccessibilityManager::AccessibilityActionSignalType mActionOverSignal;
+ Dali::AccessibilityManager::AccessibilityActionSignalType mActionUpSignal;
+ Dali::AccessibilityManager::AccessibilityActionSignalType mActionDownSignal;
+ Dali::AccessibilityManager::AccessibilityActionSignalType mActionClearFocusSignal;
+ Dali::AccessibilityManager::AccessibilityActionSignalType mActionBackSignal;
+ Dali::AccessibilityManager::AccessibilityActionSignalType mActionControlPanelOpenSignal;
bool mIsEnabled;
Dali::AccessibilityActionHandler* mActionHandler;
mGestureHandler = &handler;
}
-Dali::AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::StatusChangedSignal()
+Dali::AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::StatusChangedSignal()
{
return mStatusChangedSignal;
}
-Dali::AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionNextSignal()
+Dali::AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionNextSignal()
{
return mActionNextSignal;
}
-Dali::AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionPreviousSignal()
+Dali::AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionPreviousSignal()
{
return mActionPreviousSignal;
}
-Dali::AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionActivateSignal()
+Dali::AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionActivateSignal()
{
return mActionActivateSignal;
}
-Dali::AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionReadSignal()
+Dali::AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionReadSignal()
{
return mActionReadSignal;
}
-Dali::AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionReadNextSignal()
+Dali::AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionReadNextSignal()
{
return mActionReadNextSignal;
}
-Dali::AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionReadPreviousSignal()
+Dali::AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionReadPreviousSignal()
{
return mActionReadPreviousSignal;
}
-Dali::AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionOverSignal()
+Dali::AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionOverSignal()
{
return mActionOverSignal;
}
-Dali::AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionUpSignal()
+Dali::AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionUpSignal()
{
return mActionUpSignal;
}
-Dali::AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionDownSignal()
+Dali::AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionDownSignal()
{
return mActionDownSignal;
}
-Dali::AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionClearFocusSignal()
+Dali::AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionClearFocusSignal()
{
return mActionClearFocusSignal;
}
-Dali::AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionBackSignal()
+Dali::AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionBackSignal()
{
return mActionBackSignal;
}
-Dali::AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionControlPanelOpenSignal()
+Dali::AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionControlPanelOpenSignal()
{
return mActionControlPanelOpenSignal;
}
//Internal::Adaptor::GetImplementation(*this).HandleActionDisableEvent();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::StatusChangedSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::StatusChangedSignal()
{
return Internal::Adaptor::GetImplementation(*this).StatusChangedSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionNextSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionNextSignal()
{
return Internal::Adaptor::GetImplementation(*this).ActionNextSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionPreviousSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionPreviousSignal()
{
return Internal::Adaptor::GetImplementation(*this).ActionPreviousSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionActivateSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionActivateSignal()
{
return Internal::Adaptor::GetImplementation(*this).ActionActivateSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionOverSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionOverSignal()
{
return Internal::Adaptor::GetImplementation(*this).ActionOverSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionReadSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionReadSignal()
{
return Internal::Adaptor::GetImplementation(*this).ActionReadSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionReadNextSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionReadNextSignal()
{
return Internal::Adaptor::GetImplementation(*this).ActionReadNextSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionReadPreviousSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionReadPreviousSignal()
{
return Internal::Adaptor::GetImplementation(*this).ActionReadPreviousSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionUpSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionUpSignal()
{
return Internal::Adaptor::GetImplementation(*this).ActionUpSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionDownSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionDownSignal()
{
return Internal::Adaptor::GetImplementation(*this).ActionDownSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionClearFocusSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionClearFocusSignal()
{
return Internal::Adaptor::GetImplementation(*this).ActionClearFocusSignal();
}
-AccessibilityManager::AccessibilityActionSignalV2& AccessibilityManager::ActionBackSignal()
+AccessibilityManager::AccessibilityActionSignalType& AccessibilityManager::ActionBackSignal()
{
return Internal::Adaptor::GetImplementation(*this).ActionBackSignal();
}
#include <string>
#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-point.h>
namespace Dali
class AccessibilityManager : public BaseHandle
{
public: // Typedefs
- typedef SignalV2< bool ( AccessibilityManager& ) > AccessibilityActionSignalV2;
+ typedef Signal< bool ( AccessibilityManager& ) > AccessibilityActionSignalType;
public: // Construction & Destruction
AccessibilityManager();
void HandleActionDisableEvent();
public: // Signals
- AccessibilityActionSignalV2& StatusChangedSignal();
- AccessibilityActionSignalV2& ActionNextSignal();
- AccessibilityActionSignalV2& ActionPreviousSignal();
- AccessibilityActionSignalV2& ActionActivateSignal();
- AccessibilityActionSignalV2& ActionReadSignal();
- AccessibilityActionSignalV2& ActionOverSignal();
- AccessibilityActionSignalV2& ActionReadNextSignal();
- AccessibilityActionSignalV2& ActionReadPreviousSignal();
- AccessibilityActionSignalV2& ActionUpSignal();
- AccessibilityActionSignalV2& ActionDownSignal();
- AccessibilityActionSignalV2& ActionClearFocusSignal();
- AccessibilityActionSignalV2& ActionBackSignal();
+ AccessibilityActionSignalType& StatusChangedSignal();
+ AccessibilityActionSignalType& ActionNextSignal();
+ AccessibilityActionSignalType& ActionPreviousSignal();
+ AccessibilityActionSignalType& ActionActivateSignal();
+ AccessibilityActionSignalType& ActionReadSignal();
+ AccessibilityActionSignalType& ActionOverSignal();
+ AccessibilityActionSignalType& ActionReadNextSignal();
+ AccessibilityActionSignalType& ActionReadPreviousSignal();
+ AccessibilityActionSignalType& ActionUpSignal();
+ AccessibilityActionSignalType& ActionDownSignal();
+ AccessibilityActionSignalType& ActionClearFocusSignal();
+ AccessibilityActionSignalType& ActionBackSignal();
AccessibilityManager( Internal::Adaptor::AccessibilityManager* manager );
};
#include <boost/any.hpp>
#include <dali/public-api/common/dali-common.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
#include <dali/public-api/adaptor-framework/orientation.h>
namespace Dali
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/object/base-object.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
{
public:
- typedef Dali::ClipboardEventNotifier::ClipboardEventSignalV2 ClipboardEventSignalV2;
+ typedef Dali::ClipboardEventNotifier::ClipboardEventSignalType ClipboardEventSignalType;
// Creation
static Dali::ClipboardEventNotifier New();
void EmitContentSelectedSignal();
// Signals
- ClipboardEventSignalV2& ContentSelectedSignal()
+ ClipboardEventSignalType& ContentSelectedSignal()
{
- return mContentSelectedSignalV2;
+ return mContentSelectedSignal;
}
private:
private:
std::string mContent; ///< The current selected content.
- ClipboardEventSignalV2 mContentSelectedSignalV2;
+ ClipboardEventSignalType mContentSelectedSignal;
static Dali::ClipboardEventNotifier mToolkitClipboardEventNotifier;
void ClipboardEventNotifier::EmitContentSelectedSignal()
{
- if ( !mContentSelectedSignalV2.Empty() )
+ if ( !mContentSelectedSignal.Empty() )
{
Dali::ClipboardEventNotifier handle( this );
- mContentSelectedSignalV2.Emit( handle );
+ mContentSelectedSignal.Emit( handle );
}
}
Internal::Adaptor::ClipboardEventNotifier::GetImplementation(*this).EmitContentSelectedSignal();
}
-ClipboardEventNotifier::ClipboardEventSignalV2& ClipboardEventNotifier::ContentSelectedSignal()
+ClipboardEventNotifier::ClipboardEventSignalType& ClipboardEventNotifier::ContentSelectedSignal()
{
return Internal::Adaptor::ClipboardEventNotifier::GetImplementation(*this).ContentSelectedSignal();
}
// PUBLIC INCLUDES
#define __DALI_CLIPBOARD_EVENT_NOTIFIER_H__
#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
class ClipboardEventNotifier : public BaseHandle
{
public:
- typedef SignalV2< void ( ClipboardEventNotifier& ) > ClipboardEventSignalV2;
+ typedef Signal< void ( ClipboardEventNotifier& ) > ClipboardEventSignalType;
ClipboardEventNotifier();
static ClipboardEventNotifier Get();
void ClearContent();
void EmitContentSelectedSignal();
- ClipboardEventSignalV2& ContentSelectedSignal();
+ ClipboardEventSignalType& ContentSelectedSignal();
ClipboardEventNotifier( Internal::Adaptor::ClipboardEventNotifier* notifier );
};
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:
static Dali::ImfManager Get();
std::string GetSurroundingText();
public: // Signals
- ImfManagerSignalV2& ActivatedSignal() { return mActivatedSignalV2; }
- ImfEventSignalV2& EventReceivedSignal() { return mEventSignalV2; }
+ ImfManagerSignalType& ActivatedSignal() { return mActivatedSignal; }
+ ImfEventSignalType& EventReceivedSignal() { return mEventSignal; }
protected:
virtual ~ImfManager();
bool mIdleCallbackConnected:1; ///< Whether the idle callback is already connected.
std::vector<Dali::Integration::KeyEvent> mKeyEvents; ///< Stores key events to be sent from idle call-back.
- ImfManagerSignalV2 mActivatedSignalV2;
- ImfEventSignalV2 mEventSignalV2;
+ ImfManagerSignalType mActivatedSignal;
+ ImfEventSignalType mEventSignal;
static Dali::ImfManager mToolkitImfManager;
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
#define __DALI_IMF_MANAGER_H__
#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 DALI_IMPORT_API
{
bool preeditResetRequired; // flag if preedit reset is required.
};
- typedef SignalV2< void (ImfManager&) > ImfManagerSignalV2;
+ typedef Signal< void (ImfManager&) > ImfManagerSignalType;
- typedef SignalV2< ImfCallbackData ( ImfManager&, const ImfEventData& ) > ImfEventSignalV2;
+ typedef Signal< ImfCallbackData ( ImfManager&, const ImfEventData& ) > ImfEventSignalType;
public:
* This is emitted when the virtual keyboard is connected to or the hardware keyboard is activated.
* @return The IMF Activated signal.
*/
- ImfManagerSignalV2& ActivatedSignal();
+ ImfManagerSignalType& ActivatedSignal();
/**
* 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
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/object/base-object.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
public: // Signals
- Dali::Orientation::OrientationSignalV2& ChangedSignal();
+ Dali::Orientation::OrientationSignalType& ChangedSignal();
void EmitChangedSignal()
{
private:
- Dali::Orientation::OrientationSignalV2 mChangedSignal;
+ Dali::Orientation::OrientationSignalType mChangedSignal;
ToolkitOrientation* mToolkitOrientation;
return Math::PI * (float)mOrientation / 180.0f;
}
-Dali::Orientation::OrientationSignalV2& Orientation::ChangedSignal()
+Dali::Orientation::OrientationSignalType& Orientation::ChangedSignal()
{
mToolkitOrientation->mFunctionsCalled.ChangedSignal = true;
return mChangedSignal;
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/object/base-object.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
bool IsAttached() const;
public: // Signals
- Dali::PhysicalKeyboard::Signal& StatusChangedSignal();
+ Dali::PhysicalKeyboard::PhysicalKeyboardSignalType& StatusChangedSignal();
private:
- Dali::PhysicalKeyboard::Signal mStatusChangedSignal;
+ Dali::PhysicalKeyboard::PhysicalKeyboardSignalType mStatusChangedSignal;
bool mIsAttached;
static Dali::PhysicalKeyboard mPhysicalKeyboard;
};
return mIsAttached;
}
-Dali::PhysicalKeyboard::Signal& PhysicalKeyboard::StatusChangedSignal()
+Dali::PhysicalKeyboard::PhysicalKeyboardSignalType& PhysicalKeyboard::StatusChangedSignal()
{
return mStatusChangedSignal;
}
return pyke.IsAttached();
}
-PhysicalKeyboard::Signal& PhysicalKeyboard::StatusChangedSignal()
+PhysicalKeyboard::PhysicalKeyboardSignalType& PhysicalKeyboard::StatusChangedSignal()
{
BaseObject& object = GetBaseObject();
Internal::Adaptor::PhysicalKeyboard& pyke = static_cast< Internal::Adaptor::PhysicalKeyboard& >( object );
// EXTERNAL INCLUDES
#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>
namespace Dali
{
class PhysicalKeyboard : public BaseHandle
{
public:
- typedef SignalV2< void (PhysicalKeyboard) > Signal;
+ typedef Signal< void (PhysicalKeyboard) > PhysicalKeyboardSignalType;
PhysicalKeyboard();
~PhysicalKeyboard();
static PhysicalKeyboard Get();
bool IsAttached() const;
- Signal& StatusChangedSignal();
+ PhysicalKeyboardSignalType& StatusChangedSignal();
PhysicalKeyboard( Internal::Adaptor::PhysicalKeyboard* impl );
};
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/object/base-object.h>
#include <dali/public-api/common/map-wrapper.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/object/base-object.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
void SetTheme(std::string theme);
public: // Signals
- Dali::StyleMonitor::StyleChangeSignalV2& StyleChangeSignal();
+ Dali::StyleMonitor::StyleChangeSignalType& StyleChangeSignal();
void EmitStyleChangeSignal(StyleChange styleChange)
{
}
private:
- Dali::StyleMonitor::StyleChangeSignalV2 mStyleChangeSignal;
+ Dali::StyleMonitor::StyleChangeSignalType mStyleChangeSignal;
static Dali::StyleMonitor mToolkitStyleMonitor;
std::string mTheme;
};
EmitStyleChangeSignal(styleChange);
}
-Dali::StyleMonitor::StyleChangeSignalV2& StyleMonitor::StyleChangeSignal()
+Dali::StyleMonitor::StyleChangeSignalType& StyleMonitor::StyleChangeSignal()
{
return mStyleChangeSignal;
}
GetImplementation(*this).SetTheme(themeFilePath);
}
-StyleMonitor::StyleChangeSignalV2& StyleMonitor::StyleChangeSignal()
+StyleMonitor::StyleChangeSignalType& StyleMonitor::StyleChangeSignal()
{
return GetImplementation(*this).StyleChangeSignal();
}
// INTERNAL INCLUDES
#define __DALI_STYLE_MONITOR_H__
#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/adaptor-framework/style-change.h>
namespace Dali
class StyleMonitor : public BaseHandle
{
public: // Typedefs
- typedef SignalV2< void (StyleMonitor, StyleChange) > StyleChangeSignalV2;
+ typedef Signal< void (StyleMonitor, StyleChange) > StyleChangeSignalType;
static const std::string DEFAULT_FONT_FAMILY;
static const float DEFAULT_FONT_SIZE;
void SetTheme(std::string themeFilePath);
public: // Signals
- StyleChangeSignalV2& StyleChangeSignal();
+ StyleChangeSignalType& StyleChangeSignal();
void EmitStyleChangeSignal(StyleChange handle);
public: // Operators
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/object/base-object.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
public: // Signals
- Dali::Timer::TimerSignalV2& TickSignal();
+ Dali::Timer::TimerSignalType& TickSignal();
private: // Implementation
private: // Data
- Dali::Timer::TimerSignalV2 mTickSignal;
+ Dali::Timer::TimerSignalType mTickSignal;
unsigned int mInterval;
};
return false;
}
-Dali::Timer::TimerSignalV2& Timer::TickSignal()
+Dali::Timer::TimerSignalType& Timer::TickSignal()
{
return mTickSignal;
}
return true;
}
-Timer::TimerSignalV2& Timer::TickSignal()
+Timer::TimerSignalType& Timer::TickSignal()
{
return Internal::Adaptor::GetImplementation( *this ).TickSignal();
}
// PUBLIC INCLUDES
#define __DALI_TIMER_H__
#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
{
class Timer : public BaseHandle
{
public:
- typedef SignalV2< bool () > TimerSignalV2;
+ typedef Signal< bool () > TimerSignalType;
Timer();
static Timer New( unsigned int milliSec );
Timer( const Timer& timer );
void SetInterval( unsigned int milliSec );
unsigned int GetInterval() const;
bool IsRunning() const;
- TimerSignalV2& TickSignal();
+ TimerSignalType& TickSignal();
private:
Timer(Internal::Adaptor::Timer* timer);
};
return ret;
}
-Toolkit::Builder::Signal& Builder::QuitSignal()
+Toolkit::Builder::BuilderSignalType& Builder::QuitSignal()
{
return mQuitSignal;
}
/**
* @copydoc Toolkit::Builder::QuitSignal
*/
- Toolkit::Builder::Signal& QuitSignal();
+ Toolkit::Builder::BuilderSignalType& QuitSignal();
/**
* Emits the quit signal
void SetProperties( const TreeNode& node, Handle& handle, const Replacement& constant );
- Toolkit::Builder::Signal mQuitSignal;
+ Toolkit::Builder::BuilderSignalType mQuitSignal;
};
} // namespace Internal
return 0.f;
}
-Toolkit::Button::ClickedSignalV2& Button::ClickedSignal()
+Toolkit::Button::ClickedSignalType& Button::ClickedSignal()
{
- return mClickedSignalV2;
+ return mClickedSignal;
}
-Toolkit::Button::ToggledSignalV2& Button::ToggledSignal()
+Toolkit::Button::ToggledSignalType& Button::ToggledSignal()
{
- return mToggledSignalV2;
+ return mToggledSignal;
}
bool Button::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
/**
* @copydoc Dali::Toolkit::Button::ClickedSignal()
*/
- Toolkit::Button::ClickedSignalV2& ClickedSignal();
+ Toolkit::Button::ClickedSignalType& ClickedSignal();
/**
* @copydoc Dali::Toolkit::Button::ToggledSignal()
*/
- Toolkit::Button::ToggledSignalV2& ToggledSignal();
+ Toolkit::Button::ToggledSignalType& ToggledSignal();
/**
* Connects a callback function with the object's signals.
ButtonPainterPtr mPainter; ///< Pointer to a ButtonPainter base class.
- Toolkit::Button::ClickedSignalV2 mClickedSignalV2; ///< Signal emitted when the button is clicked.
- Toolkit::Button::ToggledSignalV2 mToggledSignalV2; ///< Signal emitted when the button is toggled.
+ Toolkit::Button::ClickedSignalType mClickedSignal; ///< Signal emitted when the button is clicked.
+ Toolkit::Button::ToggledSignalType mToggledSignal; ///< Signal emitted when the button is toggled.
TapGestureDetector mTapDetector;
};
GetCheckBoxButtonPainter( mPainter )->Checked( handle );
// Raise toggled signal
- mToggledSignalV2.Emit( handle, mChecked );
+ mToggledSignal.Emit( handle, mChecked );
}
}
GetPushButtonPainter( mPainter )->Toggled( handle );
// Emit signal.
- mToggledSignalV2.Emit( handle, mToggled );
+ mToggledSignal.Emit( handle, mToggled );
}
}
return mFadeOutButtonImage;
}
-Toolkit::PushButton::PressedSignalV2& PushButton::PressedSignal()
+Toolkit::PushButton::PressedSignalType& PushButton::PressedSignal()
{
- return mPressedSignalV2;
+ return mPressedSignal;
}
-Toolkit::PushButton::ReleasedSignalV2& PushButton::ReleasedSignal()
+Toolkit::PushButton::ReleasedSignalType& PushButton::ReleasedSignal()
{
- return mReleasedSignalV2;
+ return mReleasedSignal;
}
bool PushButton::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
}
//Emit signal.
- mPressedSignalV2.Emit( handle );
+ mPressedSignal.Emit( handle );
}
}
GetPushButtonPainter( mPainter )->Toggled( handle );
// Emit signal.
- mToggledSignalV2.Emit( handle, mToggled );
+ mToggledSignal.Emit( handle, mToggled );
}
else
{
}
//Emit signal.
- mReleasedSignalV2.Emit( handle );
- mClickedSignalV2.Emit( handle );
+ mReleasedSignal.Emit( handle );
+ mClickedSignal.Emit( handle );
}
}
}
}
//Emit signal.
- mReleasedSignalV2.Emit( handle );
+ mReleasedSignal.Emit( handle );
}
}
}
GetPushButtonPainter( mPainter )->Pressed( handle );
//Emit signal.
- consumed = mReleasedSignalV2.Emit( handle );
- consumed |= mClickedSignalV2.Emit( handle );
- consumed |= mPressedSignalV2.Emit( handle );
+ consumed = mReleasedSignal.Emit( handle );
+ consumed |= mClickedSignal.Emit( handle );
+ consumed |= mPressedSignal.Emit( handle );
}
return consumed;
/**
* @copydoc Dali::Toolkit::PushButton::PressedSignal()
*/
- Toolkit::PushButton::PressedSignalV2& PressedSignal();
+ Toolkit::PushButton::PressedSignalType& PressedSignal();
/**
* @copydoc Dali::Toolkit::PushButton::ReleasedSignal()
*/
- Toolkit::PushButton::ReleasedSignalV2& ReleasedSignal();
+ Toolkit::PushButton::ReleasedSignalType& ReleasedSignal();
/**
* Connects a callback function with the object's signals.
bool mToggled; ///< Stores the toggle state.
// Signals
- Toolkit::PushButton::PressedSignalV2 mPressedSignalV2; ///< Signal emitted when the button is pressed.
- Toolkit::PushButton::ReleasedSignalV2 mReleasedSignalV2; ///< Signal emitted when the button is released.
+ Toolkit::PushButton::PressedSignalType mPressedSignal; ///< Signal emitted when the button is pressed.
+ Toolkit::PushButton::ReleasedSignalType mReleasedSignal; ///< Signal emitted when the button is released.
Actor mButtonImage; ///< Stores the released image.
Actor mBackgroundImage; ///< Stores the background image.
// Raise toggled signal
Toolkit::RadioButton handle( GetOwner() );
- mToggledSignalV2.Emit( handle, mActive );
+ mToggledSignal.Emit( handle, mActive );
RelayoutRequest();
}
// Guard against destruction during signal emission
Toolkit::Popup handle( GetOwner() );
- mHiddenSignalV2.Emit();
+ mHiddenSignal.Emit();
}
}
-Toolkit::Popup::TouchedOutsideSignalV2& Popup::OutsideTouchedSignal()
+Toolkit::Popup::TouchedOutsideSignalType& Popup::OutsideTouchedSignal()
{
- return mTouchedOutsideSignalV2;
+ return mTouchedOutsideSignal;
}
-Toolkit::Popup::HiddenSignalV2& Popup::HiddenSignal()
+Toolkit::Popup::HiddenSignalType& Popup::HiddenSignal()
{
- return mHiddenSignalV2;
+ return mHiddenSignal;
}
bool Popup::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
// Guard against destruction during signal emission
Toolkit::Popup handle( GetOwner() );
- mTouchedOutsideSignalV2.Emit();
+ mTouchedOutsideSignal.Emit();
}
}
/**
* @copydoc Dali::Toolkit::Popup::OutsideTouchedSignal()
*/
- Toolkit::Popup::TouchedOutsideSignalV2& OutsideTouchedSignal();
+ Toolkit::Popup::TouchedOutsideSignalType& OutsideTouchedSignal();
/**
* @copydoc Dali::Toolkit::Popup::HiddenSignal()
*/
- Toolkit::Popup::HiddenSignalV2& HiddenSignal();
+ Toolkit::Popup::HiddenSignalType& HiddenSignal();
/**
* Connects a callback function with the object's signals.
LayoutInfo mLayoutInfo; ///< Stores sizes of all popup components.
- Toolkit::Popup::TouchedOutsideSignalV2 mTouchedOutsideSignalV2;
- Toolkit::Popup::HiddenSignalV2 mHiddenSignalV2;
+ Toolkit::Popup::TouchedOutsideSignalType mTouchedOutsideSignal;
+ Toolkit::Popup::HiddenSignalType mHiddenSignal;
Property::Index mPropertyTitle; ///< Property index for Title.
Property::Index mPropertyState; ///< Property index for popup state.
RemoveActorsOutsideRange( range );
AddActorsWithinRange( range, 0.0f/*immediate*/ );
- mScrollUpdatedSignalV2.Emit( Vector3(0.0f, currentLayoutPosition, 0.0f) );
+ mScrollUpdatedSignal.Emit( Vector3(0.0f, currentLayoutPosition, 0.0f) );
}
}
if(mScrollAnimation)
{
- mScrollCompletedSignalV2.Emit(GetCurrentScrollPosition());
+ mScrollCompletedSignal.Emit(GetCurrentScrollPosition());
}
RemoveAnimation(mScrollAnimation);
mScrollPositionObject.SetProperty( ScrollConnector::SCROLL_POSITION, firstItemScrollPosition );
self.SetProperty(mPropertyPosition, GetScrollPosition(firstItemScrollPosition, layoutSize));
- mScrollStartedSignalV2.Emit(GetCurrentScrollPosition());
+ mScrollStartedSignal.Emit(GetCurrentScrollPosition());
mRefreshEnabled = true;
}
mScrollOvershoot = 0.0f;
AnimateScrollOvershoot(0.0f);
- mScrollCompletedSignalV2.Emit(GetCurrentScrollPosition());
+ mScrollCompletedSignal.Emit(GetCurrentScrollPosition());
}
}
// Reset the overshoot if no scroll animation.
if (!mScrollAnimation)
{
- mScrollCompletedSignalV2.Emit(GetCurrentScrollPosition());
+ mScrollCompletedSignal.Emit(GetCurrentScrollPosition());
AnimateScrollOvershoot(0.0f, false);
}
case Gesture::Started: // Fall through
{
mTotalPanDisplacement = Vector2::ZERO;
- mScrollStartedSignalV2.Emit(GetCurrentScrollPosition());
+ mScrollStartedSignal.Emit(GetCurrentScrollPosition());
mRefreshEnabled = true;
}
RemoveAnimation(mScrollAnimation); // mScrollAnimation is used to query whether we're scrolling
- mScrollCompletedSignalV2.Emit(GetCurrentScrollPosition());
+ mScrollCompletedSignal.Emit(GetCurrentScrollPosition());
if(mIsFlicking && fabsf(mScrollOvershoot) > Math::MACHINE_EPSILON_1)
{
AnimateScrollOvershoot(0.0f);
}
- mScrollStartedSignalV2.Emit(GetCurrentScrollPosition());
+ mScrollStartedSignal.Emit(GetCurrentScrollPosition());
mRefreshEnabled = true;
}
AnimateScrollOvershoot(0.0f);
}
- mScrollStartedSignalV2.Emit(GetCurrentScrollPosition());
+ mScrollStartedSignal.Emit(GetCurrentScrollPosition());
mRefreshEnabled = true;
}
// EXTERNAL INCLUDES
#include <dali/public-api/object/base-object.h>
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scrollable/scroll-connector.h>
{
// set mScrolling to false, in case user has code that interrogates mScrolling Getter() in complete.
mScrolling = false;
- DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignalV2 1 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
- mScrollCompletedSignalV2.Emit( currentScrollPosition );
+ DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 1 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
+ mScrollCompletedSignal.Emit( currentScrollPosition );
}
if( mPanning ) // are we interrupting a current pan?
self.SetProperty(mPropertyScrolling, true);
mScrolling = true;
- DALI_LOG_SCROLL_STATE("[0x%X] mScrollStartedSignalV2 1 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
- mScrollStartedSignalV2.Emit( currentScrollPosition );
+ DALI_LOG_SCROLL_STATE("[0x%X] mScrollStartedSignal 1 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
+ mScrollStartedSignal.Emit( currentScrollPosition );
bool animating = AnimateTo(-position,
Vector3::ONE * duration,
alpha,
completedPosition = position;
}
- DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignalV2 2 [%.2f, %.2f]", this, completedPosition.x, completedPosition.y);
+ DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 2 [%.2f, %.2f]", this, completedPosition.x, completedPosition.y);
SetScrollUpdateNotification(false);
- mScrollCompletedSignalV2.Emit( completedPosition );
+ mScrollCompletedSignal.Emit( completedPosition );
}
}
snapEvent.position = -mScrollTargetPosition;
snapEvent.duration = totalDuration;
- DALI_LOG_SCROLL_STATE("[0x%X] mSnapStartedSignalV2 [%.2f, %.2f]", this, snapEvent.position.x, snapEvent.position.y);
- mSnapStartedSignalV2.Emit( snapEvent );
+ DALI_LOG_SCROLL_STATE("[0x%X] mSnapStartedSignal [%.2f, %.2f]", this, snapEvent.position.x, snapEvent.position.y);
+ mSnapStartedSignal.Emit( snapEvent );
return (mScrollStateFlags & SCROLL_ANIMATION_FLAGS) != 0;
}
panGesture.RemoveDirection( direction );
}
-Toolkit::ScrollView::SnapStartedSignalV2& ScrollView::SnapStartedSignal()
+Toolkit::ScrollView::SnapStartedSignalType& ScrollView::SnapStartedSignal()
{
- return mSnapStartedSignalV2;
+ return mSnapStartedSignal;
}
void ScrollView::FindAndUnbindActor(Actor child)
self.SetProperty(mPropertyPrePosition, mScrollPrePosition);
Vector3 currentScrollPosition = GetCurrentScrollPosition();
- DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignalV2 3 current[%.2f, %.2f], mScrollTargetPosition[%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y, -mScrollTargetPosition.x, -mScrollTargetPosition.y );
- mScrollCompletedSignalV2.Emit( currentScrollPosition );
+ DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 3 current[%.2f, %.2f], mScrollTargetPosition[%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y, -mScrollTargetPosition.x, -mScrollTargetPosition.y );
+ mScrollCompletedSignal.Emit( currentScrollPosition );
mDomainOffset += deltaPosition - mScrollPostPosition;
self.SetProperty(mPropertyDomainOffset, mDomainOffset);
Toolkit::ScrollView handle( GetOwner() );
Vector3 currentScrollPosition = GetCurrentScrollPosition();
- mScrollUpdatedSignalV2.Emit( currentScrollPosition );
+ mScrollUpdatedSignal.Emit( currentScrollPosition );
}
bool ScrollView::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
UpdateLocalScrollProperties();
Vector3 currentScrollPosition = GetCurrentScrollPosition();
- DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignalV2 4 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
- mScrollCompletedSignalV2.Emit( currentScrollPosition );
+ DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 4 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
+ mScrollCompletedSignal.Emit( currentScrollPosition );
}
}
mScrolling = false;
// send negative scroll position since scroll internal scroll position works as an offset for actors,
// give applications the position within the domain from the scroll view's anchor position
- DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignalV2 5 [%.2f, %.2f]", this, -mScrollPostPosition.x, -mScrollPostPosition.y);
- mScrollCompletedSignalV2.Emit( -mScrollPostPosition );
+ DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 5 [%.2f, %.2f]", this, -mScrollPostPosition.x, -mScrollPostPosition.y);
+ mScrollCompletedSignal.Emit( -mScrollPostPosition );
}
}
}
Vector3 currentScrollPosition = GetCurrentScrollPosition();
Self().SetProperty(mPropertyScrolling, true);
mScrolling = true;
- DALI_LOG_SCROLL_STATE("[0x%X] mScrollStartedSignalV2 2 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
- mScrollStartedSignalV2.Emit( currentScrollPosition );
+ DALI_LOG_SCROLL_STATE("[0x%X] mScrollStartedSignal 2 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
+ mScrollStartedSignal.Emit( currentScrollPosition );
}
else if( (state == Gesture::Finished) ||
(state == Gesture::Cancelled) ) // Finished/default
SnapInternalYTo(mScrollTargetPosition.y);
}
Vector3 currentScrollPosition = GetCurrentScrollPosition();
- DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignalV2 6 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
- mScrollCompletedSignalV2.Emit( currentScrollPosition );
+ DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 6 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
+ mScrollCompletedSignal.Emit( currentScrollPosition );
}
}
/**
* @copydoc Dali::Toolkit::ScrollView::SnapStartedSignal()
*/
- Toolkit::ScrollView::SnapStartedSignalV2& SnapStartedSignal();
+ Toolkit::ScrollView::SnapStartedSignalType& SnapStartedSignal();
/**
* Connects a callback function with the object's signals.
ScrollOvershootIndicatorPtr mOvershootIndicator;
- Toolkit::ScrollView::SnapStartedSignalV2 mSnapStartedSignalV2;
+ Toolkit::ScrollView::SnapStartedSignalType mSnapStartedSignal;
bool mInAccessibilityPan : 1; ///< With AccessibilityPan its easier to move between snap positions
bool mInitialized:1;
return mOvershootAnimationSpeed;
};
-Toolkit::Scrollable::ScrollStartedSignalV2& Scrollable::ScrollStartedSignal()
+Toolkit::Scrollable::ScrollStartedSignalType& Scrollable::ScrollStartedSignal()
{
- return mScrollStartedSignalV2;
+ return mScrollStartedSignal;
}
-Toolkit::Scrollable::ScrollUpdatedSignalV2& Scrollable::ScrollUpdatedSignal()
+Toolkit::Scrollable::ScrollUpdatedSignalType& Scrollable::ScrollUpdatedSignal()
{
- return mScrollUpdatedSignalV2;
+ return mScrollUpdatedSignal;
}
-Toolkit::Scrollable::ScrollCompletedSignalV2& Scrollable::ScrollCompletedSignal()
+Toolkit::Scrollable::ScrollCompletedSignalType& Scrollable::ScrollCompletedSignal()
{
- return mScrollCompletedSignalV2;
+ return mScrollCompletedSignal;
}
-Toolkit::Scrollable::ScrollClampedSignalV2& Scrollable::ScrollClampedSignal()
+Toolkit::Scrollable::ScrollClampedSignalType& Scrollable::ScrollClampedSignal()
{
- return mScrollClampedSignalV2;
+ return mScrollClampedSignal;
}
bool Scrollable::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
/**
* @copydoc Dali::Toolkit::Scrollable::ScrollStartedSignal()
*/
- Toolkit::Scrollable::ScrollStartedSignalV2& ScrollStartedSignal();
+ Toolkit::Scrollable::ScrollStartedSignalType& ScrollStartedSignal();
/**
* @copydoc Dali::Toolkit::Scrollable::ScrollUpdatedSignal()
*/
- Toolkit::Scrollable::ScrollUpdatedSignalV2& ScrollUpdatedSignal();
+ Toolkit::Scrollable::ScrollUpdatedSignalType& ScrollUpdatedSignal();
/**
* @copydoc Dali::Toolkit::Scrollable::ScrollCompletedSignal()
*/
- Toolkit::Scrollable::ScrollCompletedSignalV2& ScrollCompletedSignal();
+ Toolkit::Scrollable::ScrollCompletedSignalType& ScrollCompletedSignal();
/**
* @copydoc Dali::Toolkit::Scrollable::ScrollClampedSignal()
*/
- Toolkit::Scrollable::ScrollClampedSignalV2& ScrollClampedSignal();
+ Toolkit::Scrollable::ScrollClampedSignalType& ScrollClampedSignal();
/**
* Connects a callback function with the object's signals.
std::map<Toolkit::Scrollable::ScrollComponentType, ScrollComponentPtr> mComponent; ///< ScrollComponent (such as a scrollbar/page indicator/status)
- Toolkit::Scrollable::ScrollStartedSignalV2 mScrollStartedSignalV2;
- Toolkit::Scrollable::ScrollUpdatedSignalV2 mScrollUpdatedSignalV2;
- Toolkit::Scrollable::ScrollCompletedSignalV2 mScrollCompletedSignalV2;
- Toolkit::Scrollable::ScrollClampedSignalV2 mScrollClampedSignalV2;
+ Toolkit::Scrollable::ScrollStartedSignalType mScrollStartedSignal;
+ Toolkit::Scrollable::ScrollUpdatedSignalType mScrollUpdatedSignal;
+ Toolkit::Scrollable::ScrollCompletedSignalType mScrollCompletedSignal;
+ Toolkit::Scrollable::ScrollClampedSignalType mScrollClampedSignal;
private:
public:
- typedef SignalV2< bool( Toolkit::Button ) > PressedSignal;
- typedef SignalV2< void () > CursorPositionedSignal;
+ typedef Signal< bool( Toolkit::Button ) > PressedSignal;
+ typedef Signal< void () > CursorPositionedSignal;
/**
* @brief Signal emitted when the button is touched.
* This is relayed from the PopUp class. It enables the owner of the Decorator to act on the PopUp button press.
// Signals
-Toolkit::TextInput::InputSignalV2& TextInput::InputStartedSignal()
+Toolkit::TextInput::InputSignalType& TextInput::InputStartedSignal()
{
- return mInputStartedSignalV2;
+ return mInputStartedSignal;
}
-Toolkit::TextInput::InputSignalV2& TextInput::InputFinishedSignal()
+Toolkit::TextInput::InputSignalType& TextInput::InputFinishedSignal()
{
- return mInputFinishedSignalV2;
+ return mInputFinishedSignal;
}
-Toolkit::TextInput::InputSignalV2& TextInput::CutAndPasteToolBarDisplayedSignal()
+Toolkit::TextInput::InputSignalType& TextInput::CutAndPasteToolBarDisplayedSignal()
{
- return mCutAndPasteToolBarDisplayedV2;
+ return mCutAndPasteToolBarDisplayed;
}
-Toolkit::TextInput::StyleChangedSignalV2& TextInput::StyleChangedSignal()
+Toolkit::TextInput::StyleChangedSignalType& TextInput::StyleChangedSignal()
{
- return mStyleChangedSignalV2;
+ return mStyleChangedSignal;
}
Toolkit::TextInput::TextModifiedSignalType& TextInput::TextModifiedSignal()
return mTextModifiedSignal;
}
-Toolkit::TextInput::MaxInputCharactersReachedSignalV2& TextInput::MaxInputCharactersReachedSignal()
+Toolkit::TextInput::MaxInputCharactersReachedSignalType& TextInput::MaxInputCharactersReachedSignal()
{
- return mMaxInputCharactersReachedSignalV2;
+ return mMaxInputCharactersReachedSignal;
}
-Toolkit::TextInput::InputTextExceedBoundariesSignalV2& TextInput::InputTextExceedBoundariesSignal()
+Toolkit::TextInput::InputTextExceedBoundariesSignalType& TextInput::InputTextExceedBoundariesSignal()
{
- return mInputTextExceedBoundariesSignalV2;
+ return mInputTextExceedBoundariesSignal;
}
bool TextInput::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
StartCursorBlinkTimer();
Toolkit::TextInput handle( GetOwner() );
- mInputStartedSignalV2.Emit( handle );
+ mInputStartedSignal.Emit( handle );
ImfManager imfManager = ImfManager::Get();
VirtualKeyboard::LanguageChangedSignal().Disconnect( this, &TextInput::SetTextDirection );
Toolkit::TextInput handle( GetOwner() );
- mInputFinishedSignalV2.Emit( handle );
+ mInputFinishedSignal.Emit( handle );
mEditModeActive = false;
mPreEditFlag = false;
RemoveHighlight();
{
// emit signal if input style changes.
Toolkit::TextInput handle( GetOwner() );
- mStyleChangedSignalV2.Emit( handle, mInputStyle );
+ mStyleChangedSignal.Emit( handle, mInputStyle );
}
void TextInput::EmitTextModified()
DALI_LOG_INFO(gLogFilter, Debug::General, "EmitMaxInputCharactersReachedSignal \n");
Toolkit::TextInput handle( GetOwner() );
- mMaxInputCharactersReachedSignalV2.Emit( handle );
+ mMaxInputCharactersReachedSignal.Emit( handle );
}
void TextInput::EmitInputTextExceedsBoundariesSignal()
// Emit a signal when the input text exceeds the boundaries of the text input.
Toolkit::TextInput handle( GetOwner() );
- mInputTextExceedBoundariesSignalV2.Emit( handle );
+ mInputTextExceedBoundariesSignal.Emit( handle );
}
} // namespace Internal
/**
* @copydoc Toolkit::TextInput::InputStartedSignal()
*/
- Toolkit::TextInput::InputSignalV2& InputStartedSignal();
+ Toolkit::TextInput::InputSignalType& InputStartedSignal();
/**
* @copydoc Toolkit::TextInput::InputFinishedSignal()
*/
- Toolkit::TextInput::InputSignalV2& InputFinishedSignal();
+ Toolkit::TextInput::InputSignalType& InputFinishedSignal();
/**
* @copydoc Toolkit::TextInput::CutAndPasteToolBarDisplayedSignal()
*/
- Toolkit::TextInput::InputSignalV2& CutAndPasteToolBarDisplayedSignal();
+ Toolkit::TextInput::InputSignalType& CutAndPasteToolBarDisplayedSignal();
/**
* @copydoc Toolkit::TextInput::StyleChangedSignal()
*/
- Toolkit::TextInput::StyleChangedSignalV2& StyleChangedSignal();
+ Toolkit::TextInput::StyleChangedSignalType& StyleChangedSignal();
/**
* @copydoc Toolkit::TextInput::TextModifiedSignal()
/**
* @copydoc Toolkit::TextInput::MaxInputCharactersReachedSignal()
*/
- Toolkit::TextInput::MaxInputCharactersReachedSignalV2& MaxInputCharactersReachedSignal();
+ Toolkit::TextInput::MaxInputCharactersReachedSignalType& MaxInputCharactersReachedSignal();
/**
* @copydoc Toolkit::TextInput::InputTextExceedBoundariesSignal()
*/
- Toolkit::TextInput::InputTextExceedBoundariesSignalV2& InputTextExceedBoundariesSignal();
+ Toolkit::TextInput::InputTextExceedBoundariesSignalType& InputTextExceedBoundariesSignal();
/**
* Connects a callback function with the object's signals.
bool mPlaceHolderSet:1; ///< Whether the place holder text is set.
bool mMarkUpEnabled:1; ///< enable to scan for mark-up
- Toolkit::TextInput::InputSignalV2 mInputStartedSignalV2; ///< Signal emitted when input starts
- Toolkit::TextInput::InputSignalV2 mInputFinishedSignalV2; ///< Signal emitted when input ends
- Toolkit::TextInput::StyleChangedSignalV2 mStyleChangedSignalV2; ///< Signal emitted when style changes.
+ Toolkit::TextInput::InputSignalType mInputStartedSignal; ///< Signal emitted when input starts
+ Toolkit::TextInput::InputSignalType mInputFinishedSignal; ///< Signal emitted when input ends
+ Toolkit::TextInput::StyleChangedSignalType mStyleChangedSignal; ///< Signal emitted when style changes.
Toolkit::TextInput::TextModifiedSignalType mTextModifiedSignal; ///< Signal emitted when text modified.
- Toolkit::TextInput::MaxInputCharactersReachedSignalV2 mMaxInputCharactersReachedSignalV2; ///< Signal emitted when max input characters is reached.
- Toolkit::TextInput::InputSignalV2 mCutAndPasteToolBarDisplayedV2; ///< Signal emitted when toolbar displayed
- Toolkit::TextInput::InputTextExceedBoundariesSignalV2 mInputTextExceedBoundariesSignalV2; ///< Signal emitted when input text exceeds the boundaries of the text-input.
+ Toolkit::TextInput::MaxInputCharactersReachedSignalType mMaxInputCharactersReachedSignal; ///< Signal emitted when max input characters is reached.
+ Toolkit::TextInput::InputSignalType mCutAndPasteToolBarDisplayed; ///< Signal emitted when toolbar displayed
+ Toolkit::TextInput::InputTextExceedBoundariesSignalType mInputTextExceedBoundariesSignal; ///< Signal emitted when input text exceeds the boundaries of the text-input.
};
} // namespace Internal
mShowFinishedSignal.Emit( *this );
}
-TextInputPopup::PressedSignalV2& TextInputPopup::PressedSignal()
+TextInputPopup::PressedSignalType& TextInputPopup::PressedSignal()
{
return mPressedSignal;
}
-TextInputPopup::HideFinishedSignalV2& TextInputPopup::HideFinishedSignal()
+TextInputPopup::HideFinishedSignalType& TextInputPopup::HideFinishedSignal()
{
return mHideFinishedSignal;
}
-TextInputPopup::ShowFinishedSignalV2& TextInputPopup::ShowFinishedSignal()
+TextInputPopup::ShowFinishedSignalType& TextInputPopup::ShowFinishedSignal()
{
return mShowFinishedSignal;
}
static const char* const SIGNAL_SHOW_FINISHED;
// Popup Button Pressed
- typedef SignalV2< bool( Toolkit::Button ) > PressedSignalV2;
+ typedef Signal< bool( Toolkit::Button ) > PressedSignalType;
// Popup Hide Finished
- typedef SignalV2< void( TextInputPopup& ) > HideFinishedSignalV2;
+ typedef Signal< void( TextInputPopup& ) > HideFinishedSignalType;
// Popup Show Finished
- typedef SignalV2< void( TextInputPopup& ) > ShowFinishedSignalV2;
+ typedef Signal< void( TextInputPopup& ) > ShowFinishedSignalType;
/**
* Signal emitted when the button is touched.
*/
- PressedSignalV2& PressedSignal();
+ PressedSignalType& PressedSignal();
/**
* Signal emitted when popup is completely hidden
* @note Only occurs after a Show() call with animation enabled.
*/
- HideFinishedSignalV2& HideFinishedSignal();
+ HideFinishedSignalType& HideFinishedSignal();
/**
* Signal emitted when popup is completely shown
* @note Only occurs after a Hide() call with animation enabled.
*/
- ShowFinishedSignalV2& ShowFinishedSignal();
+ ShowFinishedSignalType& ShowFinishedSignal();
public:
std::size_t mPasteOptionPriority; // Position of Paste button
std::size_t mClipboardOptionPriority; // Position of Clipboard button
- PressedSignalV2 mPressedSignal; ///< Signal emitted when a button within the popup is pressed.
- HideFinishedSignalV2 mHideFinishedSignal; ///< Signal emitted when popup is completely hidden
- ShowFinishedSignalV2 mShowFinishedSignal; ///< Signal emitted when popup is completely shown
+ PressedSignalType mPressedSignal; ///< Signal emitted when a button within the popup is pressed.
+ HideFinishedSignalType mHideFinishedSignal; ///< Signal emitted when popup is completely hidden
+ ShowFinishedSignalType mShowFinishedSignal; ///< Signal emitted when popup is completely shown
};
static const char* const SIGNAL_SHOW_FINISHED;
// Popup Button Pressed
- typedef SignalV2< bool( Toolkit::Button ) > PopUpPressedSignal;
+ typedef Signal< bool( Toolkit::Button ) > PopUpPressedSignal;
// Popup Hide Finished
- typedef SignalV2< void( TextInputPopupNew& ) > PopUpHideFinishedSignal;
+ typedef Signal< void( TextInputPopupNew& ) > PopUpHideFinishedSignal;
// Popup Show Finished
- typedef SignalV2< void( TextInputPopupNew& ) > PopUpShowFinishedSignal;
+ typedef Signal< void( TextInputPopupNew& ) > PopUpShowFinishedSignal;
/**
* Signal emitted when the button is touched.
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/signals/dali-signal-v2.h>
+#include <dali/public-api/signals/dali-signal.h>
#include <dali/public-api/text/text-style.h>
// INTERNAL INCLUDES
*/
/* Input style changed signal.*/
- typedef SignalV2< void( const TextStyle& style ) > StyleChangedSignalType;
+ typedef Signal< void( const TextStyle& style ) > StyleChangedSignalType;
/**
* @brief Signal emitted when style changes.
return mVisualParameters.mScrollPositionTrimmed;
}
-Toolkit::TextView::ScrolledSignalV2& TextView::ScrolledSignal()
+Toolkit::TextView::ScrolledSignalType& TextView::ScrolledSignal()
{
- return mScrolledSignalV2;
+ return mScrolledSignal;
}
bool TextView::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
// Emit the signal.
Toolkit::TextView handle( GetOwner() );
- mScrolledSignalV2.Emit( handle, delta );
+ mScrolledSignal.Emit( handle, delta );
}
void TextView::CombineExceedPolicies()
/**
* @copydoc ScrolledSignal()
*/
- Toolkit::TextView::ScrolledSignalV2& ScrolledSignal();
+ Toolkit::TextView::ScrolledSignalType& ScrolledSignal();
/**
* Connects a callback function with the object's signals.
bool mPreviousSnapshotModeEnabled:1; ///< Stores the previous snapshot mode value.
bool mMarkUpEnabled:1; ///< enable to scan for mark-up
- Toolkit::TextView::ScrolledSignalV2 mScrolledSignalV2; ///< Signal emitted when text is scrolled.
+ Toolkit::TextView::ScrolledSignalType mScrolledSignal; ///< Signal emitted when text is scrolled.
};
} // namespace Internal
}
// Send notification for the change of focus actor
- mFocusChangedSignalV2.Emit( GetCurrentFocusActor(), actor );
+ mFocusChangedSignal.Emit( GetCurrentFocusActor(), actor );
// Save the current focused actor
mCurrentFocusActor = FocusIDPair(GetFocusOrder(actor), actorID);
}
// Send notification for the activation of focused actor
- mFocusedActorActivatedSignalV2.Emit(actor);
+ mFocusedActorActivatedSignal.Emit(actor);
}
}
mCurrentFocusActor = FocusIDPair(0, 0);
// Send notification for the change of focus actor
- mFocusChangedSignalV2.Emit(actor, Actor());
+ mFocusChangedSignal.Emit(actor, Actor());
if(mIsAccessibilityTtsEnabled)
{
{
DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] Overshot\n", __FUNCTION__, __LINE__);
// Send notification for handling overshooted situation
- mFocusOvershotSignalV2.Emit(GetCurrentFocusActor(), forward ? Toolkit::FocusManager::OVERSHOT_NEXT : Toolkit::FocusManager::OVERSHOT_PREVIOUS);
+ mFocusOvershotSignal.Emit(GetCurrentFocusActor(), forward ? Toolkit::FocusManager::OVERSHOT_NEXT : Toolkit::FocusManager::OVERSHOT_PREVIOUS);
return false; // Try to move the focus out of the scope
}
return handled;
}
-Toolkit::FocusManager::FocusChangedSignalV2& FocusManager::FocusChangedSignal()
+Toolkit::FocusManager::FocusChangedSignalType& FocusManager::FocusChangedSignal()
{
- return mFocusChangedSignalV2;
+ return mFocusChangedSignal;
}
-Toolkit::FocusManager::FocusOvershotSignalV2& FocusManager::FocusOvershotSignal()
+Toolkit::FocusManager::FocusOvershotSignalType& FocusManager::FocusOvershotSignal()
{
- return mFocusOvershotSignalV2;
+ return mFocusOvershotSignal;
}
-Toolkit::FocusManager::FocusedActorActivatedSignalV2& FocusManager::FocusedActorActivatedSignal()
+Toolkit::FocusManager::FocusedActorActivatedSignalType& FocusManager::FocusedActorActivatedSignal()
{
- return mFocusedActorActivatedSignalV2;
+ return mFocusedActorActivatedSignal;
}
bool FocusManager::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
/**
* @copydoc Toolkit::FocusManager::FocusChangedSignal()
*/
- Toolkit::FocusManager::FocusChangedSignalV2& FocusChangedSignal();
+ Toolkit::FocusManager::FocusChangedSignalType& FocusChangedSignal();
/**
* @copydoc Toolkit::FocusManager::FocusOvershotSignal()
*/
- Toolkit::FocusManager::FocusOvershotSignalV2& FocusOvershotSignal();
+ Toolkit::FocusManager::FocusOvershotSignalType& FocusOvershotSignal();
/**
* @copydoc Toolkit::FocusManager::FocusedActorActivatedSignal()
*/
- Toolkit::FocusManager::FocusedActorActivatedSignalV2& FocusedActorActivatedSignal();
+ Toolkit::FocusManager::FocusedActorActivatedSignalType& FocusedActorActivatedSignal();
/**
* Connects a callback function with the object's signals.
private:
- Toolkit::FocusManager::FocusChangedSignalV2 mFocusChangedSignalV2; ///< The signal to notify the focus change
- Toolkit::FocusManager::FocusOvershotSignalV2 mFocusOvershotSignalV2; ///< The signal to notify the focus overshooted
- Toolkit::FocusManager::FocusedActorActivatedSignalV2 mFocusedActorActivatedSignalV2; ///< The signal to notify the activation of focused actor
+ Toolkit::FocusManager::FocusChangedSignalType mFocusChangedSignal; ///< The signal to notify the focus change
+ Toolkit::FocusManager::FocusOvershotSignalType mFocusOvershotSignal; ///< The signal to notify the focus overshooted
+ Toolkit::FocusManager::FocusedActorActivatedSignalType mFocusedActorActivatedSignal; ///< The signal to notify the activation of focused actor
bool mIsWrapped; ///< Whether the focus movement is wrapped around or not
bool mIsFocusWithinGroup; ///< Whether the focus movement is limited to the current focus group or not
}
// Send notification for the change of focus actor
- if( !mFocusChangedSignalV2.Empty() )
+ if( !mFocusChangedSignal.Empty() )
{
- mFocusChangedSignalV2.Emit(GetCurrentFocusActor(), actor);
+ mFocusChangedSignal.Emit(GetCurrentFocusActor(), actor);
}
DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] Focus Changed\n", __FUNCTION__, __LINE__);
parentLayoutControl = GetParentLayoutControl(parentLayoutControl);
}
- if(!succeed && !mPreFocusChangeSignalV2.Empty())
+ if(!succeed && !mPreFocusChangeSignal.Empty())
{
// Don't know how to move the focus further. The application needs to tell us which actor to move the focus to
mIsWaitingKeyboardFocusChangeCommit = true;
- Actor nextFocusableActor = mPreFocusChangeSignalV2.Emit(currentFocusActor, Actor(), direction);
+ Actor nextFocusableActor = mPreFocusChangeSignal.Emit(currentFocusActor, Actor(), direction);
mIsWaitingKeyboardFocusChangeCommit = false;
if ( nextFocusableActor && nextFocusableActor.IsKeyboardFocusable() )
// We will try to move the focus to the actor. Emit a signal to notify the proposed actor to focus
// Signal handler can check the proposed actor and return a different actor if it wishes.
- if( !mPreFocusChangeSignalV2.Empty() )
+ if( !mPreFocusChangeSignal.Empty() )
{
mIsWaitingKeyboardFocusChangeCommit = true;
- committedFocusActor = mPreFocusChangeSignalV2.Emit(currentFocusActor, nextFocusableActor, direction);
+ committedFocusActor = mPreFocusChangeSignal.Emit(currentFocusActor, nextFocusableActor, direction);
mIsWaitingKeyboardFocusChangeCommit = false;
}
parentLayoutControl = GetParentLayoutControl(parentLayoutControl);
}
- if(!mFocusGroupChangedSignalV2.Empty())
+ if(!mFocusGroupChangedSignal.Empty())
{
// Emit a focus group changed signal. The applicaton can move the focus to a new focus group
- mFocusGroupChangedSignalV2.Emit(GetCurrentFocusActor(), forward);
+ mFocusGroupChangedSignal.Emit(GetCurrentFocusActor(), forward);
}
return succeed;
}
// Send notification for the activation of focused actor
- if( !mFocusedActorActivatedSignalV2.Empty() )
+ if( !mFocusedActorActivatedSignal.Empty() )
{
- mFocusedActorActivatedSignalV2.Emit(actor);
+ mFocusedActorActivatedSignal.Emit(actor);
}
}
}
}
// Send notification for the change of focus actor
- if( !mFocusChangedSignalV2.Empty() )
+ if( !mFocusChangedSignal.Empty() )
{
- mFocusChangedSignalV2.Emit(actor, Actor());
+ mFocusChangedSignal.Emit(actor, Actor());
}
}
ClearFocus();
}
-Toolkit::KeyboardFocusManager::PreFocusChangeSignalV2& KeyboardFocusManager::PreFocusChangeSignal()
+Toolkit::KeyboardFocusManager::PreFocusChangeSignalType& KeyboardFocusManager::PreFocusChangeSignal()
{
- return mPreFocusChangeSignalV2;
+ return mPreFocusChangeSignal;
}
-Toolkit::KeyboardFocusManager::FocusChangedSignalV2& KeyboardFocusManager::FocusChangedSignal()
+Toolkit::KeyboardFocusManager::FocusChangedSignalType& KeyboardFocusManager::FocusChangedSignal()
{
- return mFocusChangedSignalV2;
+ return mFocusChangedSignal;
}
-Toolkit::KeyboardFocusManager::FocusGroupChangedSignalV2& KeyboardFocusManager::FocusGroupChangedSignal()
+Toolkit::KeyboardFocusManager::FocusGroupChangedSignalType& KeyboardFocusManager::FocusGroupChangedSignal()
{
- return mFocusGroupChangedSignalV2;
+ return mFocusGroupChangedSignal;
}
-Toolkit::KeyboardFocusManager::FocusedActorActivatedSignalV2& KeyboardFocusManager::FocusedActorActivatedSignal()
+Toolkit::KeyboardFocusManager::FocusedActorActivatedSignalType& KeyboardFocusManager::FocusedActorActivatedSignal()
{
- return mFocusedActorActivatedSignalV2;
+ return mFocusedActorActivatedSignal;
}
bool KeyboardFocusManager::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
/**
* @copydoc Toolkit::KeyboardFocusManager::PreFocusChangeSignal()
*/
- Toolkit::KeyboardFocusManager::PreFocusChangeSignalV2& PreFocusChangeSignal();
+ Toolkit::KeyboardFocusManager::PreFocusChangeSignalType& PreFocusChangeSignal();
/**
* @copydoc Toolkit::KeyboardFocusManager::FocusChangedSignal()
*/
- Toolkit::KeyboardFocusManager::FocusChangedSignalV2& FocusChangedSignal();
+ Toolkit::KeyboardFocusManager::FocusChangedSignalType& FocusChangedSignal();
/**
* @copydoc Toolkit::KeyboardFocusManager::FocusGroupChangedSignal()
*/
- Toolkit::KeyboardFocusManager::FocusGroupChangedSignalV2& FocusGroupChangedSignal();
+ Toolkit::KeyboardFocusManager::FocusGroupChangedSignalType& FocusGroupChangedSignal();
/**
* @copydoc Toolkit::KeyboardFocusManager::FocusedActorActivatedSignal()
*/
- Toolkit::KeyboardFocusManager::FocusedActorActivatedSignalV2& FocusedActorActivatedSignal();
+ Toolkit::KeyboardFocusManager::FocusedActorActivatedSignalType& FocusedActorActivatedSignal();
/**
* Connects a callback function with the object's signals.
private:
- Toolkit::KeyboardFocusManager::PreFocusChangeSignalV2 mPreFocusChangeSignalV2; ///< The signal to notify the focus will be changed
- Toolkit::KeyboardFocusManager::FocusChangedSignalV2 mFocusChangedSignalV2; ///< The signal to notify the focus change
- Toolkit::KeyboardFocusManager::FocusGroupChangedSignalV2 mFocusGroupChangedSignalV2; ///< The signal to notify the focus group change
- Toolkit::KeyboardFocusManager::FocusedActorActivatedSignalV2 mFocusedActorActivatedSignalV2; ///< The signal to notify the activation of focused actor
+ Toolkit::KeyboardFocusManager::PreFocusChangeSignalType mPreFocusChangeSignal; ///< The signal to notify the focus will be changed
+ Toolkit::KeyboardFocusManager::FocusChangedSignalType mFocusChangedSignal; ///< The signal to notify the focus change
+ Toolkit::KeyboardFocusManager::FocusGroupChangedSignalType mFocusGroupChangedSignal; ///< The signal to notify the focus group change
+ Toolkit::KeyboardFocusManager::FocusedActorActivatedSignalType mFocusedActorActivatedSignal; ///< The signal to notify the activation of focused actor
unsigned int mCurrentFocusActor; ///< The actor ID of current focused actor
control.GetImplementation().OnKeyInputFocusGained();
// Emit the signal to inform focus change to the application.
- if ( !mKeyInputFocusChangedSignalV2.Empty() )
+ if ( !mKeyInputFocusChangedSignal.Empty() )
{
- mKeyInputFocusChangedSignalV2.Emit( control, previousFocusControl );
+ mKeyInputFocusChangedSignal.Emit( control, previousFocusControl );
}
}
return result;
}
-Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalV2& KeyInputFocusManager::KeyInputFocusChangedSignal()
+Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType& KeyInputFocusManager::KeyInputFocusChangedSignal()
{
- return mKeyInputFocusChangedSignalV2;
+ return mKeyInputFocusChangedSignal;
}
-Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalV2& KeyInputFocusManager::UnhandledKeyEventSignal()
+Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType& KeyInputFocusManager::UnhandledKeyEventSignal()
{
- return mUnhandledKeyEventSignalV2;
+ return mUnhandledKeyEventSignal;
}
KeyInputFocusManager::FocusStackIterator KeyInputFocusManager::FindFocusControlInStack( Toolkit::Control control ) const
if( !consumed )
{
// Emit signal to inform that a key event is not consumed.
- if( !mUnhandledKeyEventSignalV2.Empty() )
+ if( !mUnhandledKeyEventSignal.Empty() )
{
- mUnhandledKeyEventSignalV2.Emit(event);
+ mUnhandledKeyEventSignal.Emit(event);
}
}
}
/**
* @copydoc Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignal()
*/
- Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalV2& KeyInputFocusChangedSignal();
+ Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType& KeyInputFocusChangedSignal();
/**
* @copydoc Toolkit::KeyInputFocusManager::UnhandledKeyEventSignal()
*/
- Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalV2& UnhandledKeyEventSignal();
+ Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType& UnhandledKeyEventSignal();
/**
* Connects a callback function with the object's signals.
private:
// The key input focus change signal
- Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalV2 mKeyInputFocusChangedSignalV2;
+ Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType mKeyInputFocusChangedSignal;
// The un-handled key event signal
- Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalV2 mUnhandledKeyEventSignalV2;
+ Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType mUnhandledKeyEventSignal;
// Keyboard events are sent to the current focus actor, which will be the actor on the top of the focus actors stack.
FocusStack mFocusStack;
return GetImpl(*this).GetPath( name );
}
-Builder::Signal& Builder::QuitSignal()
+Builder::BuilderSignalType& Builder::QuitSignal()
{
return GetImpl( *this ).QuitSignal();
}
/**
* @brief Builder signal type
*/
- typedef SignalV2< void () > Signal;
+ typedef Signal< void () > BuilderSignalType;
/**
* @brief Signal emitted when a quit action is requested by the builder.
*/
- Signal& QuitSignal();
+ BuilderSignalType& QuitSignal();
private:
explicit DALI_INTERNAL Builder(Internal::Builder *impl);
return Dali::Toolkit::GetImplementation( *this ).GetAnimationTime();
}
-Button::ClickedSignalV2& Button::ClickedSignal()
+Button::ClickedSignalType& Button::ClickedSignal()
{
return Dali::Toolkit::GetImplementation( *this ).ClickedSignal();
}
-Button::ToggledSignalV2& Button::ToggledSignal()
+Button::ToggledSignalType& Button::ToggledSignal()
{
return Dali::Toolkit::GetImplementation( *this ).ToggledSignal();
}
/**
* @brief Button Clicked signal type
*/
- typedef SignalV2< bool ( Button ) > ClickedSignalV2;
+ typedef Signal< bool ( Button ) > ClickedSignalType;
/**
* @brief Button toggled signal type
*/
- typedef SignalV2< bool ( Button, bool ) > ToggledSignalV2;
+ typedef Signal< bool ( Button, bool ) > ToggledSignalType;
/**
* @brief Signal emitted when the button is touched and the touch point doesn't leave the boundary of the button.
*/
- ClickedSignalV2& ClickedSignal();
+ ClickedSignalType& ClickedSignal();
/**
* @brief Signal emitted when the button's state is toggled.
*/
- ToggledSignalV2& ToggledSignal();
+ ToggledSignalType& ToggledSignal();
public: // Not intended for application developers
return Dali::Toolkit::GetImplementation( *this ).GetLabelText();
}
-PushButton::PressedSignalV2& PushButton::PressedSignal()
+PushButton::PressedSignalType& PushButton::PressedSignal()
{
return Dali::Toolkit::GetImplementation( *this ).PressedSignal();
}
-PushButton::ReleasedSignalV2& PushButton::ReleasedSignal()
+PushButton::ReleasedSignalType& PushButton::ReleasedSignal()
{
return Dali::Toolkit::GetImplementation( *this ).ReleasedSignal();
}
public: //Signals
/// @brief PushButton Pressed signal type.
- typedef SignalV2< bool ( Button ) > PressedSignalV2;
+ typedef Signal< bool ( Button ) > PressedSignalType;
/// @brief PushButton Released signal type.
- typedef SignalV2< bool ( Button ) > ReleasedSignalV2;
+ typedef Signal< bool ( Button ) > ReleasedSignalType;
/**
* @brief Signal emitted when the button is touched.
*/
- PressedSignalV2& PressedSignal();
+ PressedSignalType& PressedSignal();
/**
* @brief Signal emitted when the button is touched and the touch point leaves the boundary of the button.
*/
- ReleasedSignalV2& ReleasedSignal();
+ ReleasedSignalType& ReleasedSignal();
public: // Not intended for application developers
: mControlImpl( controlImpl ),
mBackground( NULL ),
mStartingPinchScale( NULL ),
- mKeyEventSignalV2(),
+ mKeyEventSignal(),
mPinchGestureDetector(),
mPanGestureDetector(),
mTapGestureDetector(),
Control& mControlImpl;
Background* mBackground; ///< Only create the background if we use it
Vector3* mStartingPinchScale; ///< The scale when a pinch gesture starts, TODO: consider removing this
- Toolkit::Control::KeyEventSignalV2 mKeyEventSignalV2;
+ Toolkit::Control::KeyEventSignalType mKeyEventSignal;
// Gesture Detection
PinchGestureDetector mPinchGestureDetector;
return connected;
}
-Toolkit::Control::KeyEventSignalV2& Control::KeyEventSignal()
+Toolkit::Control::KeyEventSignalType& Control::KeyEventSignal()
{
- return mImpl->mKeyEventSignalV2;
+ return mImpl->mKeyEventSignal;
}
bool Control::EmitKeyEventSignal( const KeyEvent& event )
bool consumed = false;
// signals are allocated dynamically when someone connects
- if ( !mImpl->mKeyEventSignalV2.Empty() )
+ if ( !mImpl->mKeyEventSignal.Empty() )
{
- consumed = mImpl->mKeyEventSignalV2.Emit( handle, event );
+ consumed = mImpl->mKeyEventSignal.Emit( handle, event );
}
if (!consumed)
/**
* @copydoc Dali::Toolkit::Control::KeyEventSignal()
*/
- Toolkit::Control::KeyEventSignalV2& KeyEventSignal();
+ Toolkit::Control::KeyEventSignalType& KeyEventSignal();
/**
* @brief Called by the KeyInputFocusManager to emit key event signals.
return GetImplementation().GetBackgroundActor();
}
-Control::KeyEventSignalV2& Control::KeyEventSignal()
+Control::KeyEventSignalType& Control::KeyEventSignal()
{
return GetImplementation().KeyEventSignal();
}
// Typedefs
/// @brief Key Event signal type;
- typedef SignalV2<bool ( Control, const KeyEvent& ) > KeyEventSignalV2;
+ typedef Signal<bool ( Control, const KeyEvent& ) > KeyEventSignalType;
public: // Creation & Destruction
* @pre The Control has been initialized.
* @return The signal to connect to.
*/
- KeyEventSignalV2& KeyEventSignal();
+ KeyEventSignalType& KeyEventSignal();
public: // Intended for control developers
GetImpl(*this).HideTail();
}
-Popup::TouchedOutsideSignalV2& Popup::OutsideTouchedSignal()
+Popup::TouchedOutsideSignalType& Popup::OutsideTouchedSignal()
{
return GetImpl(*this).OutsideTouchedSignal();
}
-Popup::HiddenSignalV2& Popup::HiddenSignal()
+Popup::HiddenSignalType& Popup::HiddenSignal()
{
return GetImpl(*this).HiddenSignal();
}
POPUP_SHOW, ///< Shown (visible in default size)
};
- typedef SignalV2< void () > TouchedOutsideSignalV2; ///< Touched outside signal type.
- typedef SignalV2< void () > HiddenSignalV2; ///< Hidden signal type.
+ typedef Signal< void () > TouchedOutsideSignalType; ///< Touched outside signal type.
+ typedef Signal< void () > HiddenSignalType; ///< Hidden signal type.
/**
* @brief Signal emitted when user has touched outside of the Dialog.
*/
- TouchedOutsideSignalV2& OutsideTouchedSignal();
+ TouchedOutsideSignalType& OutsideTouchedSignal();
/**
* @brief Signal emitted when popup has been hidden.
*/
- HiddenSignalV2& HiddenSignal();
+ HiddenSignalType& HiddenSignal();
public:
// Signals
static const char* const SCROLL_POSITION_NOTIFIED_SIGNAL_NAME; ///< "scroll-position-notified" signal name
- typedef SignalV2< void ( float ) > ScrollPositionNotifiedSignalType;
+ typedef Signal< void ( float ) > ScrollPositionNotifiedSignalType;
// Properties
static const Property::Index PROPERTY_INDICATOR_HEIGHT_POLICY; ///< name "indicator-height-policy", @see SetIndicatorHeightPolicy(), type STRING
// Signals
static const char* const DOMAIN_CHANGED_SIGNAL_NAME; ///< "domain-changed" signal name
- typedef SignalV2< void ( float min, float max, float size ) > DomainChangedSignalType;
+ typedef Signal< void ( float min, float max, float size ) > DomainChangedSignalType;
static const char* const SCROLL_POSITION_CHANGED_SIGNAL_NAME; ///< "scroll-position-changed" signal name
- typedef SignalV2< void ( float position ) > ScrollPositionChangedSignalType;
+ typedef Signal< void ( float position ) > ScrollPositionChangedSignalType;
/**
* Create a ScrollConnector.
GetImpl(*this).UnbindActor(child);
}
-ScrollView::SnapStartedSignalV2& ScrollView::SnapStartedSignal()
+ScrollView::SnapStartedSignalType& ScrollView::SnapStartedSignal()
{
return GetImpl(*this).SnapStartedSignal();
}
float duration; ///< Duration of snap animation.
};
- typedef SignalV2< void ( const SnapEvent& ) > SnapStartedSignalV2; ///< SnapStarted signal type
+ typedef Signal< void ( const SnapEvent& ) > SnapStartedSignalType; ///< SnapStarted signal type
/**
* @brief Signal emitted when the ScrollView has started to snap or flick (it tells the target
* position, scale, rotation for the snap or flick)
*/
- SnapStartedSignalV2& SnapStartedSignal();
+ SnapStartedSignalType& SnapStartedSignal();
public:
return Control::DownCast<Scrollable, Internal::Scrollable>(handle);
}
-Scrollable::ScrollStartedSignalV2& Scrollable::ScrollStartedSignal()
+Scrollable::ScrollStartedSignalType& Scrollable::ScrollStartedSignal()
{
return GetImpl(*this).ScrollStartedSignal();
}
-Scrollable::ScrollUpdatedSignalV2& Scrollable::ScrollUpdatedSignal()
+Scrollable::ScrollUpdatedSignalType& Scrollable::ScrollUpdatedSignal()
{
return GetImpl(*this).ScrollUpdatedSignal();
}
-Scrollable::ScrollCompletedSignalV2& Scrollable::ScrollCompletedSignal()
+Scrollable::ScrollCompletedSignalType& Scrollable::ScrollCompletedSignal()
{
return GetImpl(*this).ScrollCompletedSignal();
}
-Scrollable::ScrollClampedSignalV2& Scrollable::ScrollClampedSignal()
+Scrollable::ScrollClampedSignalType& Scrollable::ScrollClampedSignal()
{
return GetImpl(*this).ScrollClampedSignal();
}
public:
- typedef SignalV2< void ( const Vector3& ) > ScrollStartedSignalV2; ///< ScrollStarted signal type
- typedef SignalV2< void ( const Vector3& ) > ScrollCompletedSignalV2; ///< ScrollCompleted signal type
- typedef SignalV2< void ( const Vector3& ) > ScrollUpdatedSignalV2; ///< Scroll updated signal type
- typedef SignalV2< void ( const ClampEvent& ) > ScrollClampedSignalV2; ///< Scroll clamped signal type
+ typedef Signal< void ( const Vector3& ) > ScrollStartedSignalType; ///< ScrollStarted signal type
+ typedef Signal< void ( const Vector3& ) > ScrollCompletedSignalType; ///< ScrollCompleted signal type
+ typedef Signal< void ( const Vector3& ) > ScrollUpdatedSignalType; ///< Scroll updated signal type
+ typedef Signal< void ( const ClampEvent& ) > ScrollClampedSignalType; ///< Scroll clamped signal type
/**
* @brief Signal emitted when the Scrollable has moved (whether by touch or animation).
*/
- ScrollStartedSignalV2& ScrollStartedSignal();
+ ScrollStartedSignalType& ScrollStartedSignal();
/**
* @brief Signal emitted when the Scrollable has moved (whether by touch or animation).
*/
- ScrollUpdatedSignalV2& ScrollUpdatedSignal();
+ ScrollUpdatedSignalType& ScrollUpdatedSignal();
/**
* @brief Signal emitted when the Scrollable has completed movement (whether by touch or animation).
*/
- ScrollCompletedSignalV2& ScrollCompletedSignal();
+ ScrollCompletedSignalType& ScrollCompletedSignal();
/**
* @brief Signal emitted when the Scrollable is pushing against a domain boundary
*
* @return The signal to connect to
*/
- ScrollClampedSignalV2& ScrollClampedSignal();
+ ScrollClampedSignalType& ScrollClampedSignal();
public:
return GetImpl( *this ).GetScrollPosition();
}
-TextInput::InputSignalV2& TextInput::InputStartedSignal()
+TextInput::InputSignalType& TextInput::InputStartedSignal()
{
return GetImpl(*this).InputStartedSignal();
}
-TextInput::InputSignalV2& TextInput::InputFinishedSignal()
+TextInput::InputSignalType& TextInput::InputFinishedSignal()
{
return GetImpl(*this).InputFinishedSignal();
}
-TextInput::InputSignalV2& TextInput::CutAndPasteToolBarDisplayedSignal()
+TextInput::InputSignalType& TextInput::CutAndPasteToolBarDisplayedSignal()
{
return GetImpl(*this).CutAndPasteToolBarDisplayedSignal();
}
-TextInput::StyleChangedSignalV2& TextInput::StyleChangedSignal()
+TextInput::StyleChangedSignalType& TextInput::StyleChangedSignal()
{
return GetImpl(*this).StyleChangedSignal();
}
return GetImpl(*this).TextModifiedSignal();
}
-TextInput::MaxInputCharactersReachedSignalV2& TextInput::MaxInputCharactersReachedSignal()
+TextInput::MaxInputCharactersReachedSignalType& TextInput::MaxInputCharactersReachedSignal()
{
return GetImpl(*this).MaxInputCharactersReachedSignal();
}
-TextInput::InputTextExceedBoundariesSignalV2& TextInput::InputTextExceedBoundariesSignal()
+TextInput::InputTextExceedBoundariesSignalType& TextInput::InputTextExceedBoundariesSignal()
{
return GetImpl(*this).InputTextExceedBoundariesSignal();
}
public: /* Signals */
/// @brief Input Signal.
- typedef SignalV2< void ( TextInput textInput ) > InputSignalV2;
+ typedef Signal< void ( TextInput textInput ) > InputSignalType;
/// @brief Input style changed signal.
- typedef SignalV2< void ( TextInput textInput, const TextStyle& style ) > StyleChangedSignalV2;
+ typedef Signal< void ( TextInput textInput, const TextStyle& style ) > StyleChangedSignalType;
/// @brief Text modified signal.
- typedef SignalV2< void ( TextInput textInput ) > TextModifiedSignalType;
+ typedef Signal< void ( TextInput textInput ) > TextModifiedSignalType;
/// @brief Max input characters reached signal.
- typedef SignalV2< void ( TextInput textInput ) > MaxInputCharactersReachedSignalV2;
+ typedef Signal< void ( TextInput textInput ) > MaxInputCharactersReachedSignalType;
/// @brief Input text exceeds boundaries signal.
- typedef SignalV2< void ( TextInput textInput ) > InputTextExceedBoundariesSignalV2;
+ typedef Signal< void ( TextInput textInput ) > InputTextExceedBoundariesSignalType;
/**
* @brief Signal emitted when the Text-Input starts receiving input.
*/
- InputSignalV2& InputStartedSignal();
+ InputSignalType& InputStartedSignal();
/**
* @brief Signal emitted when the Text-Input is finished receiving input.
* TextInput::GetText() can be called to get current text string.
* @return The signal to connect to
*/
- InputSignalV2& InputFinishedSignal();
+ InputSignalType& InputFinishedSignal();
/**
* @brief Signal emitted when the cut and paste toolbar is displayed.
*
* @return The signal to connect to
*/
- InputSignalV2& CutAndPasteToolBarDisplayedSignal();
+ InputSignalType& CutAndPasteToolBarDisplayedSignal();
/**
* @brief Signal emitted when style changes.
*
* @return The signal to connect to
*/
- StyleChangedSignalV2& StyleChangedSignal();
+ StyleChangedSignalType& StyleChangedSignal();
/**
* @brief Signal emitted when text changes.
*
* @return The signal to connect to
*/
- MaxInputCharactersReachedSignalV2& MaxInputCharactersReachedSignal();
+ MaxInputCharactersReachedSignalType& MaxInputCharactersReachedSignal();
/**
* @brief Signal emitted when input text exceeds the boundaries of the text-input.
*
* @return The signal to connect to
*/
- InputTextExceedBoundariesSignalV2& InputTextExceedBoundariesSignal();
+ InputTextExceedBoundariesSignalType& InputTextExceedBoundariesSignal();
public: // Not intended for application developers
return GetImpl( *this ).IsScrollPositionTrimmed();
}
-TextView::ScrolledSignalV2& TextView::ScrolledSignal()
+TextView::ScrolledSignalType& TextView::ScrolledSignal()
{
return GetImpl( *this ).ScrolledSignal();
}
public:
/// @brief Signal types
- typedef SignalV2< void ( TextView textView, Vector2 scrollDelta ) > ScrolledSignalV2;
+ typedef Signal< void ( TextView textView, Vector2 scrollDelta ) > ScrolledSignalType;
/**
* @brief Signal emitted when the text is scrolled inside the text-view.
* \e scrollDelta is the differente of the current scroll position with the previous one.
* @return The signal to connect to
*/
- ScrolledSignalV2& ScrolledSignal();
+ ScrolledSignalType& ScrolledSignal();
public: // Not intended for application developers
return GetImpl(*this).GetFocusGroup(actor);
}
-FocusManager::FocusChangedSignalV2& FocusManager::FocusChangedSignal()
+FocusManager::FocusChangedSignalType& FocusManager::FocusChangedSignal()
{
return GetImpl(*this).FocusChangedSignal();
}
-FocusManager::FocusOvershotSignalV2& FocusManager::FocusOvershotSignal()
+FocusManager::FocusOvershotSignalType& FocusManager::FocusOvershotSignal()
{
return GetImpl(*this).FocusOvershotSignal();
}
-FocusManager::FocusedActorActivatedSignalV2& FocusManager::FocusedActorActivatedSignal()
+FocusManager::FocusedActorActivatedSignalType& FocusManager::FocusedActorActivatedSignal()
{
return GetImpl(*this).FocusedActorActivatedSignal();
}
public:
/// @brief Focus changed signal
- typedef SignalV2< void ( Actor, Actor ) > FocusChangedSignalV2;
+ typedef Signal< void ( Actor, Actor ) > FocusChangedSignalType;
/// @brief Focus overshooted signal
- typedef SignalV2< void ( Actor, FocusOvershotDirection ) > FocusOvershotSignalV2;
+ typedef Signal< void ( Actor, FocusOvershotDirection ) > FocusOvershotSignalType;
/// @brief Focused actor activated signal
- typedef SignalV2< void ( Actor ) > FocusedActorActivatedSignalV2;
+ typedef Signal< void ( Actor ) > FocusedActorActivatedSignalType;
/**
* @brief Create a FocusManager handle; this can be initialised with FocusManager::New().
* @pre The Object has been initialized.
* @return The signal to connect to.
*/
- FocusChangedSignalV2& FocusChangedSignal();
+ FocusChangedSignalType& FocusChangedSignal();
/**
* @brief This signal is emitted when there is no way to move focus further.
* @pre The Object has been initialized.
* @return The signal to connect to.
*/
- FocusOvershotSignalV2& FocusOvershotSignal();
+ FocusOvershotSignalType& FocusOvershotSignal();
/**
* @brief This signal is emitted when the current focused actor is activated.
* @pre The Object has been initialized.
* @return The signal to connect to.
*/
- FocusedActorActivatedSignalV2& FocusedActorActivatedSignal();
+ FocusedActorActivatedSignalType& FocusedActorActivatedSignal();
private:
return GetImpl(*this).GetFocusIndicatorActor();
}
-KeyboardFocusManager::PreFocusChangeSignalV2& KeyboardFocusManager::PreFocusChangeSignal()
+KeyboardFocusManager::PreFocusChangeSignalType& KeyboardFocusManager::PreFocusChangeSignal()
{
return GetImpl(*this).PreFocusChangeSignal();
}
-KeyboardFocusManager::FocusChangedSignalV2& KeyboardFocusManager::FocusChangedSignal()
+KeyboardFocusManager::FocusChangedSignalType& KeyboardFocusManager::FocusChangedSignal()
{
return GetImpl(*this).FocusChangedSignal();
}
-KeyboardFocusManager::FocusGroupChangedSignalV2& KeyboardFocusManager::FocusGroupChangedSignal()
+KeyboardFocusManager::FocusGroupChangedSignalType& KeyboardFocusManager::FocusGroupChangedSignal()
{
return GetImpl(*this).FocusGroupChangedSignal();
}
-KeyboardFocusManager::FocusedActorActivatedSignalV2& KeyboardFocusManager::FocusedActorActivatedSignal()
+KeyboardFocusManager::FocusedActorActivatedSignalType& KeyboardFocusManager::FocusedActorActivatedSignal()
{
return GetImpl(*this).FocusedActorActivatedSignal();
}
public:
/// @brief Pre focus change signal
- typedef SignalV2< Actor ( Actor, Actor, Control::KeyboardFocusNavigationDirection ) > PreFocusChangeSignalV2;
+ typedef Signal< Actor ( Actor, Actor, Control::KeyboardFocusNavigationDirection ) > PreFocusChangeSignalType;
/// @brief Focus changed signal
- typedef SignalV2< void ( Actor, Actor ) > FocusChangedSignalV2;
+ typedef Signal< void ( Actor, Actor ) > FocusChangedSignalType;
/// @brief Focus group changed signal
- typedef SignalV2< void ( Actor, bool ) > FocusGroupChangedSignalV2;
+ typedef Signal< void ( Actor, bool ) > FocusGroupChangedSignalType;
/// @brief Focused actor activated signal
- typedef SignalV2< void ( Actor ) > FocusedActorActivatedSignalV2;
+ typedef Signal< void ( Actor ) > FocusedActorActivatedSignalType;
/**
* @brief Create a KeyboardFocusManager handle; this can be initialised with KeyboardFocusManager::New().
* @pre The Object has been initialized.
* @return The signal to connect to.
*/
- PreFocusChangeSignalV2& PreFocusChangeSignal();
+ PreFocusChangeSignalType& PreFocusChangeSignal();
/**
* @brief This signal is emitted after the current focused actor has been changed.
* @pre The Object has been initialized.
* @return The signal to connect to.
*/
- FocusChangedSignalV2& FocusChangedSignal();
+ FocusChangedSignalType& FocusChangedSignal();
/**
* @brief This signal is emitted when the focus group has been changed.
* @pre The Object has been initialized.
* @return The signal to connect to.
*/
- FocusGroupChangedSignalV2& FocusGroupChangedSignal();
+ FocusGroupChangedSignalType& FocusGroupChangedSignal();
/**
* @brief This signal is emitted when the current focused actor is activated.
* @pre The Object has been initialized.
* @return The signal to connect to.
*/
- FocusedActorActivatedSignalV2& FocusedActorActivatedSignal();
+ FocusedActorActivatedSignalType& FocusedActorActivatedSignal();
// Not intended for application developers
return GetImpl(*this).IsKeyboardListener(control);
}
-KeyInputFocusManager::KeyInputFocusChangedSignalV2& KeyInputFocusManager::KeyInputFocusChangedSignal()
+KeyInputFocusManager::KeyInputFocusChangedSignalType& KeyInputFocusManager::KeyInputFocusChangedSignal()
{
return GetImpl(*this).KeyInputFocusChangedSignal();
}
-KeyInputFocusManager::UnhandledKeyEventSignalV2& KeyInputFocusManager::UnhandledKeyEventSignal()
+KeyInputFocusManager::UnhandledKeyEventSignalType& KeyInputFocusManager::UnhandledKeyEventSignal()
{
return GetImpl(*this).UnhandledKeyEventSignal();
}
static const char* const SIGNAL_UNHANDLED_KEY_EVENT;
// KeyInputFocusChanged
- typedef SignalV2< void (Control, Control) > KeyInputFocusChangedSignalV2;
+ typedef Signal< void (Control, Control) > KeyInputFocusChangedSignalType;
// Unhandled Key Event
- typedef SignalV2< void (const KeyEvent&) > UnhandledKeyEventSignalV2;
+ typedef Signal< void (const KeyEvent&) > UnhandledKeyEventSignalType;
public:
* @endcode
* @return The signal to connect to.
*/
- KeyInputFocusChangedSignalV2& KeyInputFocusChangedSignal();
+ KeyInputFocusChangedSignalType& KeyInputFocusChangedSignal();
/**
* This signal is emitted when a key event was received, and none of the focused controls on the stage have consumed it.
* @endcode
* @return The signal to connect to.
*/
- UnhandledKeyEventSignalV2& UnhandledKeyEventSignal();
+ UnhandledKeyEventSignalType& UnhandledKeyEventSignal();
private:
public:
// Signals
- typedef SignalV2< void ( StyleManager, StyleChange ) > StyleChangeSignalType;
+ typedef Signal< void ( StyleManager, StyleChange ) > StyleChangeSignalType;
/**
* @brief Create a StyleManager handle; this can be initialised with StyleManager::Get()
}
}
-Toolkit::NavigationControl::ItemPushedSignalV2& NavigationControl::ItemPushedSignal()
+Toolkit::NavigationControl::ItemPushedSignalType& NavigationControl::ItemPushedSignal()
{
return mItemPushedSignal;
}
-Toolkit::NavigationControl::ItemPoppedSignalV2& NavigationControl::ItemPoppedSignal()
+Toolkit::NavigationControl::ItemPoppedSignalType& NavigationControl::ItemPoppedSignal()
{
return mItemPoppedSignal;
}
/**
* @copydoc Dali::Toolkit::NavigatinControl::ItemPushedSignal()
*/
- Toolkit::NavigationControl::ItemPushedSignalV2& ItemPushedSignal();
+ Toolkit::NavigationControl::ItemPushedSignalType& ItemPushedSignal();
/**
* @copydoc Dali::Toolkit::NavigatinControl::ItemPoppedSignal()
*/
- Toolkit::NavigationControl::ItemPoppedSignalV2& ItemPoppedSignal();
+ Toolkit::NavigationControl::ItemPoppedSignalType& ItemPoppedSignal();
private: // override functions from Control
Toolkit::Popup mPopupMenu;
private:
- Toolkit::NavigationControl::ItemPushedSignalV2 mItemPushedSignal; ///< The signal to notify the item push
- Toolkit::NavigationControl::ItemPoppedSignalV2 mItemPoppedSignal; ///< The signal to notify the item pop
+ Toolkit::NavigationControl::ItemPushedSignalType mItemPushedSignal; ///< The signal to notify the item push
+ Toolkit::NavigationControl::ItemPoppedSignalType mItemPoppedSignal; ///< The signal to notify the item pop
};
} // namespace Internal
}
Toolkit::View handle( GetOwner() );
- mOrientationAnimationStartedSignalV2.Emit( handle, mRotateAnimation, orientation );
+ mOrientationAnimationStartedSignal.Emit( handle, mRotateAnimation, orientation );
mRotateAnimation.Play();
}
mAutoRotateEnabled = enabled;
}
-Toolkit::View::OrientationAnimationStartedSignalV2& View::OrientationAnimationStartedSignal()
+Toolkit::View::OrientationAnimationStartedSignalType& View::OrientationAnimationStartedSignal()
{
- return mOrientationAnimationStartedSignalV2;
+ return mOrientationAnimationStartedSignal;
}
bool View::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
/**
* @copydoc Dali::Toolkit::View::AnimationStartedSignalOrientation()
*/
- Toolkit::View::OrientationAnimationStartedSignalV2& OrientationAnimationStartedSignal();
+ Toolkit::View::OrientationAnimationStartedSignalType& OrientationAnimationStartedSignal();
/**
* Connects a callback function with the object's signals.
float mOrientationFunction[4]; ///< The orientation function used to transform from degrees to the internal orientation.
bool mAutoRotateEnabled; ///< Whether the view rotates if the OrientationChanged method is called.
- Toolkit::View::OrientationAnimationStartedSignalV2 mOrientationAnimationStartedSignalV2;
+ Toolkit::View::OrientationAnimationStartedSignalType mOrientationAnimationStartedSignal;
};
} // namespace Internal
//Emit signal
Toolkit::CubeTransitionEffect handle( this );
- mTransitionCompletedSignalV2.Emit( handle, mCurrentImage );
+ mTransitionCompletedSignal.Emit( handle, mCurrentImage );
}
-Toolkit::CubeTransitionEffect::TransitionCompletedSignalV2& CubeTransitionEffect::TransitionCompletedSignal()
+Toolkit::CubeTransitionEffect::TransitionCompletedSignalType& CubeTransitionEffect::TransitionCompletedSignal()
{
- return mTransitionCompletedSignalV2;
+ return mTransitionCompletedSignal;
}
} // namespace Internal
/**
* @copydoc Toolkit::CubeTransitionEffect::TransitionCompletedSignal()
*/
- Toolkit::CubeTransitionEffect::TransitionCompletedSignalV2& TransitionCompletedSignal();
+ Toolkit::CubeTransitionEffect::TransitionCompletedSignalType& TransitionCompletedSignal();
protected:
private:
- Toolkit::CubeTransitionEffect::TransitionCompletedSignalV2 mTransitionCompletedSignalV2;
+ Toolkit::CubeTransitionEffect::TransitionCompletedSignalType mTransitionCompletedSignal;
};
/**
* Signal type for notifications
*/
- typedef SignalV2< void (GaussianBlurView source) > GaussianBlurViewSignal;
+ typedef Signal< void (GaussianBlurView source) > GaussianBlurViewSignal;
/**
* Create an uninitialized GaussianBlurView; this can be initialized with GaussianBlurView::New()
public: /* Signals */
/// @brief Finished signal type.
- typedef SignalV2< void (MaskedImageView& source) > MaskedImageViewSignal;
+ typedef Signal< void (MaskedImageView& source) > MaskedImageViewSignal;
/**
* @brief Signal emitted when the render task which targets the
GetImpl( *this ).SetOrientationRotateAnimation( duration, alphaFunc );
}
-NavigationControl::ItemPushedSignalV2& NavigationControl::ItemPushedSignal()
+NavigationControl::ItemPushedSignalType& NavigationControl::ItemPushedSignal()
{
return GetImpl( *this ).ItemPushedSignal();
}
-NavigationControl::ItemPoppedSignalV2& NavigationControl::ItemPoppedSignal()
+NavigationControl::ItemPoppedSignalType& NavigationControl::ItemPoppedSignal()
{
return GetImpl( *this ).ItemPoppedSignal();
}
public: //Signal
- typedef SignalV2< void( NavigationControl, Page ) > ItemPushedSignalV2;
- typedef SignalV2< void( NavigationControl, Page ) > ItemPoppedSignalV2;
+ typedef Signal< void( NavigationControl, Page ) > ItemPushedSignalType;
+ typedef Signal< void( NavigationControl, Page ) > ItemPoppedSignalType;
/**
* Signal emitted right after a new item is pushed into the navigation stack.
* @endcode
* @return The signal to connect to.
*/
- ItemPushedSignalV2& ItemPushedSignal();
+ ItemPushedSignalType& ItemPushedSignal();
/**
* Signal emitted right after an item is popped out from the navigation stack.
* The app can use this signal and check the poppedItem to be uninitialized to know the app window should be lower
* @return The signal to connect to.
*/
- ItemPoppedSignalV2& ItemPoppedSignal();
+ ItemPoppedSignalType& ItemPoppedSignal();
/**
* Signal type for notification
*/
- typedef SignalV2< void ( int ) > RefreshSignal;
+ typedef Signal< void ( int ) > RefreshSignal;
/**
* Signal emitted when the Actor tree is ready for rendering into the page image.
public: //Signal
// Page Turned signal, with page index and boolean turning direction (true = forward, false = backward)
- typedef SignalV2< void ( PageTurnView, unsigned int, bool ) > PageTurnSignal;
- typedef SignalV2< void ( PageTurnView ) > PagePanSignal;
+ typedef Signal< void ( PageTurnView, unsigned int, bool ) > PageTurnSignal;
+ typedef Signal< void ( PageTurnView ) > PagePanSignal;
/**
* Signal emitted when a page has started to turn over.
// Signals
// Value changed
- typedef SignalV2< bool ( Slider, float ) > ValueChangedSignalType;
- typedef SignalV2< bool ( Slider, int ) > MarkSignalType;
+ typedef Signal< bool ( Slider, float ) > ValueChangedSignalType;
+ typedef Signal< bool ( Slider, int ) > MarkSignalType;
/**
* Signal emitted when the slider value changes
/**
* @brief Signal type for notifications.
*/
- typedef SignalV2< void (SuperBlurView source) > SuperBlurViewSignal;
+ typedef Signal< void (SuperBlurView source) > SuperBlurViewSignal;
/**
* @brief Creates an empty SuperBlurView handle.
GetImpl( *this ).SetAutoRotate( enabled );
}
-View::OrientationAnimationStartedSignalV2& View::OrientationAnimationStartedSignal()
+View::OrientationAnimationStartedSignalType& View::OrientationAnimationStartedSignal()
{
return GetImpl( *this ).OrientationAnimationStartedSignal();
}
public: //Signals
// Orientation change animation starts.
- typedef SignalV2< void ( View, Animation&, const Orientation& ) > OrientationAnimationStartedSignalV2;
+ typedef Signal< void ( View, Animation&, const Orientation& ) > OrientationAnimationStartedSignalType;
/**
* Signal emitted just before the rotate animation starts when the device orientation changes.
*/
- OrientationAnimationStartedSignalV2& OrientationAnimationStartedSignal();
+ OrientationAnimationStartedSignalType& OrientationAnimationStartedSignal();
public: // Not intended for application developers
GetImpl(*this).StopTransition();
}
-CubeTransitionEffect::TransitionCompletedSignalV2& CubeTransitionEffect::TransitionCompletedSignal()
+CubeTransitionEffect::TransitionCompletedSignalType& CubeTransitionEffect::TransitionCompletedSignal()
{
return GetImpl( *this ).TransitionCompletedSignal();
}
static const char* const SIGNAL_TRANSITION_COMPLETED;
//Transition animation completed signal
- typedef SignalV2< void ( CubeTransitionEffect, ImageActor ) > TransitionCompletedSignalV2;
+ typedef Signal< void ( CubeTransitionEffect, ImageActor ) > TransitionCompletedSignalType;
/**
* Signal emitted when the transition has completed animation
* @endcode
* @return The Signal to connect to.
*/
- TransitionCompletedSignalV2& TransitionCompletedSignal();
+ TransitionCompletedSignalType& TransitionCompletedSignal();
public: // Not intended for developer use
projects / platform / core / uifw / dali-toolkit.git / commitdiff