%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)]
- public delegate void TouchEventHandler(object source, TouchEventArgs e);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void WheelEventHandler(object source, WheelEventArgs e);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void KeyEventHandler(object source, KeyEventArgs e);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void EventProcessingFinishedEventHandler(object source, EventProcessingFinishedEventArgs e);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void ContextLostEventHandler(object source, ContextLostEventArgs e);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void ContextRegainedEventHandler(object source, ContextRegainedEventArgs e);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- public delegate void SceneCreatedEventHandler(object source, SceneCreatedEventArgs e);
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void StageTouchCallbackDelegate(IntPtr data);
- private TouchEventHandler _stageTouchEventHandler;
- private StageTouchCallbackDelegate _stageTouchCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void WheelCallbackDelegate(IntPtr data);
- private WheelEventHandler _stageWheelEventHandler;
- private WheelCallbackDelegate _stageWheelCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void KeyCallbackDelegate(IntPtr data);
- private KeyEventHandler _stageKeyEventHandler;
- private KeyCallbackDelegate _stageKeyCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void EventProcessingFinishedEventCallbackDelegate();
- private EventProcessingFinishedEventHandler _stageEventProcessingFinishedEventHandler;
- private EventProcessingFinishedEventCallbackDelegate _stageEventProcessingFinishedEventCallbackDelegate;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void ContextLostEventCallbackDelegate();
- private ContextLostEventHandler _stageContextLostEventHandler;
- private ContextLostEventCallbackDelegate _stageContextLostEventCallbackDelegate;
+ /**
+ * @brief Event arguments that passed via Touch signal
+ *
+ */
+ public class TouchEventArgs : EventArgs
+ {
+ private TouchData _touchData;
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void ContextRegainedEventCallbackDelegate();
- private ContextRegainedEventHandler _stageContextRegainedEventHandler;
- private ContextRegainedEventCallbackDelegate _stageContextRegainedEventCallbackDelegate;
+ /**
+ * @brief TouchData - contains the information of touch points
+ *
+ */
+ public TouchData TouchData
+ {
+ get
+ {
+ return _touchData;
+ }
+ set
+ {
+ _touchData = value;
+ }
+ }
+ }
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void SceneCreatedEventCallbackDelegate();
- private SceneCreatedEventHandler _stageSceneCreatedEventHandler;
- private SceneCreatedEventCallbackDelegate _stageSceneCreatedEventCallbackDelegate;
+ private event EventHandler<TouchEventArgs> _stageTouchEventHandler;
+ private EventCallbackDelegateType1<IntPtr> _stageTouchCallbackDelegate;
/**
- * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of TouchEventHandler) 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 TouchEventHandler Touched
+ public event EventHandler<TouchEventArgs> TouchEvent
{
add
{
lock(this)
{
- // Restricted to only one listener
- if (_stageTouchEventHandler == null)
- {
- _stageTouchEventHandler += value;
-
- _stageTouchCallbackDelegate = new StageTouchCallbackDelegate(OnStageTouch);
- this.TouchSignal().Connect(_stageTouchCallbackDelegate);
- }
+ _stageTouchEventHandler += value;
+ _stageTouchCallbackDelegate = OnStageTouch;
+ this.TouchSignal().Connect(_stageTouchCallbackDelegate);
}
}
-
remove
{
lock(this)
{
this.TouchSignal().Disconnect(_stageTouchCallbackDelegate);
}
-
_stageTouchEventHandler -= value;
}
}
}
- // Callback for Stage Touch signal
private void OnStageTouch(IntPtr data)
{
- TouchEventArgs e = new TouchEventArgs();
+ TouchEventArgs e = new TouchEventArgs();
- // Populate all members of "e" (TouchEventArgs) with real data
- e.TouchData = TouchData.GetTouchDataFromPtr( data );
+ if( data != null )
+ {
+ e.TouchData = TouchData.GetTouchDataFromPtr( data );
+ }
- if (_stageTouchEventHandler != null)
+ if (_stageTouchEventHandler != null)
+ {
+ _stageTouchEventHandler(this, e);
+ }
+ }
+
+
+ /**
+ * @brief WheelEvent 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
{
- //here we send all data to user event handlers
- _stageTouchEventHandler(this, e);
+ get
+ {
+ return _wheelEvent;
+ }
+ set
+ {
+ _wheelEvent = value;
+ }
}
}
+ private event EventHandler<WheelEventArgs> _stageWheelEventHandler;
+ private EventCallbackDelegateType1<IntPtr> _stageWheelCallbackDelegate;
+
/**
- * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of WheelEventHandler) provided by the user.
- * WheelMoved signal is emitted is emitted when wheel event is received.
+ * @brief Event for WheelEvent signal which can be used to subscribe/unsubscribe the event handler
+ * WheelEvent signal is emitted is emitted when wheel event is received.
*
*/
- public event WheelEventHandler WheelMoved
+ public event EventHandler<WheelEventArgs> WheelEvent
{
add
{
lock(this)
{
- // Restricted to only one listener
- if (_stageWheelEventHandler == null)
- {
- _stageWheelEventHandler += value;
-
- _stageWheelCallbackDelegate = new WheelCallbackDelegate(OnStageWheel);
- this.WheelEventSignal().Connect(_stageWheelCallbackDelegate);
- }
+ _stageWheelEventHandler += value;
+ _stageWheelCallbackDelegate = OnStageWheel;
+ this.WheelEventSignal().Connect(_stageWheelCallbackDelegate);
}
}
-
remove
{
lock(this)
{
this.WheelEventSignal().Disconnect(_stageWheelCallbackDelegate);
}
-
_stageWheelEventHandler -= 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.WheelEvent = Dali.WheelEvent.GetWheelEventFromPtr( data );
+ }
- if (_stageWheelEventHandler != null)
+ if (_stageWheelEventHandler != null)
+ {
+ _stageWheelEventHandler(this, e);
+ }
+ }
+
+ /**
+ * @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
{
- //here we send all data to user event handlers
- _stageWheelEventHandler(this, e);
+ get
+ {
+ return _keyEvent;
+ }
+ set
+ {
+ _keyEvent = value;
+ }
}
}
+ private event EventHandler<KeyEventArgs> _stageKeyEventHandler;
+ private EventCallbackDelegateType1<IntPtr> _stageKeyCallbackDelegate;
+
/**
- * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of KeyEventHandler) provided by the user.
- * KeyPressed signal is emitted is emitted when key event is received.
+ * @brief Event for KeyEvent signal which can be used to subscribe/unsubscribe the event handler
+ * KeyEvent signal is emitted is emitted when key event is received.
*
*/
- public event KeyEventHandler KeyPressed
+ public event EventHandler<KeyEventArgs> KeyEvent
{
add
{
lock(this)
{
- // Restricted to only one listener
- if (_stageKeyEventHandler == null)
- {
- _stageKeyEventHandler += value;
-
- _stageKeyCallbackDelegate = new KeyCallbackDelegate(OnStageKey);
- this.KeyEventSignal().Connect(_stageKeyCallbackDelegate);
- }
+ _stageKeyEventHandler += value;
+ _stageKeyCallbackDelegate = OnStageKey;
+ this.KeyEventSignal().Connect(_stageKeyCallbackDelegate);
}
}
-
remove
{
lock(this)
{
this.KeyEventSignal().Disconnect(_stageKeyCallbackDelegate);
}
-
_stageKeyEventHandler -= 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.KeyEvent = Dali.KeyEvent.GetKeyEventFromPtr( data );
+ }
+
+ if (_stageKeyEventHandler != null)
+ {
+ //here we send all data to user event handlers
+ _stageKeyEventHandler(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) provided by the user.
- * EventProcessingFinished signal is emitted just after the event processing is finished.
+ * provided by the user. EventProcessingFinished signal is emitted just after the event processing is finished.
*
*/
- public event EventProcessingFinishedEventHandler 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) provided by the user.
* ContextLost signal is emitted when the GL context is lost (Platform specific behaviour).
*
*/
- public event ContextLostEventHandler 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) provided by the user.
- * ContextRegained signal is emitted when the GL context is regained (Platform specific
+ * provided by the user. ContextRegained signal is emitted when the GL context is regained (Platform specific
* behaviour).
*
*/
- public event ContextRegainedEventHandler 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) provided by the user.
* SceneCreated signal is emitted after the initial scene is created.
*
*/
- public event SceneCreatedEventHandler 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