private RootLayerTouchDataCallbackType rootLayerTouchDataCallback;
private RootLayerTouchDataCallbackType rootLayerInterceptTouchDataCallback;
private WheelEventCallbackType wheelEventCallback;
+ private WheelEventCallbackType interceptWheelCallback;
private EventCallbackDelegateType1 stageKeyCallbackDelegate;
private InterceptKeyEventDelegateType stageInterceptKeyCallbackDelegate;
private EventCallbackDelegateType0 stageEventProcessingFinishedEventCallbackDelegate;
private MovedEventCallbackType movedEventCallback;
private OrientationChangedEventCallbackType orientationChangedEventCallback;
private KeyboardRepeatSettingsChangedEventCallbackType keyboardRepeatSettingsChangedEventCallback;
- private ViewAddedEventCallbackType viewAddedEventCallback;
private AuxiliaryMessageEventCallbackType auxiliaryMessageEventCallback;
+ private WindowMouseInOutEventCallbackType windowMouseInOutEventCallback;
+ private MoveCompletedEventCallbackType moveCompletedEventCallback;
+ private ResizeCompletedEventCallbackType resizeCompletedEventCallback;
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void WindowFocusChangedEventCallbackType(IntPtr window, bool focusGained);
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate bool RootLayerTouchDataCallbackType(IntPtr view, IntPtr touchData);
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate bool WheelEventCallbackType(IntPtr view, IntPtr wheelEvent);
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void WindowResizeEventCallbackType(IntPtr window, IntPtr windowSize);
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void WindowFocusChangedEventCallbackType2(IntPtr window, bool focusGained);
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void TransitionEffectEventCallbackType(IntPtr window, int state, int type);
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void MovedEventCallbackType(IntPtr window, IntPtr position);
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void OrientationChangedEventCallbackType(IntPtr window, int orientation);
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void KeyboardRepeatSettingsChangedEventCallbackType();
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void ViewAddedEventCallbackType(IntPtr view);
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void AuxiliaryMessageEventCallbackType(IntPtr kData, IntPtr vData, IntPtr optionsArray);
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate bool InterceptKeyEventDelegateType(IntPtr arg1);
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ private delegate void WindowMouseInOutEventCallbackType(IntPtr window, IntPtr mouseEvent);
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ private delegate void MoveCompletedEventCallbackType(IntPtr window, IntPtr position);
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ private delegate void ResizeCompletedEventCallbackType(IntPtr window, IntPtr size);
+
/// <summary>
/// FocusChanged event.
}
/// <summary>
+ /// An event for the wheel event signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
+ /// The wheel event signal is emitted when the wheel input is received.<br />
+ /// This can receive wheel events before child. <br />
+ /// If it returns false, the child can receive the wheel event. If it returns true, the wheel event is intercepted. So child cannot receive wheel event.<br />
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event ReturnTypeEventHandler<object, WheelEventArgs, bool> InterceptWheelEvent
+ {
+ add
+ {
+ if (interceptWheelHandler == null)
+ {
+ interceptWheelCallback = OnWindowInterceptWheel;
+ Interop.ActorSignal.InterceptWheelConnect(Layer.getCPtr(GetRootLayer()), interceptWheelCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ }
+ interceptWheelHandler += value;
+ }
+ remove
+ {
+ interceptWheelHandler -= value;
+ if (interceptWheelHandler == null && interceptWheelCallback != null)
+ {
+ Interop.ActorSignal.InterceptWheelDisconnect(Layer.getCPtr(GetRootLayer()), interceptWheelCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ interceptWheelCallback = null;
+ }
+ }
+ }
+
+ /// <summary>
/// Emits the event when the key event is received.
/// </summary>
/// <since_tizen> 3 </since_tizen>
}
/// <summary>
- /// Emits the event when the window resized.
+ /// Emits the event when window is resized by user or the display server.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public event EventHandler<ResizedEventArgs> Resized
}
/// <summary>
- /// MovedEvent
+ /// Emits the event when window is moved by user or the display server.<br />
/// </summary>
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler<WindowMovedEventArgs> Moved
}
/// <summary>
- /// ViewAdded will be triggered when the view added on Window
+ /// MouseInOutEvent event.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<MouseInOutEventArgs> MouseInOutEvent
+ {
+ add
+ {
+ if (windowMouseInOutEventHandler == null)
+ {
+ windowMouseInOutEventCallback = OnWindowMouseInOutEvent;
+ using WindowMouseInOutEventSignal signal = new WindowMouseInOutEventSignal(Interop.WindowMouseInOutEventSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Connect(windowMouseInOutEventCallback);
+ }
+ windowMouseInOutEventHandler += value;
+ }
+ remove
+ {
+ windowMouseInOutEventHandler -= value;
+ if (windowMouseInOutEventHandler == null && windowMouseInOutEventCallback != null)
+ {
+ using WindowMouseInOutEventSignal signal = new WindowMouseInOutEventSignal(Interop.WindowMouseInOutEventSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Disconnect(windowMouseInOutEventCallback);
+ windowMouseInOutEventCallback = null;
+ }
+ }
+ }
+
+ /// <summary>
+ /// Emits the event when window has been moved by the display server.<br />
+ /// To make the window move by display server, RequestMoveToServer() should be called.<br />
+ /// After the moving job is completed, this signal will be emitted.<br />
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<WindowMoveCompletedEventArgs> MoveCompleted
+ {
+ add
+ {
+ if (moveCompletedHandler == null)
+ {
+ moveCompletedEventCallback = OnMoveCompleted;
+ using WindowMoveCompletedSignal signal = new WindowMoveCompletedSignal(Interop.WindowMoveCompletedSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Connect(moveCompletedEventCallback);
+ }
+ moveCompletedHandler += value;
+ }
+ remove
+ {
+ moveCompletedHandler -= value;
+ if (moveCompletedHandler == null && moveCompletedEventCallback != null)
+ {
+ using WindowMoveCompletedSignal signal = new WindowMoveCompletedSignal(Interop.WindowMoveCompletedSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Disconnect(moveCompletedEventCallback);
+ moveCompletedEventCallback = null;
+ }
+ }
+ }
+
+ /// <summary>
+ /// Emits the event when window has been resized by the display server.<br />
+ /// To make the window resize by display server, RequestResizeToServer() should be called.<br />
+ /// After the resizing job is completed, this signal will be emitted.<br />
/// </summary>
- /// <since_tizen> 6 </since_tizen>
- /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
[EditorBrowsable(EditorBrowsableState.Never)]
- public event EventHandler ViewAdded
+ public event EventHandler<WindowResizeCompletedEventArgs> ResizeCompleted
{
add
{
- if (viewAddedHandler == null)
+ if (resizeCompletedHandler == null)
{
- viewAddedEventCallback = OnViewAdded;
- using WindowViewAddedSignal signal = new WindowViewAddedSignal(Interop.WindowViewAddedSignal.GetSignal(SwigCPtr), false);
- signal.Ensure()?.Connect(viewAddedEventCallback);
+ resizeCompletedEventCallback = OnResizeCompleted;
+ using WindowResizeCompletedSignal signal = new WindowResizeCompletedSignal(Interop.WindowResizeCompletedSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Connect(resizeCompletedEventCallback);
}
- viewAddedHandler += value;
+ resizeCompletedHandler += value;
}
remove
{
- viewAddedHandler -= value;
- if (viewAddedHandler == null && viewAddedEventCallback != null)
+ resizeCompletedHandler -= value;
+ if (resizeCompletedHandler == null && resizeCompletedEventCallback != null)
{
- using WindowViewAddedSignal signal = new WindowViewAddedSignal(Interop.WindowViewAddedSignal.GetSignal(SwigCPtr), false);
- signal.Ensure()?.Disconnect(viewAddedEventCallback);
- viewAddedEventCallback = null;
+ using WindowResizeCompletedSignal signal = new WindowResizeCompletedSignal(Interop.WindowResizeCompletedSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Disconnect(resizeCompletedEventCallback);
+ resizeCompletedEventCallback = null;
}
}
}
private event EventHandler<TouchEventArgs> rootLayerTouchDataEventHandler;
private ReturnTypeEventHandler<object, TouchEventArgs, bool> rootLayerInterceptTouchDataEventHandler;
private event EventHandler<WheelEventArgs> stageWheelHandler;
+ private ReturnTypeEventHandler<object, WheelEventArgs, bool> interceptWheelHandler;
private event EventHandler<KeyEventArgs> stageKeyHandler;
private ReturnTypeEventHandler<object, KeyEventArgs, bool> stageInterceptKeyHandler;
private event EventHandler stageEventProcessingFinishedEventHandler;
private event EventHandler<WindowMovedEventArgs> movedHandler;
private event EventHandler<WindowOrientationChangedEventArgs> orientationChangedHandler;
private event EventHandler keyboardRepeatSettingsChangedHandler;
- private event EventHandler viewAddedHandler;
private event EventHandler<AuxiliaryMessageEventArgs> auxiliaryMessageEventHandler;
+ private event EventHandler<MouseInOutEventArgs> windowMouseInOutEventHandler;
+ private event EventHandler<WindowMoveCompletedEventArgs> moveCompletedHandler;
+ private event EventHandler<WindowResizeCompletedEventArgs> resizeCompletedHandler;
internal event EventHandler EventProcessingFinished
DetentEventCallback = null;
}
+ if (interceptWheelCallback != null)
+ {
+ Interop.ActorSignal.InterceptWheelDisconnect(Layer.getCPtr(GetRootLayer()), interceptWheelCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ interceptWheelCallback = null;
+ }
+
if (stageKeyCallbackDelegate != null)
{
using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(GetBaseHandleCPtrHandleRef), false);
keyboardRepeatSettingsChangedEventCallback = null;
}
- if (viewAddedEventCallback != null)
- {
- using WindowViewAddedSignal signal = new WindowViewAddedSignal(Interop.WindowViewAddedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
- signal?.Disconnect(viewAddedEventCallback);
- viewAddedEventCallback = null;
- }
-
if (auxiliaryMessageEventCallback != null)
{
using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(GetBaseHandleCPtrHandleRef), false);
signal?.Disconnect(AccessibilityHighlightEventCallback);
AccessibilityHighlightEventCallback = null;
}
+
+ if (windowMouseInOutEventCallback != null)
+ {
+ using WindowMouseInOutEventSignal signal = new WindowMouseInOutEventSignal(Interop.WindowMouseInOutEventSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+ signal?.Disconnect(windowMouseInOutEventCallback);
+ windowMouseInOutEventCallback = null;
+ }
+
+ if (moveCompletedEventCallback != null)
+ {
+ using WindowMoveCompletedSignal signal = new WindowMoveCompletedSignal(Interop.WindowMoveCompletedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+ signal?.Disconnect(moveCompletedEventCallback);
+ moveCompletedEventCallback = null;
+ }
+
+ if (resizeCompletedEventCallback != null)
+ {
+ using WindowResizeCompletedSignal signal = new WindowResizeCompletedSignal(Interop.WindowResizeCompletedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+ signal?.Disconnect(resizeCompletedEventCallback);
+ resizeCompletedEventCallback = null;
+ }
}
private void OnWindowFocusedChanged(IntPtr window, bool focusGained)
return true;
}
+ private bool OnWindowInterceptWheel(IntPtr view, IntPtr wheelEvent)
+ {
+ if (wheelEvent == global::System.IntPtr.Zero)
+ {
+ NUILog.Error("wheelEvent should not be null!");
+ return true;
+ }
+
+ bool consumed = false;
+ if (interceptWheelHandler != null)
+ {
+ WheelEventArgs e = new WheelEventArgs();
+ e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
+ consumed = interceptWheelHandler(this, e);
+ }
+ return consumed;
+ }
+
// Callback for Stage KeyEventsignal
private void OnStageKey(IntPtr data)
{
return;
}
- private void OnViewAdded(IntPtr view)
+ private void OnWindowMouseInOutEvent(IntPtr view, IntPtr mouseEvent)
+ {
+ if (mouseEvent == global::System.IntPtr.Zero)
+ {
+ NUILog.Error("mouseEvent should not be null!");
+ return;
+ }
+
+ if (windowMouseInOutEventHandler != null)
+ {
+ MouseInOutEventArgs e = new MouseInOutEventArgs();
+ e.MouseInOut = Tizen.NUI.MouseInOut.GetMouseInOutFromPtr(mouseEvent);
+ windowMouseInOutEventHandler(this, e);
+ }
+ }
+
+ private void OnMoveCompleted(IntPtr window, IntPtr position)
+ {
+ if (window == global::System.IntPtr.Zero)
+ {
+ return;
+ }
+
+ if (moveCompletedHandler != null)
+ {
+ WindowMoveCompletedEventArgs e = new WindowMoveCompletedEventArgs(this.WindowPosition);
+ moveCompletedHandler(this, e);
+ }
+ return;
+ }
+
+ private void OnResizeCompleted(IntPtr window, IntPtr size)
{
- if (view == global::System.IntPtr.Zero)
+ if (window == global::System.IntPtr.Zero)
{
return;
}
- View addedView = Extensions.GetInstanceSafely<View>(this, view);
- if (addedView)
+ if (resizeCompletedHandler != null)
{
- // Note : object sender is View, not window it selfs (Since tizen_5.5, Pull Request #705)
- viewAddedHandler?.Invoke(view, EventArgs.Empty);
+ WindowResizeCompletedEventArgs e = new WindowResizeCompletedEventArgs(this.WindowSize);
+ resizeCompletedHandler(this, e);
}
return;
}
}
/// <summary>
+ /// MouseInOut evnet arguments.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public class MouseInOutEventArgs : EventArgs
+ {
+ private MouseInOut mouseEvent;
+
+ /// <summary>
+ /// MouseInOut event.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public MouseInOut MouseInOut
+ {
+ get
+ {
+ return mouseEvent;
+ }
+ set
+ {
+ mouseEvent = value;
+ }
+ }
+ }
+
+ /// <summary>
/// Do not use this, that will be deprecated.
/// </summary>
/// <since_tizen> 3 </since_tizen>
private EventHandler<WheelEventArgs> DetentEventHandler;
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void DetentEventCallbackType(IntPtr arg1);
private DetentEventCallbackType DetentEventCallback;
}
}
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void VisibilityChangedEventCallbackType(IntPtr window, bool visibility);
private VisibilityChangedEventCallbackType VisibilityChangedEventCallback;
private event EventHandler<VisibilityChangedEventArgs> VisibilityChangedEventHandler;
}
}
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void AccessibilityHighlightEventCallbackType(IntPtr window, bool highlight);
private AccessibilityHighlightEventCallbackType AccessibilityHighlightEventCallback;
private event EventHandler<AccessibilityHighlightEventArgs> AccessibilityHighlightEventHandler;
}
/// <summary>
- /// MovedArgs
+ /// Move event is sent when window is resized by user or the display server.
/// </summary>
[EditorBrowsable(EditorBrowsableState.Never)]
public class WindowMovedEventArgs : EventArgs
}
}
}
+
+ /// <summary>
+ /// Move Completed event is sent when window has been moved the display server.
+ /// It is triggered by calling RequestMoveToServer().
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public class WindowMoveCompletedEventArgs : EventArgs
+ {
+ public WindowMoveCompletedEventArgs(Position2D completedPosition)
+ {
+ WindowCompletedPosition = completedPosition;
+ }
+
+ public Position2D WindowCompletedPosition
+ {
+ get;
+ private set;
+ }
+ }
+
+ /// <summary>
+ /// Resize Completed event is sent when window has been resized the display server.
+ /// It is triggered by calling RequestResizeToServer().
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public class WindowResizeCompletedEventArgs : EventArgs
+ {
+ public WindowResizeCompletedEventArgs(Size2D completedSize)
+ {
+ WindowCompletedSize = completedSize;
+ }
+
+ public Size2D WindowCompletedSize
+ {
+ get;
+ private set;
+ }
+ }
+
}