X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=plugins%2Fdali-swig%2FSWIG%2Fevents%2Fstage-event.i;h=506759435f48d4f420645a68cf67a5cfa06dbfc1;hp=74693cd84914f5c865cd2edb2c5b13ada5d77f3c;hb=13f7f10f99c5253c500ffd644a1ac4a9039d4a07;hpb=89ae5b785c2eb8276d5fb350004414bc3fab8a2d diff --git a/plugins/dali-swig/SWIG/events/stage-event.i b/plugins/dali-swig/SWIG/events/stage-event.i old mode 100644 new mode 100755 index 74693cd..5067594 --- a/plugins/dali-swig/SWIG/events/stage-event.i +++ b/plugins/dali-swig/SWIG/events/stage-event.i @@ -26,330 +26,246 @@ using System.Runtime.InteropServices; %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 _stageTouchEventHandler; - private StageTouchCallbackDelegate _stageTouchCallbackDelegate; - - [UnmanagedFunctionPointer(CallingConvention.StdCall)] - private delegate void WheelCallbackDelegate(IntPtr data); - private DaliEventHandler _stageWheelEventHandler; - private WheelCallbackDelegate _stageWheelCallbackDelegate; - - [UnmanagedFunctionPointer(CallingConvention.StdCall)] - private delegate void KeyCallbackDelegate(IntPtr data); - private DaliEventHandler _stageKeyEventHandler; - private KeyCallbackDelegate _stageKeyCallbackDelegate; - - [UnmanagedFunctionPointer(CallingConvention.StdCall)] - private delegate void EventProcessingFinishedEventCallbackDelegate(); - private DaliEventHandler _stageEventProcessingFinishedEventHandler; - private EventProcessingFinishedEventCallbackDelegate _stageEventProcessingFinishedEventCallbackDelegate; - - [UnmanagedFunctionPointer(CallingConvention.StdCall)] - private delegate void ContextLostEventCallbackDelegate(); - private DaliEventHandler _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 _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 _stageSceneCreatedEventHandler; - private SceneCreatedEventCallbackDelegate _stageSceneCreatedEventCallbackDelegate; + private event EventHandler _stageTouchHandler; + private EventCallbackDelegateType1 _stageTouchCallbackDelegate; /** - * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler - * (in the type of TouchEventHandler-DaliEventHandler) 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 Touched + public event EventHandler 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 _stageWheelHandler; + private EventCallbackDelegateType1 _stageWheelCallbackDelegate; + /** - * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler - * (in the type of WheelEventHandler-DaliEventHandler) 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 WheelMoved + public event EventHandler 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 _stageKeyHandler; + private EventCallbackDelegateType1 _stageKeyCallbackDelegate; + /** - * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler - * (in the type of KeyEventHandler-DaliEventHandler) 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 KeyPressed + public event EventHandler 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) * provided by the user. EventProcessingFinished signal is emitted just after the event processing is finished. * */ - public event DaliEventHandler 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) @@ -358,7 +274,6 @@ public class SceneCreatedEventArgs : EventArgs { this.EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate); } - _stageEventProcessingFinishedEventHandler -= value; } } @@ -367,38 +282,32 @@ public class SceneCreatedEventArgs : EventArgs // 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) provided by the user. * ContextLost signal is emitted when the GL context is lost (Platform specific behaviour). * */ - public event DaliEventHandler 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) @@ -416,39 +325,33 @@ public class SceneCreatedEventArgs : EventArgs // 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) * provided by the user. ContextRegained signal is emitted when the GL context is regained (Platform specific * behaviour). * */ - public event DaliEventHandler 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) @@ -466,38 +369,32 @@ public class SceneCreatedEventArgs : EventArgs // 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) provided by the user. * SceneCreated signal is emitted after the initial scene is created. * */ - public event DaliEventHandler 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) @@ -515,30 +412,23 @@ public class SceneCreatedEventArgs : EventArgs // 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); } } - ///< name "Size", type Dali.Size (Stage Size value) - //@since 1.0.0 - public Dali.Size Size + + public Vector2 Size { get { - Vector2 ret1 = GetSize(); - Dali.Size ret= new Size(ret1); + Vector2 ret = GetSize(); return ret; } } - ///< name "BackgroundColor", type Dali.Color (Stage background color value) - //@since 1.0.0 - public Dali.Color BackgroundColor + public Vector4 BackgroundColor { set { @@ -546,12 +436,37 @@ public class SceneCreatedEventArgs : EventArgs } get { - Vector4 ret1 = GetBackgroundColor(); - Dali.Color ret = new Color(ret1); + Vector4 ret = GetBackgroundColor(); return ret; } } + 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