/*
- * Copyright(c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright(c) 2023 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
using System.ComponentModel;
using System.Runtime.InteropServices;
using Tizen.NUI.BaseComponents;
+using System.Collections.Generic;
namespace Tizen.NUI
{
/// <since_tizen> 3 </since_tizen>
public partial class Window
{
- private WindowFocusChangedEventCallbackType _windowFocusChangedEventCallback;
- private RootLayerTouchDataCallbackType _rootLayerTouchDataCallback;
- private WheelEventCallbackType _wheelEventCallback;
- private EventCallbackDelegateType1 _stageKeyCallbackDelegate;
- private EventCallbackDelegateType0 _stageEventProcessingFinishedEventCallbackDelegate;
- private EventHandler _stageContextLostEventHandler;
- private EventCallbackDelegateType0 _stageContextLostEventCallbackDelegate;
- private EventHandler _stageContextRegainedEventHandler;
- private EventCallbackDelegateType0 _stageContextRegainedEventCallbackDelegate;
- private EventHandler _stageSceneCreatedEventHandler;
- private EventCallbackDelegateType0 _stageSceneCreatedEventCallbackDelegate;
- private WindowResizeEventCallbackType _windowResizeEventCallback;
- private WindowFocusChangedEventCallbackType _windowFocusChangedEventCallback2;
+ private WindowFocusChangedEventCallbackType windowFocusChangedEventCallback;
+ private RootLayerTouchDataCallbackType rootLayerTouchDataCallback;
+ private RootLayerTouchDataCallbackType rootLayerInterceptTouchDataCallback;
+ private WheelEventCallbackType wheelEventCallback;
+ private EventCallbackDelegateType1 stageKeyCallbackDelegate;
+ private InterceptKeyEventDelegateType stageInterceptKeyCallbackDelegate;
+ private EventCallbackDelegateType0 stageEventProcessingFinishedEventCallbackDelegate;
+ private EventHandler stageContextLostEventHandler;
+ private EventCallbackDelegateType0 stageContextLostEventCallbackDelegate;
+ private EventHandler stageContextRegainedEventHandler;
+ private EventCallbackDelegateType0 stageContextRegainedEventCallbackDelegate;
+ private EventHandler stageSceneCreatedEventHandler;
+ private EventCallbackDelegateType0 stageSceneCreatedEventCallbackDelegate;
+ private WindowResizeEventCallbackType windowResizeEventCallback;
+ private WindowFocusChangedEventCallbackType windowFocusChangedEventCallback2;
private TransitionEffectEventCallbackType transitionEffectEventCallback;
- private WindowTransitionEffectSignal transitionEffectSignal;
+ private MovedEventCallbackType movedEventCallback;
+ private OrientationChangedEventCallbackType orientationChangedEventCallback;
private KeyboardRepeatSettingsChangedEventCallbackType keyboardRepeatSettingsChangedEventCallback;
- private KeyboardRepeatSettingsChangedSignal keyboardRepeatSettingsChangedSignal;
- private WindowFocusSignalType windowFocusChangedSignal;
- private WindowFocusSignalType windowFocusChangedSignal2;
- private TouchDataSignal touchDataSignal;
- private TouchSignal touchSignal;
- private WheelSignal wheelSignal;
- private StageWheelSignal stageWheelSignal;
- private KeyEventSignal keyEventSignal;
- private VoidSignal sceneCreatedSignal;
- private ResizeSignal resizeSignal;
- private VoidSignal eventProcessingFinishedSignal;
- private VoidSignal contextLostSignal;
- private VoidSignal contextRegainedSignal;
-
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private AuxiliaryMessageEventCallbackType auxiliaryMessageEventCallback;
+ private WindowMouseInOutEventCallbackType windowMouseInOutEventCallback;
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void WindowFocusChangedEventCallbackType(IntPtr window, bool focusGained);
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool RootLayerTouchDataCallbackType(IntPtr view, IntPtr touchData);
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void TransitionEffectEventCallbackType(IntPtr window, int state, int type);
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void MovedEventCallbackType(IntPtr window, IntPtr position);
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void OrientationChangedEventCallbackType(IntPtr window, int orientation);
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void KeyboardRepeatSettingsChangedEventCallbackType();
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void AuxiliaryMessageEventCallbackType(IntPtr kData, IntPtr vData, IntPtr optionsArray);
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate bool InterceptKeyEventDelegateType(IntPtr arg1);
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ private delegate void WindowMouseInOutEventCallbackType(IntPtr window, IntPtr mouseEvent);
/// <summary>
/// FocusChanged event.
{
add
{
- if (_windowFocusChangedEventHandler == null)
+ if (windowFocusChangedEventHandler == null)
{
- _windowFocusChangedEventCallback = OnWindowFocusedChanged;
- windowFocusChangedSignal = WindowFocusChangedSignal();
- windowFocusChangedSignal?.Connect(_windowFocusChangedEventCallback);
+ windowFocusChangedEventCallback = OnWindowFocusedChanged;
+ using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
+ signal.Ensure()?.Connect(windowFocusChangedEventCallback);
}
-
- _windowFocusChangedEventHandler += value;
+ windowFocusChangedEventHandler += value;
}
remove
{
- _windowFocusChangedEventHandler -= value;
-
- if (_windowFocusChangedEventHandler == null && windowFocusChangedSignal?.Empty() == false && _windowFocusChangedEventCallback != null)
+ windowFocusChangedEventHandler -= value;
+ if (windowFocusChangedEventHandler == null && windowFocusChangedEventCallback != null)
{
- windowFocusChangedSignal?.Disconnect(_windowFocusChangedEventCallback);
+ using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
+ signal.Ensure()?.Disconnect(windowFocusChangedEventCallback);
+ windowFocusChangedEventCallback = null;
}
}
}
{
add
{
- if (_rootLayerTouchDataEventHandler == null)
+ if (rootLayerTouchDataEventHandler == null)
+ {
+ rootLayerTouchDataCallback = OnWindowTouch;
+ Interop.ActorSignal.TouchConnect(Layer.getCPtr(GetRootLayer()), rootLayerTouchDataCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ }
+ rootLayerTouchDataEventHandler += value;
+ }
+ remove
+ {
+ rootLayerTouchDataEventHandler -= value;
+ if (rootLayerTouchDataEventHandler == null && rootLayerTouchDataCallback != null)
+ {
+ Interop.ActorSignal.TouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerTouchDataCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ rootLayerTouchDataCallback = null;
+ }
+ }
+ }
+
+ /// <summary>
+ /// An event for the touched signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
+ /// The touched signal is emitted when the touch input is received.<br />
+ /// This can receive touch events before child. <br />
+ /// If it returns false, the child can receive the touch event. If it returns true, the touch event is intercepted. So child cannot receive touch event.<br />
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event ReturnTypeEventHandler<object, TouchEventArgs, bool> InterceptTouchEvent
+ {
+ add
+ {
+ if (rootLayerInterceptTouchDataEventHandler == null)
{
- _rootLayerTouchDataCallback = OnWindowTouch;
- touchDataSignal = this.TouchDataSignal();
- touchDataSignal?.Connect(_rootLayerTouchDataCallback);
+ rootLayerInterceptTouchDataCallback = OnWindowInterceptTouch;
+ Interop.ActorSignal.InterceptTouchConnect(Layer.getCPtr(GetRootLayer()), rootLayerInterceptTouchDataCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
}
- _rootLayerTouchDataEventHandler += value;
+ rootLayerInterceptTouchDataEventHandler += value;
}
remove
{
- _rootLayerTouchDataEventHandler -= value;
- touchSignal = TouchSignal();
- if (_rootLayerTouchDataEventHandler == null && touchSignal?.Empty() == false && _rootLayerTouchDataCallback != null)
+ rootLayerInterceptTouchDataEventHandler -= value;
+ if (rootLayerInterceptTouchDataEventHandler == null && rootLayerInterceptTouchDataCallback != null)
{
- touchDataSignal?.Disconnect(_rootLayerTouchDataCallback);
+ Interop.ActorSignal.InterceptTouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerInterceptTouchDataCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ rootLayerInterceptTouchDataCallback = null;
}
}
}
{
add
{
- if (_stageWheelHandler == null)
+ if (stageWheelHandler == null)
{
- _wheelEventCallback = OnStageWheel;
- wheelSignal = WheelEventSignal();
- wheelSignal?.Connect(_wheelEventCallback);
+ wheelEventCallback = OnStageWheel;
+ Interop.ActorSignal.WheelEventConnect(Layer.getCPtr(GetRootLayer()), wheelEventCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
}
- _stageWheelHandler += value;
+ stageWheelHandler += value;
if (DetentEventHandler == null)
{
DetentEventCallback = OnDetentEvent;
- stageWheelSignal = StageWheelEventSignal();
- stageWheelSignal?.Connect(DetentEventCallback);
+ using StageWheelSignal signal = new StageWheelSignal(Interop.StageSignal.WheelEventSignal(stageCPtr), false);
+ signal.Ensure()?.Connect(DetentEventCallback);
}
DetentEventHandler += value;
}
remove
{
- _stageWheelHandler -= value;
- if (_stageWheelHandler == null && wheelSignal?.Empty() == false)
+ stageWheelHandler -= value;
+ if (stageWheelHandler == null && wheelEventCallback != null)
{
- wheelSignal?.Disconnect(_wheelEventCallback);
+ Interop.ActorSignal.WheelEventDisconnect(Layer.getCPtr(GetRootLayer()), wheelEventCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ wheelEventCallback = null;
}
DetentEventHandler -= value;
- if (DetentEventHandler == null && stageWheelSignal?.Empty() == false)
+ if (DetentEventHandler == null && DetentEventCallback != null)
{
- stageWheelSignal?.Disconnect(DetentEventCallback);
+ using StageWheelSignal signal = new StageWheelSignal(Interop.StageSignal.WheelEventSignal(stageCPtr), false);
+ signal.Ensure()?.Disconnect(DetentEventCallback);
+ DetentEventCallback = null;
}
}
}
{
add
{
- if (_stageKeyHandler == null)
+ if (stageKeyHandler == null)
+ {
+ stageKeyCallbackDelegate = OnStageKey;
+ using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(SwigCPtr), false);
+ signal.Ensure()?.Connect(stageKeyCallbackDelegate);
+ }
+ stageKeyHandler += value;
+ }
+ remove
+ {
+ stageKeyHandler -= value;
+ if (stageKeyHandler == null && stageKeyCallbackDelegate != null)
+ {
+ using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(SwigCPtr), false);
+ signal.Ensure()?.Disconnect(stageKeyCallbackDelegate);
+ stageKeyCallbackDelegate = null;
+ }
+ }
+ }
+
+ /// <summary>
+ /// Intercepts KeyEvents in the window before dispatching KeyEvents to the child.<br />
+ /// If it returns true(consumed), no KeyEvent is delivered to the child.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event ReturnTypeEventHandler<object, KeyEventArgs, bool> InterceptKeyEvent
+ {
+ add
+ {
+ if (stageInterceptKeyHandler == null)
{
- _stageKeyCallbackDelegate = OnStageKey;
- keyEventSignal = KeyEventSignal();
- keyEventSignal?.Connect(_stageKeyCallbackDelegate);
+ stageInterceptKeyCallbackDelegate = OnStageInterceptKey;
+ using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(SwigCPtr), false);
+ signal.Ensure()?.Connect(stageInterceptKeyCallbackDelegate);
}
- _stageKeyHandler += value;
+ stageInterceptKeyHandler += value;
}
remove
{
- _stageKeyHandler -= value;
- if (_stageKeyHandler == null && keyEventSignal?.Empty() == false)
+ stageInterceptKeyHandler -= value;
+ if (stageInterceptKeyHandler == null && stageInterceptKeyCallbackDelegate != null)
{
- keyEventSignal?.Disconnect(_stageKeyCallbackDelegate);
+ using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(SwigCPtr), false);
+ signal.Ensure()?.Disconnect(stageInterceptKeyCallbackDelegate);
+ stageInterceptKeyCallbackDelegate = null;
}
}
}
{
add
{
- if (_windowResizeEventHandler == null)
+ if (windowResizeEventHandler == null)
{
- _windowResizeEventCallback = OnResized;
- resizeSignal = ResizeSignal();
- resizeSignal?.Connect(_windowResizeEventCallback);
+ windowResizeEventCallback = OnResized;
+ using ResizeSignal signal = new ResizeSignal(Interop.Window.ResizeSignal(SwigCPtr), false);
+ signal.Ensure()?.Connect(windowResizeEventCallback);
}
- _windowResizeEventHandler += value;
+ windowResizeEventHandler += value;
}
remove
{
- _windowResizeEventHandler -= value;
-
- if (_windowResizeEventHandler == null && resizeSignal?.Empty() == false && _windowResizeEventCallback != null)
+ windowResizeEventHandler -= value;
+ if (windowResizeEventHandler == null && windowResizeEventCallback != null)
{
- resizeSignal?.Disconnect(_windowResizeEventCallback);
+ using ResizeSignal signal = new ResizeSignal(Interop.Window.ResizeSignal(SwigCPtr), false);
+ signal.Ensure()?.Disconnect(windowResizeEventCallback);
+ windowResizeEventCallback = null;
}
}
}
/// <summary>
- /// Please do not use! this will be deprecated. Please use 'FocusChanged' event instead.
+ /// Do not use this, that will be deprecated. Use 'FocusChanged' event instead.
/// </summary>
/// <since_tizen> 3 </since_tizen>
- /// Please do not use! this will be deprecated!
- /// Instead please use FocusChanged.
- [Obsolete("Please do not use! This will be deprecated! Please use FocusChanged instead! " +
+ /// Do not use this, that will be deprecated.
+ /// Instead Use FocusChanged.
+ [Obsolete("Do not use this, that will be deprecated. Use FocusChanged instead. " +
"Like: " +
"NUIApplication.GetDefaultWindow().FocusChanged = OnFocusChanged; " +
"private void OnFocusChanged(object source, Window.FocusChangedEventArgs args) {...}")]
{
add
{
- if (_windowFocusChangedEventHandler2 == null)
+ if (windowFocusChangedEventHandler2 == null)
{
- _windowFocusChangedEventCallback2 = OnWindowFocusedChanged2;
- windowFocusChangedSignal2 = WindowFocusChangedSignal();
- windowFocusChangedSignal2?.Connect(_windowFocusChangedEventCallback2);
+ windowFocusChangedEventCallback2 = OnWindowFocusedChanged2;
+ using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
+ signal.Ensure()?.Connect(windowFocusChangedEventCallback2);
}
-
- _windowFocusChangedEventHandler2 += value;
+ windowFocusChangedEventHandler2 += value;
}
remove
{
- _windowFocusChangedEventHandler2 -= value;
-
- if (_windowFocusChangedEventHandler2 == null && windowFocusChangedSignal2?.Empty() == false && _windowFocusChangedEventCallback2 != null)
+ windowFocusChangedEventHandler2 -= value;
+ if (windowFocusChangedEventHandler2 == null && windowFocusChangedEventCallback2 != null)
{
- windowFocusChangedSignal2?.Disconnect(_windowFocusChangedEventCallback2);
+ using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
+ signal.Ensure()?.Disconnect(windowFocusChangedEventCallback2);
+ windowFocusChangedEventCallback2 = null;
}
}
}
if (transitionEffectHandler == null)
{
transitionEffectEventCallback = OnTransitionEffect;
- TransitionEffectEventSignal().Connect(transitionEffectEventCallback);
+ using WindowTransitionEffectSignal signal = new WindowTransitionEffectSignal(Interop.WindowTransitionEffectSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Connect(transitionEffectEventCallback);
}
transitionEffectHandler += value;
}
remove
{
transitionEffectHandler -= value;
- if (transitionEffectHandler == null && TransitionEffectEventSignal().Empty() == false)
+ if (transitionEffectHandler == null && transitionEffectEventCallback != null)
+ {
+ using WindowTransitionEffectSignal signal = new WindowTransitionEffectSignal(Interop.WindowTransitionEffectSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Disconnect(transitionEffectEventCallback);
+ transitionEffectEventCallback = null;
+ }
+ }
+ }
+
+ /// <summary>
+ /// MovedEvent
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<WindowMovedEventArgs> Moved
+ {
+ add
+ {
+ if (movedHandler == null)
+ {
+ movedEventCallback = OnMoved;
+ using WindowMovedSignal signal = new WindowMovedSignal(Interop.WindowMovedSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Connect(movedEventCallback);
+ }
+ movedHandler += value;
+ }
+ remove
+ {
+ movedHandler -= value;
+ if (movedHandler == null && movedEventCallback != null)
+ {
+ using WindowMovedSignal signal = new WindowMovedSignal(Interop.WindowMovedSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Disconnect(movedEventCallback);
+ movedEventCallback = null;
+ }
+ }
+ }
+
+ /// <summary>
+ /// Window Orientation Changed event
+ /// This event is for per windows
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<WindowOrientationChangedEventArgs> OrientationChanged
+ {
+ add
+ {
+ if (orientationChangedHandler == null)
{
- TransitionEffectEventSignal().Disconnect(transitionEffectEventCallback);
+ orientationChangedEventCallback = OnOrientationChanged;
+ using WindowOrientationChangedSignal signal = new WindowOrientationChangedSignal(Interop.WindowOrientationChangedSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Connect(orientationChangedEventCallback);
+ }
+ orientationChangedHandler += value;
+ }
+ remove
+ {
+ orientationChangedHandler -= value;
+ if (orientationChangedHandler == null && orientationChangedEventCallback != null)
+ {
+ using WindowOrientationChangedSignal signal = new WindowOrientationChangedSignal(Interop.WindowOrientationChangedSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Disconnect(orientationChangedEventCallback);
+ orientationChangedEventCallback = null;
}
}
}
if (keyboardRepeatSettingsChangedHandler == null)
{
keyboardRepeatSettingsChangedEventCallback = OnKeyboardRepeatSettingsChanged;
- KeyboardRepeatSettingsChangedEventSignal().Connect(keyboardRepeatSettingsChangedEventCallback);
+ using KeyboardRepeatSettingsChangedSignal signal = new KeyboardRepeatSettingsChangedSignal(Interop.KeyboardRepeatSettingsChangedSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Connect(keyboardRepeatSettingsChangedEventCallback);
}
keyboardRepeatSettingsChangedHandler += value;
}
remove
{
keyboardRepeatSettingsChangedHandler -= value;
- if (keyboardRepeatSettingsChangedHandler == null && KeyboardRepeatSettingsChangedEventSignal().Empty() == false)
+ if (keyboardRepeatSettingsChangedHandler == null && keyboardRepeatSettingsChangedEventCallback != null)
{
- KeyboardRepeatSettingsChangedEventSignal().Disconnect(keyboardRepeatSettingsChangedEventCallback);
+ using KeyboardRepeatSettingsChangedSignal signal = new KeyboardRepeatSettingsChangedSignal(Interop.KeyboardRepeatSettingsChangedSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Disconnect(keyboardRepeatSettingsChangedEventCallback);
+ keyboardRepeatSettingsChangedEventCallback = null;
}
}
}
/// <summary>
- /// ViewAdded will be triggered when the view added on Window
+ /// MouseInOutEvent event.
/// </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;
- private event EventHandler<FocusChangedEventArgs> _windowFocusChangedEventHandler;
- private event EventHandler<TouchEventArgs> _rootLayerTouchDataEventHandler;
- private event EventHandler<WheelEventArgs> _stageWheelHandler;
- private event EventHandler<KeyEventArgs> _stageKeyHandler;
- private event EventHandler _stageEventProcessingFinishedEventHandler;
- private event EventHandler<ResizedEventArgs> _windowResizeEventHandler;
- private event EventHandler<FocusChangedEventArgs> _windowFocusChangedEventHandler2;
+ 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;
+ }
+ }
+ }
+
+ private event EventHandler<FocusChangedEventArgs> windowFocusChangedEventHandler;
+ private event EventHandler<TouchEventArgs> rootLayerTouchDataEventHandler;
+ private ReturnTypeEventHandler<object, TouchEventArgs, bool> rootLayerInterceptTouchDataEventHandler;
+ private event EventHandler<WheelEventArgs> stageWheelHandler;
+ private event EventHandler<KeyEventArgs> stageKeyHandler;
+ private ReturnTypeEventHandler<object, KeyEventArgs, bool> stageInterceptKeyHandler;
+ private event EventHandler stageEventProcessingFinishedEventHandler;
+ private event EventHandler<ResizedEventArgs> windowResizeEventHandler;
+ private event EventHandler<FocusChangedEventArgs> windowFocusChangedEventHandler2;
private event EventHandler<TransitionEffectEventArgs> transitionEffectHandler;
+ private event EventHandler<WindowMovedEventArgs> movedHandler;
+ private event EventHandler<WindowOrientationChangedEventArgs> orientationChangedHandler;
private event EventHandler keyboardRepeatSettingsChangedHandler;
+ private event EventHandler<AuxiliaryMessageEventArgs> auxiliaryMessageEventHandler;
+ private event EventHandler<MouseInOutEventArgs> windowMouseInOutEventHandler;
- internal void SendViewAdded(View view)
- {
- ViewAdded?.Invoke(view, EventArgs.Empty);
- }
internal event EventHandler EventProcessingFinished
{
add
{
- if (_stageEventProcessingFinishedEventHandler == null)
+ if (stageEventProcessingFinishedEventHandler == null)
{
- _stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished;
- eventProcessingFinishedSignal = EventProcessingFinishedSignal();
- eventProcessingFinishedSignal?.Connect(_stageEventProcessingFinishedEventCallbackDelegate);
+ stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished;
+ using VoidSignal signal = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
+ signal.Ensure()?.Connect(stageEventProcessingFinishedEventCallbackDelegate);
}
- _stageEventProcessingFinishedEventHandler += value;
-
+ stageEventProcessingFinishedEventHandler += value;
}
remove
{
- _stageEventProcessingFinishedEventHandler -= value;
- if (_stageEventProcessingFinishedEventHandler == null && eventProcessingFinishedSignal?.Empty() == false)
+ stageEventProcessingFinishedEventHandler -= value;
+ if (stageEventProcessingFinishedEventHandler == null && stageEventProcessingFinishedEventCallbackDelegate != null)
{
- eventProcessingFinishedSignal?.Disconnect(_stageEventProcessingFinishedEventCallbackDelegate);
+ using VoidSignal signal = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
+ signal.Ensure()?.Disconnect(stageEventProcessingFinishedEventCallbackDelegate);
+ stageEventProcessingFinishedEventCallbackDelegate = null;
}
}
}
{
add
{
- if (_stageContextLostEventHandler == null)
+ if (stageContextLostEventHandler == null)
{
- _stageContextLostEventCallbackDelegate = OnContextLost;
- contextLostSignal = ContextLostSignal();
- contextLostSignal?.Connect(_stageContextLostEventCallbackDelegate);
+ stageContextLostEventCallbackDelegate = OnContextLost;
+ using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
+ signal.Ensure()?.Connect(stageContextLostEventCallbackDelegate);
}
- _stageContextLostEventHandler += value;
+ stageContextLostEventHandler += value;
}
remove
{
- _stageContextLostEventHandler -= value;
- if (_stageContextLostEventHandler == null && contextLostSignal?.Empty() == false)
+ stageContextLostEventHandler -= value;
+ if (stageContextLostEventHandler == null && stageContextLostEventCallbackDelegate != null)
{
- contextLostSignal?.Disconnect(_stageContextLostEventCallbackDelegate);
+ using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
+ signal.Ensure()?.Disconnect(stageContextLostEventCallbackDelegate);
+ stageContextLostEventCallbackDelegate = null;
}
}
}
{
add
{
- if (_stageContextRegainedEventHandler == null)
+ if (stageContextRegainedEventHandler == null)
{
- _stageContextRegainedEventCallbackDelegate = OnContextRegained;
- contextRegainedSignal = ContextRegainedSignal();
- contextRegainedSignal?.Connect(_stageContextRegainedEventCallbackDelegate);
+ stageContextRegainedEventCallbackDelegate = OnContextRegained;
+ using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
+ signal.Ensure()?.Connect(stageContextRegainedEventCallbackDelegate);
}
- _stageContextRegainedEventHandler += value;
+ stageContextRegainedEventHandler += value;
}
remove
{
- _stageContextRegainedEventHandler -= value;
- if (_stageContextRegainedEventHandler == null && contextRegainedSignal?.Empty() == false)
+ stageContextRegainedEventHandler -= value;
+ if (stageContextRegainedEventHandler == null && stageContextRegainedEventCallbackDelegate != null)
{
- contextRegainedSignal?.Disconnect(_stageContextRegainedEventCallbackDelegate);
+ using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
+ signal.Ensure()?.Disconnect(stageContextRegainedEventCallbackDelegate);
+ stageContextRegainedEventCallbackDelegate = null;
}
}
}
{
add
{
- if (_stageSceneCreatedEventHandler == null)
+ if (stageSceneCreatedEventHandler == null)
{
- _stageSceneCreatedEventCallbackDelegate = OnSceneCreated;
- sceneCreatedSignal = SceneCreatedSignal();
- sceneCreatedSignal?.Connect(_stageSceneCreatedEventCallbackDelegate);
+ stageSceneCreatedEventCallbackDelegate = OnSceneCreated;
+ using VoidSignal signal = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
+ signal.Ensure()?.Connect(stageSceneCreatedEventCallbackDelegate);
}
- _stageSceneCreatedEventHandler += value;
+ stageSceneCreatedEventHandler += value;
}
remove
{
- _stageSceneCreatedEventHandler -= value;
- if (_stageSceneCreatedEventHandler == null && sceneCreatedSignal?.Empty() == false)
+ stageSceneCreatedEventHandler -= value;
+ if (stageSceneCreatedEventHandler == null && stageSceneCreatedEventCallbackDelegate != null)
{
- sceneCreatedSignal?.Disconnect(_stageSceneCreatedEventCallbackDelegate);
+ using VoidSignal signal = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
+ signal.Ensure()?.Disconnect(stageSceneCreatedEventCallbackDelegate);
+ stageSceneCreatedEventCallbackDelegate = null;
}
}
}
- internal WindowFocusSignalType WindowFocusChangedSignal()
- {
- WindowFocusSignalType ret = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal WindowFocusSignalType FocusChangedSignal()
- {
- WindowFocusSignalType ret = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal KeyEventSignal KeyEventSignal()
- {
- KeyEventSignal ret = new KeyEventSignal(Interop.Window.KeyEventSignal(SwigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal VoidSignal EventProcessingFinishedSignal()
- {
- VoidSignal ret = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal TouchSignal TouchSignal()
- {
- TouchSignal ret = new TouchSignal(Interop.Window.TouchSignal(SwigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal TouchDataSignal TouchDataSignal()
- {
- TouchDataSignal ret = new TouchDataSignal(Interop.ActorSignal.ActorTouchSignal(Layer.getCPtr(GetRootLayer())), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending)
- throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal VoidSignal ContextLostSignal()
- {
- VoidSignal ret = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal VoidSignal ContextRegainedSignal()
- {
- VoidSignal ret = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal VoidSignal SceneCreatedSignal()
- {
- VoidSignal ret = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal ResizeSignal ResizeSignal()
- {
- ResizeSignal ret = new ResizeSignal(Interop.Window.ResizeSignal(SwigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
internal System.IntPtr GetNativeWindowHandler()
{
System.IntPtr ret = Interop.Window.GetNativeWindowHandler(HandleRef.ToIntPtr(this.SwigCPtr));
/// <since_tizen> 5 </since_tizen>
internal void DisconnectNativeSignals()
{
- if (_windowFocusChangedEventCallback != null)
+ if (HasBody() == false)
+ {
+ NUILog.Debug($"[Dispose] DisConnectFromSignals() No native body! No need to Disconnect Signals!");
+ return;
+ }
+
+ if (windowFocusChangedEventCallback != null)
+ {
+ using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(GetBaseHandleCPtrHandleRef), false);
+ signal?.Disconnect(windowFocusChangedEventCallback);
+ windowFocusChangedEventCallback = null;
+ }
+
+ if (rootLayerTouchDataCallback != null)
{
- windowFocusChangedSignal?.Disconnect(_windowFocusChangedEventCallback);
+ Interop.ActorSignal.TouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerTouchDataCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ rootLayerTouchDataCallback = null;
}
- if (_rootLayerTouchDataCallback != null)
+ if (rootLayerInterceptTouchDataCallback != null)
{
- touchDataSignal?.Disconnect(_rootLayerTouchDataCallback);
+ Interop.ActorSignal.InterceptTouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerInterceptTouchDataCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ rootLayerInterceptTouchDataCallback = null;
}
- if (_wheelEventCallback != null)
+ if (wheelEventCallback != null)
{
- wheelSignal?.Disconnect(_wheelEventCallback);
+ Interop.ActorSignal.WheelEventDisconnect(Layer.getCPtr(GetRootLayer()), wheelEventCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ wheelEventCallback = null;
}
if (DetentEventCallback != null)
{
- stageWheelSignal?.Disconnect(DetentEventCallback);
+ using StageWheelSignal signal = new StageWheelSignal(Interop.StageSignal.WheelEventSignal(stageCPtr), false);
+ signal?.Disconnect(DetentEventCallback);
+ DetentEventCallback = null;
}
- if (_stageKeyCallbackDelegate != null)
+ if (stageKeyCallbackDelegate != null)
{
- keyEventSignal?.Disconnect(_stageKeyCallbackDelegate);
+ using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(GetBaseHandleCPtrHandleRef), false);
+ signal?.Disconnect(stageKeyCallbackDelegate);
+ stageKeyCallbackDelegate = null;
}
- if (_stageEventProcessingFinishedEventCallbackDelegate != null)
+ if (stageInterceptKeyCallbackDelegate != null)
{
- eventProcessingFinishedSignal?.Disconnect(_stageEventProcessingFinishedEventCallbackDelegate);
+ using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(GetBaseHandleCPtrHandleRef), false);
+ signal?.Disconnect(stageInterceptKeyCallbackDelegate);
+ stageInterceptKeyCallbackDelegate = null;
}
- if (_stageContextLostEventCallbackDelegate != null)
+ if (stageEventProcessingFinishedEventCallbackDelegate != null)
{
- contextLostSignal?.Disconnect(_stageContextLostEventCallbackDelegate);
+ using VoidSignal signal = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
+ signal?.Disconnect(stageEventProcessingFinishedEventCallbackDelegate);
+ stageEventProcessingFinishedEventCallbackDelegate = null;
}
- if (_stageContextRegainedEventCallbackDelegate != null)
+ if (stageContextLostEventCallbackDelegate != null)
{
- contextRegainedSignal?.Disconnect(_stageContextRegainedEventCallbackDelegate);
+ using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
+ signal?.Disconnect(stageContextLostEventCallbackDelegate);
+ stageContextLostEventCallbackDelegate = null;
}
- if (_stageSceneCreatedEventCallbackDelegate != null)
+ if (stageContextRegainedEventCallbackDelegate != null)
{
- sceneCreatedSignal?.Disconnect(_stageSceneCreatedEventCallbackDelegate);
+ using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
+ signal?.Disconnect(stageContextRegainedEventCallbackDelegate);
+ stageContextRegainedEventCallbackDelegate = null;
}
- if (_windowResizeEventCallback != null)
+ if (stageSceneCreatedEventCallbackDelegate != null)
{
- resizeSignal?.Disconnect(_windowResizeEventCallback);
+ using VoidSignal signal = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
+ signal?.Disconnect(stageSceneCreatedEventCallbackDelegate);
+ stageSceneCreatedEventCallbackDelegate = null;
}
- if (_windowFocusChangedEventCallback2 != null)
+ if (windowResizeEventCallback != null)
{
- windowFocusChangedSignal2?.Disconnect(_windowFocusChangedEventCallback2);
+ using ResizeSignal signal = new ResizeSignal(Interop.Window.ResizeSignal(GetBaseHandleCPtrHandleRef), false);
+ signal?.Disconnect(windowResizeEventCallback);
+ windowResizeEventCallback = null;
}
- if (transitionEffectSignal != null)
+ if (windowFocusChangedEventCallback2 != null)
{
- TransitionEffectEventSignal().Disconnect(transitionEffectEventCallback);
+ using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(GetBaseHandleCPtrHandleRef), false);
+ signal?.Disconnect(windowFocusChangedEventCallback2);
+ windowFocusChangedEventCallback2 = null;
}
- if (keyboardRepeatSettingsChangedSignal != null)
+ if (transitionEffectEventCallback != null)
{
- KeyboardRepeatSettingsChangedEventSignal().Disconnect(keyboardRepeatSettingsChangedEventCallback);
+ using WindowTransitionEffectSignal signal = new WindowTransitionEffectSignal(Interop.WindowTransitionEffectSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+ signal?.Disconnect(transitionEffectEventCallback);
+ transitionEffectEventCallback = null;
}
- }
- private StageWheelSignal StageWheelEventSignal()
- {
- StageWheelSignal ret = new StageWheelSignal(Interop.StageSignal.WheelEventSignal(stageCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
+ if (movedEventCallback != null)
+ {
+ using WindowMovedSignal signal = new WindowMovedSignal(Interop.WindowMovedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+ signal?.Disconnect(movedEventCallback);
+ movedEventCallback = null;
+ }
- private WheelSignal WheelEventSignal()
- {
- WheelSignal ret = new WheelSignal(Interop.ActorSignal.ActorWheelEventSignal(Layer.getCPtr(this.GetRootLayer())), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending)
- throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
+ if (orientationChangedEventCallback != null)
+ {
+ using WindowOrientationChangedSignal signal = new WindowOrientationChangedSignal(Interop.WindowOrientationChangedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+ signal?.Disconnect(orientationChangedEventCallback);
+ orientationChangedEventCallback = null;
+ }
- private WindowTransitionEffectSignal TransitionEffectEventSignal()
- {
- if (transitionEffectSignal == null)
+ if (keyboardRepeatSettingsChangedEventCallback != null)
{
- transitionEffectSignal = new WindowTransitionEffectSignal(this);
- if (NDalicPINVOKE.SWIGPendingException.Pending)
- throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ using KeyboardRepeatSettingsChangedSignal signal = new KeyboardRepeatSettingsChangedSignal(Interop.KeyboardRepeatSettingsChangedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+ signal?.Disconnect(keyboardRepeatSettingsChangedEventCallback);
+ keyboardRepeatSettingsChangedEventCallback = null;
}
- return transitionEffectSignal;
- }
- private KeyboardRepeatSettingsChangedSignal KeyboardRepeatSettingsChangedEventSignal()
- {
- if (keyboardRepeatSettingsChangedSignal == null)
+ if (auxiliaryMessageEventCallback != null)
+ {
+ using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(GetBaseHandleCPtrHandleRef), false);
+ signal?.Disconnect(auxiliaryMessageEventCallback);
+ auxiliaryMessageEventCallback = null;
+ }
+
+ if (AccessibilityHighlightEventCallback != null)
{
- keyboardRepeatSettingsChangedSignal = new KeyboardRepeatSettingsChangedSignal(this);
- if (NDalicPINVOKE.SWIGPendingException.Pending)
- throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ using WindowAccessibilityHighlightEvent signal = new WindowAccessibilityHighlightEvent(Interop.WindowAccessibilityHighlightSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+ signal?.Disconnect(AccessibilityHighlightEventCallback);
+ AccessibilityHighlightEventCallback = null;
}
- return keyboardRepeatSettingsChangedSignal;
+
+ if (windowMouseInOutEventCallback != null)
+ {
+ using WindowMouseInOutEventSignal signal = new WindowMouseInOutEventSignal(Interop.WindowMouseInOutEventSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+ signal?.Disconnect(windowMouseInOutEventCallback);
+ windowMouseInOutEventCallback = null;
+ }
+
}
private void OnWindowFocusedChanged(IntPtr window, bool focusGained)
return;
}
- FocusChangedEventArgs e = new FocusChangedEventArgs();
-
- e.FocusGained = focusGained;
-
- if (_windowFocusChangedEventHandler != null)
+ if (windowFocusChangedEventHandler != null)
{
- _windowFocusChangedEventHandler(this, e);
+ FocusChangedEventArgs e = new FocusChangedEventArgs();
+ e.FocusGained = focusGained;
+ windowFocusChangedEventHandler(this, e);
}
}
return false;
}
- TouchEventArgs e = new TouchEventArgs();
+ if (rootLayerTouchDataEventHandler != null)
+ {
+ TouchEventArgs e = new TouchEventArgs();
+ e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
+ rootLayerTouchDataEventHandler(this, e);
+ }
+ return false;
+ }
- e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
+ private bool OnWindowInterceptTouch(IntPtr view, IntPtr touchData)
+ {
+ if (touchData == global::System.IntPtr.Zero)
+ {
+ NUILog.Error("touchData should not be null!");
+ return true;
+ }
- if (_rootLayerTouchDataEventHandler != null)
+ bool consumed = false;
+ if (rootLayerInterceptTouchDataEventHandler != null)
{
- _rootLayerTouchDataEventHandler(this, e);
+ TouchEventArgs e = new TouchEventArgs();
+ e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
+ consumed = rootLayerInterceptTouchDataEventHandler(this, e);
}
- return false;
+ return consumed;
}
private bool OnStageWheel(IntPtr rootLayer, IntPtr wheelEvent)
return true;
}
- WheelEventArgs e = new WheelEventArgs();
-
- e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
-
- if (_stageWheelHandler != null)
+ if (stageWheelHandler != null)
{
- _stageWheelHandler(this, e);
+ WheelEventArgs e = new WheelEventArgs();
+ e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
+ stageWheelHandler(this, e);
}
return true;
}
// Callback for Stage KeyEventsignal
private void OnStageKey(IntPtr data)
{
- KeyEventArgs e = new KeyEventArgs();
- e.Key = Tizen.NUI.Key.GetKeyFromPtr(data);
-
+ if (stageKeyHandler != null)
+ {
+ KeyEventArgs e = new KeyEventArgs();
+ e.Key = Tizen.NUI.Key.GetKeyFromPtr(data);
+ //here we send all data to user event handlers
+ stageKeyHandler(this, e);
+ }
+ }
- if (_stageKeyHandler != null)
+ // Callback for Stage InterceptKeyEventsignal
+ private bool OnStageInterceptKey(IntPtr data)
+ {
+ bool consumed = false;
+ if (stageInterceptKeyHandler != null)
{
+ KeyEventArgs e = new KeyEventArgs();
+ e.Key = Tizen.NUI.Key.GetKeyFromPtr(data);
//here we send all data to user event handlers
- _stageKeyHandler(this, e);
+ consumed = stageInterceptKeyHandler(this, e);
}
+ return consumed;
}
// Callback for Stage EventProcessingFinishedSignal
private void OnEventProcessingFinished()
{
- if (_stageEventProcessingFinishedEventHandler != null)
- {
- _stageEventProcessingFinishedEventHandler(this, null);
- }
+ stageEventProcessingFinishedEventHandler?.Invoke(this, null);
}
// Callback for Stage ContextLostSignal
private void OnContextLost()
{
- if (_stageContextLostEventHandler != null)
- {
- _stageContextLostEventHandler(this, null);
- }
+ stageContextLostEventHandler?.Invoke(this, null);
}
// Callback for Stage ContextRegainedSignal
private void OnContextRegained()
{
- if (_stageContextRegainedEventHandler != null)
- {
- _stageContextRegainedEventHandler(this, null);
- }
+ stageContextRegainedEventHandler?.Invoke(this, null);
}
// Callback for Stage SceneCreatedSignal
private void OnSceneCreated()
{
- if (_stageSceneCreatedEventHandler != null)
- {
- _stageSceneCreatedEventHandler(this, null);
- }
+ stageSceneCreatedEventHandler?.Invoke(this, null);
}
private void OnResized(IntPtr window, IntPtr windowSize)
return;
}
- ResizedEventArgs e = new ResizedEventArgs();
- // var val = new Uint16Pair(windowSize, false);
- // e.WindowSize = new Size2D(val.GetWidth(), val.GetHeight());
- // val.Dispose();
-
- // Workaround : windowSize should be valid pointer from dali,
- // but currenlty it is fixed and is not Uint16Pair class.
- // will be fixed later.
- e.WindowSize = this.WindowSize;
-
- if (_windowResizeEventHandler != null)
+ if (windowResizeEventHandler != null)
{
- _windowResizeEventHandler(this, e);
+ ResizedEventArgs e = new ResizedEventArgs();
+ // var val = new Uint16Pair(windowSize, false);
+ // e.WindowSize = new Size2D(val.GetWidth(), val.GetHeight());
+ // val.Dispose();
+
+ // Workaround : windowSize should be valid pointer from dali,
+ // but currently it is fixed and is not Uint16Pair class.
+ // will be fixed later.
+ e.WindowSize = this.WindowSize;
+ windowResizeEventHandler(this, e);
}
}
return;
}
- FocusChangedEventArgs e = new FocusChangedEventArgs();
-
- e.FocusGained = focusGained;
-
- if (_windowFocusChangedEventHandler2 != null)
+ if (windowFocusChangedEventHandler2 != null)
{
- _windowFocusChangedEventHandler2(this, e);
+ FocusChangedEventArgs e = new FocusChangedEventArgs();
+ e.FocusGained = focusGained;
+ windowFocusChangedEventHandler2(this, e);
}
}
return;
}
- TransitionEffectEventArgs e = new TransitionEffectEventArgs();
+ if (transitionEffectHandler != null)
+ {
+ TransitionEffectEventArgs e = new TransitionEffectEventArgs();
+ e.State = (EffectState)state;
+ e.Type = (EffectType)type;
+ transitionEffectHandler(this, e);
+ }
+ return;
+ }
+
+ private void OnMoved(IntPtr window, IntPtr position)
+ {
+ if (window == global::System.IntPtr.Zero)
+ {
+ return;
+ }
- e.State = (EffectState)state;
+ if (movedHandler != null)
+ {
+ WindowMovedEventArgs e = new WindowMovedEventArgs();
+ e.WindowPosition = this.WindowPosition;
+ movedHandler(this, e);
+ }
+ return;
+ }
- e.Type = (EffectType)type;
+ private void OnOrientationChanged(IntPtr window, int orientation)
+ {
+ if (window == global::System.IntPtr.Zero)
+ {
+ return;
+ }
- if (transitionEffectHandler != null)
+ if (orientationChangedHandler != null)
{
- transitionEffectHandler(this, e);
+ WindowOrientationChangedEventArgs e = new WindowOrientationChangedEventArgs();
+ e.WindowOrientation = (WindowOrientation)orientation;
+ orientationChangedHandler(this, e);
}
return;
}
private void OnKeyboardRepeatSettingsChanged()
{
- if (keyboardRepeatSettingsChangedHandler != null)
+ keyboardRepeatSettingsChangedHandler?.Invoke(this, null);
+ return;
+ }
+
+ private void OnWindowMouseInOutEvent(IntPtr view, IntPtr mouseEvent)
+ {
+ if (mouseEvent == global::System.IntPtr.Zero)
{
- keyboardRepeatSettingsChangedHandler(this, null);
+ 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);
}
- return;
}
/// <summary>
/// <since_tizen> 3 </since_tizen>
public class TouchEventArgs : EventArgs
{
- private Touch _touch;
+ private Touch touch;
/// <summary>
/// Touch.
{
get
{
- return _touch;
+ return touch;
}
set
{
- _touch = value;
+ touch = value;
}
}
}
/// <since_tizen> 3 </since_tizen>
public class WheelEventArgs : EventArgs
{
- private Wheel _wheel;
+ private Wheel wheel;
/// <summary>
/// Wheel.
{
get
{
- return _wheel;
+ return wheel;
}
set
{
- _wheel = value;
+ wheel = value;
}
}
}
/// <since_tizen> 3 </since_tizen>
public class KeyEventArgs : EventArgs
{
- private Key _key;
+ private Key key;
/// <summary>
/// Key.
{
get
{
- return _key;
+ return key;
}
set
{
- _key = value;
+ key = value;
}
}
}
/// <since_tizen> 3 </since_tizen>
public class ResizedEventArgs : EventArgs
{
- Size2D _windowSize;
+ Size2D windowSize;
/// <summary>
/// This window size.
{
get
{
- return _windowSize;
+ return windowSize;
+ }
+ set
+ {
+ windowSize = value;
+ }
+ }
+ }
+
+ /// <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
{
- _windowSize = value;
+ mouseEvent = value;
}
}
}
/// <summary>
- /// Please do not use! this will be deprecated
+ /// Do not use this, that will be deprecated.
/// </summary>
/// <since_tizen> 3 </since_tizen>
- [Obsolete("Please do not use! This will be deprecated! Please use FocusChangedEventArgs instead! " +
+ [Obsolete("Do not use this, that will be deprecated. Use FocusChangedEventArgs instead. " +
"Like: " +
"NUIApplication.GetDefaultWindow().FocusChanged = OnFocusChanged; " +
"private void OnFocusChanged(object source, Window.FocusChangedEventArgs args) {...}")]
public class WindowFocusChangedEventArgs : EventArgs
{
/// <summary>
- /// Please do not use! this will be deprecated
+ /// Do not use this, that will be deprecated.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public bool FocusGained
/// Contains and encapsulates Native Window handle.
/// </summary>
/// <since_tizen> 4 </since_tizen>
+ [Obsolete("This has been deprecated in API9 and will be removed in API11. Use Window.NativeHandle instead.")]
public class SafeNativeWindowHandle : SafeHandle
{
/// <summary>
- /// Contructor, Native window handle is set to handle.
+ ///Constructor, Native window handle is set to handle.
/// </summary>
/// <since_tizen> 4 </since_tizen>
public SafeNativeWindowHandle() : base(IntPtr.Zero, false)
if (VisibilityChangedEventHandler == null)
{
VisibilityChangedEventCallback = OnVisibilityChanged;
- VisibilityChangedEventSignal = new WindowVisibilityChangedEvent(this);
- VisibilityChangedEventSignal.Connect(VisibilityChangedEventCallback);
+ using WindowVisibilityChangedEvent signal = new WindowVisibilityChangedEvent(Interop.WindowVisibilityChangedSignal.GetSignal(Window.getCPtr(this)), false);
+ signal.Ensure()?.Connect(VisibilityChangedEventCallback);
}
VisibilityChangedEventHandler += value;
}
remove
{
VisibilityChangedEventHandler -= value;
- if (VisibilityChangedEventHandler == null)
+ if (VisibilityChangedEventHandler == null && VisibilityChangedEventCallback != null)
{
- if (VisibilityChangedEventSignal != null)
- {
- if (VisibilityChangedEventSignal.Empty() == false)
- {
- VisibilityChangedEventSignal.Disconnect(VisibilityChangedEventCallback);
- }
- }
+ using WindowVisibilityChangedEvent signal = new WindowVisibilityChangedEvent(Interop.WindowVisibilityChangedSignal.GetSignal(Window.getCPtr(this)), false);
+ signal.Ensure()?.Disconnect(VisibilityChangedEventCallback);
+ VisibilityChangedEventCallback = null;
}
}
}
VisibilityChangedEventSignal.Emit(this, visibility);
}
+ private void OnAuxiliaryMessage(IntPtr kData, IntPtr vData, IntPtr optionsArray)
+ {
+ if (kData == IntPtr.Zero || vData == IntPtr.Zero)
+ {
+ return;
+ }
+
+ using var tmp = new PropertyArray(optionsArray, false);
+ var size = tmp.Size();
+
+ List<string> tmpList = new List<string>();
+ for (int i = 0; i < size; i++)
+ {
+ string option = "none";
+ tmp.GetElementAt((uint)i).Get(out option);
+ tmpList.Add(option);
+ }
+ tmp.Dispose();
+
+ AuxiliaryMessageEventArgs e = new AuxiliaryMessageEventArgs();
+ e.Key = StringToVoidSignal.GetResult(kData);
+ e.Value = StringToVoidSignal.GetResult(vData); ;
+ e.Options = tmpList;
+
+ auxiliaryMessageEventHandler?.Invoke(this, e);
+ }
+
+ /// <summary>
+ /// Auxiliary message is sent by displayer server when window's auxiliary was changed then display server sent the message.
+ /// When client application added the window's auxiliary hint and if the auxiliary is changed,
+ /// display server send the auxiliary message.
+ /// Auxiliary message has the key, value and options.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<AuxiliaryMessageEventArgs> AuxiliaryMessage
+ {
+ add
+ {
+ if (auxiliaryMessageEventHandler == null)
+ {
+ auxiliaryMessageEventCallback = OnAuxiliaryMessage;
+ using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(SwigCPtr), false);
+ signal.Ensure()?.Connect(auxiliaryMessageEventCallback);
+ }
+ auxiliaryMessageEventHandler += value;
+ }
+ remove
+ {
+ auxiliaryMessageEventHandler -= value;
+ if (auxiliaryMessageEventHandler == null && auxiliaryMessageEventCallback != null)
+ {
+ using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(SwigCPtr), false);
+ signal.Ensure()?.Disconnect(auxiliaryMessageEventCallback);
+ auxiliaryMessageEventCallback = null;
+ }
+ }
+ }
+
+ /// <summary>
+ /// AccessibilityHighlightArgs
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public class AccessibilityHighlightEventArgs : EventArgs
+ {
+ private bool accessibilityHighlight;
+ /// <summary>
+ /// accessibilityHighlight
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public bool AccessibilityHighlight
+ {
+ get => accessibilityHighlight;
+ set
+ {
+ accessibilityHighlight = value;
+ }
+ }
+ }
+
+ private void OnAccessibilityHighlight(IntPtr window, bool highlight)
+ {
+ if (window == global::System.IntPtr.Zero)
+ {
+ NUILog.Error("[ERR] OnAccessibilityHighlight() window is null");
+ return;
+ }
+
+ AccessibilityHighlightEventArgs e = new AccessibilityHighlightEventArgs();
+ e.AccessibilityHighlight = highlight;
+ if (AccessibilityHighlightEventHandler != null)
+ {
+ AccessibilityHighlightEventHandler.Invoke(this, e);
+ }
+ }
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void AccessibilityHighlightEventCallbackType(IntPtr window, bool highlight);
+ private AccessibilityHighlightEventCallbackType AccessibilityHighlightEventCallback;
+ private event EventHandler<AccessibilityHighlightEventArgs> AccessibilityHighlightEventHandler;
+
+ /// <summary>
+ /// Emits the event when the window needs to grab or clear highlight.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<AccessibilityHighlightEventArgs> AccessibilityHighlight
+ {
+ add
+ {
+ if (AccessibilityHighlightEventHandler == null)
+ {
+ AccessibilityHighlightEventCallback = OnAccessibilityHighlight;
+ using WindowAccessibilityHighlightEvent signal = new WindowAccessibilityHighlightEvent(Interop.WindowAccessibilityHighlightSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Connect(AccessibilityHighlightEventCallback);
+ }
+ AccessibilityHighlightEventHandler += value;
+ }
+ remove
+ {
+ AccessibilityHighlightEventHandler -= value;
+ if (AccessibilityHighlightEventHandler == null && AccessibilityHighlightEventCallback != null)
+ {
+ using WindowAccessibilityHighlightEvent signal = new WindowAccessibilityHighlightEvent(Interop.WindowAccessibilityHighlightSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Disconnect(AccessibilityHighlightEventCallback);
+ AccessibilityHighlightEventCallback = null;
+ }
+ }
+ }
+ }
+
+ /// <summary>
+ /// MovedArgs
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public class WindowMovedEventArgs : EventArgs
+ {
+ private Position2D position;
+
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public Position2D WindowPosition
+ {
+ get
+ {
+ return position;
+ }
+ set
+ {
+ position = value;
+ }
+ }
+ }
+
+ /// <summary>
+ /// OrientationChangedArgs
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public class WindowOrientationChangedEventArgs : EventArgs
+ {
+ private Window.WindowOrientation orientation;
+
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public Window.WindowOrientation WindowOrientation
+ {
+ get
+ {
+ return orientation;
+ }
+ set
+ {
+ orientation = value;
+ }
+ }
}
}
projects / platform / core / csapi / tizenfx.git / blobdiff