X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=plugins%2Fdali-swig%2Fautomatic%2Fcsharp%2FActor.cs;h=3dda733c8a23b0fd7f59802d2f9f24acfd6eb25e;hb=872a1c0f2e64041bc64b478d9735acc2b137bfaf;hp=c09fa1ffbc2f359c72bf9b012009924e4d4dc353;hpb=a10edf35216e89cd2b6a2d1fa131a9dcb2bdfc7d;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/plugins/dali-swig/automatic/csharp/Actor.cs b/plugins/dali-swig/automatic/csharp/Actor.cs index c09fa1f..3dda733 100644 --- a/plugins/dali-swig/automatic/csharp/Actor.cs +++ b/plugins/dali-swig/automatic/csharp/Actor.cs @@ -59,6 +59,555 @@ public class Actor : Handle { } + + /** + * @brief Event arguments that passed via Touch signal + * + */ + public class TouchEventArgs : EventArgs + { + private Actor _actor; + private TouchData _touchData; + + /** + * @brief Actor - is the actor that is being touched + * + */ + public Actor Actor + { + get + { + return _actor; + } + set + { + _actor = value; + } + } + + /** + * @brief TouchData - contains the information of touch points + * + */ + public TouchData TouchData + { + get + { + return _touchData; + } + set + { + _touchData = value; + } + } + } + + /** + * @brief Event arguments that passed via Hover signal + * + */ + public class HoverEventArgs : EventArgs + { + private Actor _actor; + private HoverEvent _hoverEvent; + + /** + * @brief Actor - is the actor that is being hovered + * + */ + public Actor Actor + { + get + { + return _actor; + } + set + { + _actor = value; + } + } + + /** + * @brief HoverEvent - contains touch points that represent the points + * that are currently being hovered or the points where a hover has stopped + * + */ + public HoverEvent HoverEvent + { + get + { + return _hoverEvent; + } + set + { + _hoverEvent = value; + } + } + } + + /** + * @brief Event arguments that passed via Wheel signal + * + */ + public class WheelEventArgs : EventArgs + { + private Actor _actor; + private WheelEvent _wheelEvent; + + /** + * @brief Actor - is the actor that is being wheeled + * + */ + public Actor Actor + { + get + { + return _actor; + } + set + { + _actor = value; + } + } + + /** + * @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 OnStage signal + * + */ + public class OnStageEventArgs : EventArgs + { + private Actor _actor; + + /** + * @brief Actor - is the actor that is being connected to the stage + * + */ + public Actor Actor + { + get + { + return _actor; + } + set + { + _actor = value; + } + } + } + + /** + * @brief Event arguments that passed via OffStage signal + * + */ + public class OffStageEventArgs : EventArgs + { + private Actor _actor; + + /** + * @brief Actor - is the actor that is being disconnected from the stage + * + */ + public Actor Actor + { + get + { + return _actor; + } + set + { + _actor = value; + } + } + } + + /** + * @brief Event arguments that passed via OnRelayout signal + * + */ + public class OnRelayoutEventArgs : EventArgs + { + private Actor _actor; + + /** + * @brief Actor - is the actor that is being resized upon relayout + * + */ + public Actor Actor + { + get + { + return _actor; + } + set + { + _actor = value; + } + } + } + + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + private delegate bool TouchCallbackDelegate(IntPtr actor, IntPtr touchData); + private DaliEventHandlerWithReturnType _actorTouchDataEventHandler; + private TouchCallbackDelegate _actorTouchDataCallbackDelegate; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + private delegate bool HoverEventCallbackDelegate(IntPtr actor, IntPtr hoverEvent); + private DaliEventHandlerWithReturnType _actorHoverEventHandler; + private HoverEventCallbackDelegate _actorHoverEventCallbackDelegate; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + private delegate bool WheelEventCallbackDelegate(IntPtr actor, IntPtr wheelEvent); + private DaliEventHandlerWithReturnType _actorWheelEventHandler; + private WheelEventCallbackDelegate _actorWheelEventCallbackDelegate; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + private delegate void OnStageEventCallbackDelegate(IntPtr actor); + private DaliEventHandler _actorOnStageEventHandler; + private OnStageEventCallbackDelegate _actorOnStageEventCallbackDelegate; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + private delegate void OffStageEventCallbackDelegate(IntPtr actor); + private DaliEventHandler _actorOffStageEventHandler; + private OffStageEventCallbackDelegate _actorOffStageEventCallbackDelegate; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + private delegate void OnRelayoutEventCallbackDelegate(IntPtr actor); + private DaliEventHandler _actorOnRelayoutEventHandler; + private OnRelayoutEventCallbackDelegate _actorOnRelayoutEventCallbackDelegate; + + /** + * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler + * (in the type of TouchEventHandler-DaliEventHandlerWithReturnType) + * provided by the user. Touched signal is emitted when touch input is received. + */ + public event DaliEventHandlerWithReturnType Touched + { + add + { + lock(this) + { + // Restricted to only one listener + if (_actorTouchDataEventHandler == null) + { + _actorTouchDataEventHandler += value; + + _actorTouchDataCallbackDelegate = new TouchCallbackDelegate(OnTouch); + this.TouchSignal().Connect(_actorTouchDataCallbackDelegate); + } + } + } + + remove + { + lock(this) + { + if (_actorTouchDataEventHandler != null) + { + this.TouchSignal().Disconnect(_actorTouchDataCallbackDelegate); + } + + _actorTouchDataEventHandler -= value; + } + } + } + + // Callback for Actor TouchSignal + private bool OnTouch(IntPtr actor, IntPtr touchData) + { + TouchEventArgs e = new TouchEventArgs(); + + // Populate all members of "e" (TouchEventArgs) with real data + e.Actor = Actor.GetActorFromPtr(actor); + e.TouchData = Dali.TouchData.GetTouchDataFromPtr(touchData); + + if (_actorTouchDataEventHandler != null) + { + //here we send all data to user event handlers + return _actorTouchDataEventHandler(this, e, true); + } + + return false; + } + + /** + * @brief Event for Hovered signal which can be used to subscribe/unsubscribe the event handler + * (in the type of HoverEventHandler-DaliEventHandlerWithReturnType) + * provided by the user. Hovered signal is emitted when hover input is received. + */ + public event DaliEventHandlerWithReturnType Hovered + { + add + { + lock(this) + { + // Restricted to only one listener + if (_actorHoverEventHandler == null) + { + _actorHoverEventHandler += value; + + _actorHoverEventCallbackDelegate = new HoverEventCallbackDelegate(OnHoverEvent); + this.HoveredSignal().Connect(_actorHoverEventCallbackDelegate); + } + } + } + + remove + { + lock(this) + { + if (_actorHoverEventHandler != null) + { + this.HoveredSignal().Disconnect(_actorHoverEventCallbackDelegate); + } + + _actorHoverEventHandler -= value; + } + } + } + + // Callback for Actor Hover signal + private bool OnHoverEvent(IntPtr actor, IntPtr hoverEvent) + { + HoverEventArgs e = new HoverEventArgs(); + + // Populate all members of "e" (HoverEventArgs) with real data + e.Actor = Actor.GetActorFromPtr(actor); + e.HoverEvent = Dali.HoverEvent.GetHoverEventFromPtr(hoverEvent); + + if (_actorHoverEventHandler != null) + { + //here we send all data to user event handlers + return _actorHoverEventHandler(this, e, true); + } + + return false; + } + + /** + * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler + * (in the type of WheelEventHandler-DaliEventHandlerWithReturnType) + * provided by the user. WheelMoved signal is emitted when wheel event is received. + */ + public event DaliEventHandlerWithReturnType WheelMoved + { + add + { + lock(this) + { + // Restricted to only one listener + if (_actorWheelEventHandler == null) + { + _actorWheelEventHandler += value; + + _actorWheelEventCallbackDelegate = new WheelEventCallbackDelegate(OnWheelEvent); + this.WheelEventSignal().Connect(_actorWheelEventCallbackDelegate); + } + } + } + + remove + { + lock(this) + { + if (_actorWheelEventHandler != null) + { + this.WheelEventSignal().Disconnect(_actorWheelEventCallbackDelegate); + } + + _actorWheelEventHandler -= value; + } + } + } + + // Callback for Actor Wheel signal + private bool OnWheelEvent(IntPtr actor, IntPtr wheelEvent) + { + WheelEventArgs e = new WheelEventArgs(); + + // Populate all members of "e" (WheelEventArgs) with real data + e.Actor = Actor.GetActorFromPtr(actor); + e.WheelEvent = Dali.WheelEvent.GetWheelEventFromPtr(wheelEvent); + + if (_actorWheelEventHandler != null) + { + //here we send all data to user event handlers + return _actorWheelEventHandler(this, e, true); + } + + return false; + } + + /** + * @brief Event for OnStage signal which can be used to subscribe/unsubscribe the event handler + * (in the type of OnStageEventHandler) provided by the user. + * OnStage signal is emitted after the actor has been connected to the stage. + */ + public event DaliEventHandler OnStageEvent + { + add + { + lock(this) + { + // Restricted to only one listener + if (_actorOnStageEventHandler == null) + { + _actorOnStageEventHandler += value; + + _actorOnStageEventCallbackDelegate = new OnStageEventCallbackDelegate(OnStage); + this.OnStageSignal().Connect(_actorOnStageEventCallbackDelegate); + } + } + } + + remove + { + lock(this) + { + if (_actorOnStageEventHandler != null) + { + this.OnStageSignal().Disconnect(_actorOnStageEventCallbackDelegate); + } + + _actorOnStageEventHandler -= value; + } + } + } + + // Callback for Actor OnStage signal + private void OnStage(IntPtr data) + { + OnStageEventArgs e = new OnStageEventArgs(); + + // Populate all members of "e" (OnStageEventArgs) with real data + e.Actor = Actor.GetActorFromPtr(data); + + if (_actorOnStageEventHandler != null) + { + //here we send all data to user event handlers + _actorOnStageEventHandler(this, e); + } + } + + /** + * @brief Event for OffStage signal which can be used to subscribe/unsubscribe the event handler + * (in the type of OffStageEventHandler) provided by the user. + * OffStage signal is emitted after the actor has been disconnected from the stage. + */ + public event DaliEventHandler OffStageEvent + { + add + { + lock(this) + { + // Restricted to only one listener + if (_actorOffStageEventHandler == null) + { + _actorOffStageEventHandler += value; + + _actorOffStageEventCallbackDelegate = new OffStageEventCallbackDelegate(OffStage); + this.OnStageSignal().Connect(_actorOffStageEventCallbackDelegate); + } + } + } + + remove + { + lock(this) + { + if (_actorOffStageEventHandler != null) + { + this.OnStageSignal().Disconnect(_actorOffStageEventCallbackDelegate); + } + + _actorOffStageEventHandler -= value; + } + } + } + + // Callback for Actor OffStage signal + private void OffStage(IntPtr data) + { + OffStageEventArgs e = new OffStageEventArgs(); + + // Populate all members of "e" (OffStageEventArgs) with real data + e.Actor = Actor.GetActorFromPtr(data); + + if (_actorOffStageEventHandler != null) + { + //here we send all data to user event handlers + _actorOffStageEventHandler(this, e); + } + } + + /** + * @brief Event for OnRelayout signal which can be used to subscribe/unsubscribe the event handler + * (in the type of OnRelayoutEventHandler) provided by the user. + * OnRelayout signal is emitted after the size has been set on the actor during relayout. + */ + public event DaliEventHandler OnRelayoutEvent + { + add + { + lock(this) + { + // Restricted to only one listener + if (_actorOnRelayoutEventHandler == null) + { + _actorOnRelayoutEventHandler += value; + + _actorOnRelayoutEventCallbackDelegate = new OnRelayoutEventCallbackDelegate(OnRelayout); + this.OnRelayoutSignal().Connect(_actorOnRelayoutEventCallbackDelegate); + } + } + } + + remove + { + lock(this) + { + if (_actorOnRelayoutEventHandler != null) + { + this.OnRelayoutSignal().Disconnect(_actorOnRelayoutEventCallbackDelegate); + } + + _actorOnRelayoutEventHandler -= value; + } + } + } + + // Callback for Actor OnRelayout signal + private void OnRelayout(IntPtr data) + { + OnRelayoutEventArgs e = new OnRelayoutEventArgs(); + + // Populate all members of "e" (OnRelayoutEventArgs) with real data + e.Actor = Actor.GetActorFromPtr(data); + + if (_actorOnRelayoutEventHandler != null) + { + //here we send all data to user event handlers + _actorOnRelayoutEventHandler(this, e); + } + } + public static Actor GetActorFromPtr(global::System.IntPtr cPtr) { Actor ret = new Actor(cPtr, false); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); @@ -79,7 +628,7 @@ public class Actor : Handle { } } - public bool Visibility + public bool Vibility { get { @@ -94,12 +643,16 @@ public class Actor : Handle { { SetOpacity(value); } + } + + public float CurrentOpacity + { get { float ret = GetCurrentOpacity(); return ret; } - } + } public bool StateFocusEnable { @@ -114,16 +667,6 @@ public class Actor : Handle { } } - public void Show() - { - SetVisible(true); - } - - public void Hide() - { - SetVisible(false); - } - public class Property : global::System.IDisposable { private global::System.Runtime.InteropServices.HandleRef swigCPtr;