%define STAGE_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
%typemap(cscode) NameSpace::ClassName %{
-/**
- * @brief Event arguments that passed via Touch signal
- *
- */
-public class TouchEventArgs : EventArgs
-{
- private TouchData _touchData;
-
- /**
- * @brief TouchData - contains the information of touch points
- *
- */
- public TouchData TouchData
- {
- get
- {
- return _touchData;
- }
- set
- {
- _touchData = value;
- }
- }
-}
-
-
-/**
- * @brief Event arguments that passed via Wheel signal
- *
- */
-public class WheelEventArgs : EventArgs
-{
- private WheelEvent _wheelEvent;
-
- /**
- * @brief WheelEvent - store a wheel rolling type MOUSE_WHEEL or CUSTOM_WHEEL
- *
- */
- public WheelEvent WheelEvent
- {
- get
- {
- return _wheelEvent;
- }
- set
- {
- _wheelEvent = value;
- }
- }
-}
-
-/**
- * @brief Event arguments that passed via KeyEvent signal
- *
- */
-public class KeyEventArgs : EventArgs
-{
- private KeyEvent _keyEvent;
-
- /**
- * @brief KeyEvent - is the keyevent sent to Stage.
- *
- */
- public KeyEvent KeyEvent
- {
- get
- {
- return _keyEvent;
- }
- set
- {
- _keyEvent = value;
- }
- }
-}
-
-/**
- * @brief Event arguments that passed via EventProcessingFinished signal
- *
- */
-public class EventProcessingFinishedEventArgs : EventArgs
-{
-}
-
-/**
- * @brief Event arguments that passed via ContextLost signal
- *
- */
-public class ContextLostEventArgs : EventArgs
-{
-}
-
-/**
- * @brief Event arguments that passed via ContextRegained signal
- *
- */
-public class ContextRegainedEventArgs : EventArgs
-{
-}
-/**
- * @brief Event arguments that passed via SceneCreated signal
- *
- */
-public class SceneCreatedEventArgs : EventArgs
-{
-}
-
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void StageTouchCallbackDelegate(IntPtr data);
- private DaliEventHandler<object,TouchEventArgs> _stageTouchEventHandler;
- private StageTouchCallbackDelegate _stageTouchCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void WheelCallbackDelegate(IntPtr data);
- private DaliEventHandler<object,WheelEventArgs> _stageWheelEventHandler;
- private WheelCallbackDelegate _stageWheelCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void KeyCallbackDelegate(IntPtr data);
- private DaliEventHandler<object,KeyEventArgs> _stageKeyEventHandler;
- private KeyCallbackDelegate _stageKeyCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void EventProcessingFinishedEventCallbackDelegate();
- private DaliEventHandler<object,EventProcessingFinishedEventArgs> _stageEventProcessingFinishedEventHandler;
- private EventProcessingFinishedEventCallbackDelegate _stageEventProcessingFinishedEventCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void ContextLostEventCallbackDelegate();
- private DaliEventHandler<object,ContextLostEventArgs> _stageContextLostEventHandler;
- private ContextLostEventCallbackDelegate _stageContextLostEventCallbackDelegate;
+ /**
+ * @brief Event arguments that passed via Touch signal
+ *
+ */
+ public class TouchEventArgs : EventArgs
+ {
+ private Touch _touch;
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void ContextRegainedEventCallbackDelegate();
- private DaliEventHandler<object,ContextRegainedEventArgs> _stageContextRegainedEventHandler;
- private ContextRegainedEventCallbackDelegate _stageContextRegainedEventCallbackDelegate;
+ /**
+ * @brief Touch - contains the information of touch points
+ *
+ */
+ public Touch Touch
+ {
+ get
+ {
+ return _touch;
+ }
+ set
+ {
+ _touch = value;
+ }
+ }
+ }
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void SceneCreatedEventCallbackDelegate();
- private DaliEventHandler<object,SceneCreatedEventArgs> _stageSceneCreatedEventHandler;
- private SceneCreatedEventCallbackDelegate _stageSceneCreatedEventCallbackDelegate;
+ private event EventHandler<TouchEventArgs> _stageTouchHandler;
+ private EventCallbackDelegateType1<IntPtr> _stageTouchCallbackDelegate;
/**
- * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of TouchEventHandler-DaliEventHandler<object,TouchEventArgs>) provided by the user.
- * Touched signal is emitted when the screen is touched and when the touch ends
+ * @brief Event for TouchEvent signal which can be used to subscribe/unsubscribe the event handler
+ * TouchEvent signal is emitted when the screen is touched and when the touch ends
* (i.e. the down & up touch events only).
*
*/
- public event DaliEventHandler<object,TouchEventArgs> Touched
+ public event EventHandler<TouchEventArgs> Touch
{
add
{
lock(this)
{
- // Restricted to only one listener
- if (_stageTouchEventHandler == null)
- {
- _stageTouchEventHandler += value;
-
- _stageTouchCallbackDelegate = new StageTouchCallbackDelegate(OnStageTouch);
- this.TouchSignal().Connect(_stageTouchCallbackDelegate);
- }
+ _stageTouchHandler += value;
+ _stageTouchCallbackDelegate = OnStageTouch;
+ this.TouchSignal().Connect(_stageTouchCallbackDelegate);
}
}
-
remove
{
lock(this)
{
- if (_stageTouchEventHandler != null)
+ if (_stageTouchHandler != null)
{
this.TouchSignal().Disconnect(_stageTouchCallbackDelegate);
}
-
- _stageTouchEventHandler -= value;
+ _stageTouchHandler -= value;
}
}
}
- // Callback for Stage Touch signal
private void OnStageTouch(IntPtr data)
{
- TouchEventArgs e = new TouchEventArgs();
+ TouchEventArgs e = new TouchEventArgs();
+
+ if( data != null )
+ {
+ e.Touch = Dali.Touch.GetTouchFromPtr( data );
+ }
+
+ if (_stageTouchHandler != null)
+ {
+ _stageTouchHandler(this, e);
+ }
+ }
- // Populate all members of "e" (TouchEventArgs) with real data
- e.TouchData = TouchData.GetTouchDataFromPtr( data );
+ /**
+ * @brief Wheel arguments that passed via Wheel signal
+ *
+ */
+ public class WheelEventArgs : EventArgs
+ {
+ private Wheel _wheel;
- if (_stageTouchEventHandler != null)
+ /**
+ * @brief Wheel - store a wheel rolling type MOUSE_WHEEL or CUSTOM_WHEEL
+ *
+ */
+ public Wheel Wheel
{
- //here we send all data to user event handlers
- _stageTouchEventHandler(this, e);
+ get
+ {
+ return _wheel;
+ }
+ set
+ {
+ _wheel = value;
+ }
}
}
+ private event EventHandler<WheelEventArgs> _stageWheelHandler;
+ private EventCallbackDelegateType1<IntPtr> _stageWheelCallbackDelegate;
+
/**
- * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of WheelEventHandler-DaliEventHandler<object,WheelEventArgs>) provided by the user.
- * WheelMoved signal is emitted is emitted when wheel event is received.
+ * @brief Event for Wheel signal which can be used to subscribe/unsubscribe the event handler
+ * Wheel signal is emitted is emitted when wheel event is received.
*
*/
- public event DaliEventHandler<object,WheelEventArgs> WheelMoved
+ public event EventHandler<WheelEventArgs> Wheel
{
add
{
lock(this)
{
- // Restricted to only one listener
- if (_stageWheelEventHandler == null)
- {
- _stageWheelEventHandler += value;
-
- _stageWheelCallbackDelegate = new WheelCallbackDelegate(OnStageWheel);
- this.WheelEventSignal().Connect(_stageWheelCallbackDelegate);
- }
+ _stageWheelHandler += value;
+ _stageWheelCallbackDelegate = OnStageWheel;
+ this.WheelEventSignal().Connect(_stageWheelCallbackDelegate);
}
}
-
remove
{
lock(this)
{
- if (_stageWheelEventHandler != null)
+ if (_stageWheelHandler != null)
{
this.WheelEventSignal().Disconnect(_stageWheelCallbackDelegate);
}
-
- _stageWheelEventHandler -= value;
+ _stageWheelHandler -= value;
}
}
}
- // Callback for Stage WheelEventsignal
private void OnStageWheel(IntPtr data)
{
- WheelEventArgs e = new WheelEventArgs();
+ WheelEventArgs e = new WheelEventArgs();
- // Populate all members of "e" (WheelEventArgs) with real data
- e.WheelEvent = Dali.WheelEvent.GetWheelEventFromPtr( data );
+ if( data != null )
+ {
+ e.Wheel = Dali.Wheel.GetWheelFromPtr( data );
+ }
+
+ if (_stageWheelHandler != null)
+ {
+ _stageWheelHandler(this, e);
+ }
+ }
+
+ /**
+ * @brief Event arguments that passed via Key signal
+ *
+ */
+ public class KeyEventArgs : EventArgs
+ {
+ private Key _key;
- if (_stageWheelEventHandler != null)
+ /**
+ * @brief Key - is the keyevent sent to Stage.
+ *
+ */
+ public Key Key
{
- //here we send all data to user event handlers
- _stageWheelEventHandler(this, e);
+ get
+ {
+ return _key;
+ }
+ set
+ {
+ _key = value;
+ }
}
}
+ private event EventHandler<KeyEventArgs> _stageKeyHandler;
+ private EventCallbackDelegateType1<IntPtr> _stageKeyCallbackDelegate;
+
/**
- * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of KeyEventHandler-DaliEventHandler<object,KeyEventArgs>) provided by the user.
- * KeyPressed signal is emitted is emitted when key event is received.
+ * @brief Event for Key signal which can be used to subscribe/unsubscribe the event handler
+ * Key signal is emitted is emitted when key event is received.
*
*/
- public event DaliEventHandler<object,KeyEventArgs> KeyPressed
+ public event EventHandler<KeyEventArgs> Key
{
add
{
lock(this)
{
- // Restricted to only one listener
- if (_stageKeyEventHandler == null)
- {
- _stageKeyEventHandler += value;
-
- _stageKeyCallbackDelegate = new KeyCallbackDelegate(OnStageKey);
- this.KeyEventSignal().Connect(_stageKeyCallbackDelegate);
- }
+ _stageKeyHandler += value;
+ _stageKeyCallbackDelegate = OnStageKey;
+ this.KeyEventSignal().Connect(_stageKeyCallbackDelegate);
}
}
-
remove
{
lock(this)
{
- if (_stageKeyEventHandler != null)
+ if (_stageKeyHandler != null)
{
this.KeyEventSignal().Disconnect(_stageKeyCallbackDelegate);
}
-
- _stageKeyEventHandler -= value;
+ _stageKeyHandler -= value;
}
}
}
// Callback for Stage KeyEventsignal
- private void OnStageKey(IntPtr keyEvent)
+ private void OnStageKey(IntPtr data)
{
- KeyEventArgs e = new KeyEventArgs();
+ KeyEventArgs e = new KeyEventArgs();
+
+ if( data != null )
+ {
+ e.Key = Dali.Key.GetKeyFromPtr( data );
+ }
+
+ if (_stageKeyHandler != null)
+ {
+ //here we send all data to user event handlers
+ _stageKeyHandler(this, e);
+ }
+ }
- // Populate all members of "e" (KeyEventArgs) with real data
- e.KeyEvent = Dali.KeyEvent.GetKeyEventFromPtr( keyEvent );
- if (_stageKeyEventHandler != null)
- {
- //here we send all data to user event handlers
- _stageKeyEventHandler(this, e);
- }
- }
+ private event EventHandler _stageEventProcessingFinishedEventHandler;
+ private EventCallbackDelegateType0 _stageEventProcessingFinishedEventCallbackDelegate;
/**
* @brief Event for EventProcessingFinished signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of EventProcessingFinishedEventHandler-DaliEventHandler<object,EventProcessingFinishedEventArgs>)
* provided by the user. EventProcessingFinished signal is emitted just after the event processing is finished.
*
*/
- public event DaliEventHandler<object,EventProcessingFinishedEventArgs> EventProcessingFinished
+ public event EventHandler EventProcessingFinished
{
add
{
lock(this)
{
- // Restricted to only one listener
- if (_stageEventProcessingFinishedEventHandler == null)
- {
- _stageEventProcessingFinishedEventHandler += value;
-
- _stageEventProcessingFinishedEventCallbackDelegate = new EventProcessingFinishedEventCallbackDelegate(OnEventProcessingFinished);
- this.EventProcessingFinishedSignal().Connect(_stageEventProcessingFinishedEventCallbackDelegate);
- }
+ _stageEventProcessingFinishedEventHandler += value;
+ _stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished;
+ this.EventProcessingFinishedSignal().Connect(_stageEventProcessingFinishedEventCallbackDelegate);
}
}
-
remove
{
lock(this)
{
this.EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate);
}
-
_stageEventProcessingFinishedEventHandler -= value;
}
}
// Callback for Stage EventProcessingFinishedSignal
private void OnEventProcessingFinished()
{
- EventProcessingFinishedEventArgs e = new EventProcessingFinishedEventArgs();
-
if (_stageEventProcessingFinishedEventHandler != null)
{
- //here we send all data to user event handlers
- _stageEventProcessingFinishedEventHandler(this, e);
+ _stageEventProcessingFinishedEventHandler(this, null);
}
}
+
+ private EventHandler _stageContextLostEventHandler;
+ private EventCallbackDelegateType0 _stageContextLostEventCallbackDelegate;
+
/**
* @brief Event for ContextLost signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of ContextLostEventHandler-DaliEventHandler<object,ContextLostEventArgs>) provided by the user.
* ContextLost signal is emitted when the GL context is lost (Platform specific behaviour).
*
*/
- public event DaliEventHandler<object,ContextLostEventArgs> ContextLost
+ public event EventHandler ContextLost
{
add
{
lock(this)
{
- // Restricted to only one listener
- if (_stageContextLostEventHandler == null)
- {
- _stageContextLostEventHandler += value;
-
- _stageContextLostEventCallbackDelegate = new ContextLostEventCallbackDelegate(OnContextLost);
- this.ContextLostSignal().Connect(_stageContextLostEventCallbackDelegate);
- }
+ _stageContextLostEventHandler += value;
+ _stageContextLostEventCallbackDelegate = OnContextLost;
+ this.ContextLostSignal().Connect(_stageContextLostEventCallbackDelegate);
}
}
-
remove
{
lock(this)
// Callback for Stage ContextLostSignal
private void OnContextLost()
{
- ContextLostEventArgs e = new ContextLostEventArgs();
-
if (_stageContextLostEventHandler != null)
{
- //here we send all data to user event handlers
- _stageContextLostEventHandler(this, e);
+ _stageContextLostEventHandler(this, null);
}
}
+
+ private EventHandler _stageContextRegainedEventHandler;
+ private EventCallbackDelegateType0 _stageContextRegainedEventCallbackDelegate;
+
/**
* @brief Event for ContextRegained signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of ContextRegainedEventHandler-DaliEventHandler<object,ContextRegainedEventArgs>)
* provided by the user. ContextRegained signal is emitted when the GL context is regained (Platform specific
* behaviour).
*
*/
- public event DaliEventHandler<object,ContextRegainedEventArgs> ContextRegained
+ public event EventHandler ContextRegained
{
add
{
lock(this)
{
- // Restricted to only one listener
- if (_stageContextRegainedEventHandler == null)
- {
- _stageContextRegainedEventHandler += value;
-
- _stageContextRegainedEventCallbackDelegate = new ContextRegainedEventCallbackDelegate(OnContextRegained);
- this.ContextRegainedSignal().Connect(_stageContextRegainedEventCallbackDelegate);
- }
+ _stageContextRegainedEventHandler += value;
+ _stageContextRegainedEventCallbackDelegate = OnContextRegained;
+ this.ContextRegainedSignal().Connect(_stageContextRegainedEventCallbackDelegate);
}
}
-
remove
{
lock(this)
// Callback for Stage ContextRegainedSignal
private void OnContextRegained()
{
- ContextRegainedEventArgs e = new ContextRegainedEventArgs();
-
if (_stageContextRegainedEventHandler != null)
{
- //here we send all data to user event handlers
- _stageContextRegainedEventHandler(this, e);
+ _stageContextRegainedEventHandler(this, null);
}
}
+
+ private EventHandler _stageSceneCreatedEventHandler;
+ private EventCallbackDelegateType0 _stageSceneCreatedEventCallbackDelegate;
+
/**
* @brief Event for SceneCreated signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of SceneCreatedEventHandler-DaliEventHandler<object,SceneCreatedEventArgs>) provided by the user.
* SceneCreated signal is emitted after the initial scene is created.
*
*/
- public event DaliEventHandler<object,SceneCreatedEventArgs> SceneCreated
+ public event EventHandler SceneCreated
{
add
{
lock(this)
{
- // Restricted to only one listener
- if (_stageSceneCreatedEventHandler == null)
- {
- _stageSceneCreatedEventHandler += value;
-
- _stageSceneCreatedEventCallbackDelegate = new SceneCreatedEventCallbackDelegate(OnSceneCreated);
- this.SceneCreatedSignal().Connect(_stageSceneCreatedEventCallbackDelegate);
- }
+ _stageSceneCreatedEventHandler += value;
+ _stageSceneCreatedEventCallbackDelegate = OnSceneCreated;
+ this.SceneCreatedSignal().Connect(_stageSceneCreatedEventCallbackDelegate);
}
}
-
remove
{
lock(this)
// Callback for Stage SceneCreatedSignal
private void OnSceneCreated()
{
- SceneCreatedEventArgs e = new SceneCreatedEventArgs();
-
if (_stageSceneCreatedEventHandler != null)
{
- //here we send all data to user event handlers
- _stageSceneCreatedEventHandler(this, e);
+ _stageSceneCreatedEventHandler(this, null);
}
}
+
public Vector2 Size
{
get
}
}
+ private static readonly Stage instance = Stage.GetCurrent();
+
+ public static Stage Instance
+ {
+ get
+ {
+ return instance;
+ }
+ }
+
+ public Layer GetDefaultLayer()
+ {
+ return this.GetRootLayer();
+ }
+
+ public void AddLayer(Layer layer)
+ {
+ this.Add( (Actor)layer );
+ }
+
+ public void RemoveLayer(Layer layer)
+ {
+ this.Remove( (Actor)layer );
+ }
+
+
%}
%enddef
projects / platform / core / uifw / dali-toolkit.git / blobdiff