X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2FTizen.NUI%2Fsrc%2Fpublic%2FWindow%2FWindowEvent.cs;h=4fe11003e2f0746e764643693e6f3114bd8c0e5f;hb=c6837f8be8bdad8992b991eac276dd897a9ef404;hp=6bb01cc8a51d37e332ab8555db185e4fd906297f;hpb=a5611da5a0fcafd18ab6ae7bfcfe9465f0489f9f;p=platform%2Fcore%2Fcsapi%2Ftizenfx.git

diff --git a/src/Tizen.NUI/src/public/Window/WindowEvent.cs b/src/Tizen.NUI/src/public/Window/WindowEvent.cs
index 6bb01cc..4fe1100 100755
--- a/src/Tizen.NUI/src/public/Window/WindowEvent.cs
+++ b/src/Tizen.NUI/src/public/Window/WindowEvent.cs
@@ -1,5 +1,5 @@
 /*
- * Copyright(c) 2021 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.
@@ -32,8 +32,11 @@ namespace Tizen.NUI
     {
         private WindowFocusChangedEventCallbackType windowFocusChangedEventCallback;
         private RootLayerTouchDataCallbackType rootLayerTouchDataCallback;
+        private RootLayerTouchDataCallbackType rootLayerInterceptTouchDataCallback;
         private WheelEventCallbackType wheelEventCallback;
+        private WheelEventCallbackType interceptWheelCallback;
         private EventCallbackDelegateType1 stageKeyCallbackDelegate;
+        private InterceptKeyEventDelegateType stageInterceptKeyCallbackDelegate;
         private EventCallbackDelegateType0 stageEventProcessingFinishedEventCallbackDelegate;
         private EventHandler stageContextLostEventHandler;
         private EventCallbackDelegateType0 stageContextLostEventCallbackDelegate;
@@ -44,24 +47,14 @@ namespace Tizen.NUI
         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;
         private AuxiliaryMessageEventCallbackType auxiliaryMessageEventCallback;
-
-        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+        private WindowMouseInOutEventCallbackType windowMouseInOutEventCallback;
+        private MoveCompletedEventCallbackType moveCompletedEventCallback;
+        private ResizeCompletedEventCallbackType resizeCompletedEventCallback;
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         private delegate void WindowFocusChangedEventCallbackType(IntPtr window, bool focusGained);
         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
         private delegate bool RootLayerTouchDataCallbackType(IntPtr view, IntPtr touchData);
@@ -74,9 +67,22 @@ namespace Tizen.NUI
         [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);
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+        private delegate void MoveCompletedEventCallbackType(IntPtr window, IntPtr position);
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+        private delegate void ResizeCompletedEventCallbackType(IntPtr window, IntPtr size);
+
 
         /// <summary>
         /// FocusChanged event.
@@ -89,19 +95,19 @@ namespace Tizen.NUI
                 if (windowFocusChangedEventHandler == null)
                 {
                     windowFocusChangedEventCallback = OnWindowFocusedChanged;
-                    windowFocusChangedSignal = WindowFocusChangedSignal();
-                    windowFocusChangedSignal?.Connect(windowFocusChangedEventCallback);
+                    using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
+                    signal.Ensure()?.Connect(windowFocusChangedEventCallback);
                 }
-
                 windowFocusChangedEventHandler += value;
             }
             remove
             {
                 windowFocusChangedEventHandler -= value;
-
-                if (windowFocusChangedEventHandler == null && windowFocusChangedSignal?.Empty() == false && windowFocusChangedEventCallback != null)
+                if (windowFocusChangedEventHandler == null && windowFocusChangedEventCallback != null)
                 {
-                    windowFocusChangedSignal?.Disconnect(windowFocusChangedEventCallback);
+                    using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
+                    signal.Ensure()?.Disconnect(windowFocusChangedEventCallback);
+                    windowFocusChangedEventCallback = null;
                 }
             }
         }
@@ -120,18 +126,50 @@ namespace Tizen.NUI
                 if (rootLayerTouchDataEventHandler == null)
                 {
                     rootLayerTouchDataCallback = OnWindowTouch;
-                    touchDataSignal = this.TouchDataSignal();
-                    touchDataSignal?.Connect(rootLayerTouchDataCallback);
+                    Interop.ActorSignal.TouchConnect(Layer.getCPtr(GetRootLayer()), rootLayerTouchDataCallback.ToHandleRef(this));
+                    NDalicPINVOKE.ThrowExceptionIfExists();
                 }
                 rootLayerTouchDataEventHandler += value;
             }
             remove
             {
                 rootLayerTouchDataEventHandler -= value;
-                touchSignal = TouchSignal();
-                if (rootLayerTouchDataEventHandler == null && touchSignal?.Empty() == false && rootLayerTouchDataCallback != null)
+                if (rootLayerTouchDataEventHandler == null && rootLayerTouchDataCallback != null)
                 {
-                    touchDataSignal?.Disconnect(rootLayerTouchDataCallback);
+                    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)
+                {
+                    rootLayerInterceptTouchDataCallback = OnWindowInterceptTouch;
+                    Interop.ActorSignal.InterceptTouchConnect(Layer.getCPtr(GetRootLayer()), rootLayerInterceptTouchDataCallback.ToHandleRef(this));
+                    NDalicPINVOKE.ThrowExceptionIfExists();
+                }
+                rootLayerInterceptTouchDataEventHandler += value;
+            }
+            remove
+            {
+                rootLayerInterceptTouchDataEventHandler -= value;
+                if (rootLayerInterceptTouchDataEventHandler == null && rootLayerInterceptTouchDataCallback != null)
+                {
+                    Interop.ActorSignal.InterceptTouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerInterceptTouchDataCallback.ToHandleRef(this));
+                    NDalicPINVOKE.ThrowExceptionIfExists();
+                    rootLayerInterceptTouchDataCallback = null;
                 }
             }
         }
@@ -147,31 +185,66 @@ namespace Tizen.NUI
                 if (stageWheelHandler == null)
                 {
                     wheelEventCallback = OnStageWheel;
-                    wheelSignal = WheelEventSignal();
-                    wheelSignal?.Connect(wheelEventCallback);
+                    Interop.ActorSignal.WheelEventConnect(Layer.getCPtr(GetRootLayer()), wheelEventCallback.ToHandleRef(this));
+                    NDalicPINVOKE.ThrowExceptionIfExists();
                 }
                 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)
+                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;
+                }
+            }
+        }
+
+        /// <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;
                 }
             }
         }
@@ -187,23 +260,54 @@ namespace Tizen.NUI
                 if (stageKeyHandler == null)
                 {
                     stageKeyCallbackDelegate = OnStageKey;
-                    keyEventSignal = KeyEventSignal();
-                    keyEventSignal?.Connect(stageKeyCallbackDelegate);
+                    using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(SwigCPtr), false);
+                    signal.Ensure()?.Connect(stageKeyCallbackDelegate);
                 }
                 stageKeyHandler += value;
             }
             remove
             {
                 stageKeyHandler -= value;
-                if (stageKeyHandler == null && keyEventSignal?.Empty() == false)
+                if (stageKeyHandler == null && stageKeyCallbackDelegate != null)
                 {
-                    keyEventSignal?.Disconnect(stageKeyCallbackDelegate);
+                    using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(SwigCPtr), false);
+                    signal.Ensure()?.Disconnect(stageKeyCallbackDelegate);
+                    stageKeyCallbackDelegate = null;
                 }
             }
         }
 
         /// <summary>
-        /// Emits the event when the window resized.
+        /// 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)
+                {
+                    stageInterceptKeyCallbackDelegate = OnStageInterceptKey;
+                    using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(SwigCPtr), false);
+                    signal.Ensure()?.Connect(stageInterceptKeyCallbackDelegate);
+                }
+                stageInterceptKeyHandler += value;
+            }
+            remove
+            {
+                stageInterceptKeyHandler -= value;
+                if (stageInterceptKeyHandler == null && stageInterceptKeyCallbackDelegate != null)
+                {
+                    using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(SwigCPtr), false);
+                    signal.Ensure()?.Disconnect(stageInterceptKeyCallbackDelegate);
+                    stageInterceptKeyCallbackDelegate = null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 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
@@ -213,8 +317,8 @@ namespace Tizen.NUI
                 if (windowResizeEventHandler == null)
                 {
                     windowResizeEventCallback = OnResized;
-                    resizeSignal = ResizeSignal();
-                    resizeSignal?.Connect(windowResizeEventCallback);
+                    using ResizeSignal signal = new ResizeSignal(Interop.Window.ResizeSignal(SwigCPtr), false);
+                    signal.Ensure()?.Connect(windowResizeEventCallback);
                 }
 
                 windowResizeEventHandler += value;
@@ -222,21 +326,22 @@ namespace Tizen.NUI
             remove
             {
                 windowResizeEventHandler -= value;
-
-                if (windowResizeEventHandler == null && resizeSignal?.Empty() == false && windowResizeEventCallback != null)
+                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) {...}")]
@@ -248,19 +353,19 @@ namespace Tizen.NUI
                 if (windowFocusChangedEventHandler2 == null)
                 {
                     windowFocusChangedEventCallback2 = OnWindowFocusedChanged2;
-                    windowFocusChangedSignal2 = WindowFocusChangedSignal();
-                    windowFocusChangedSignal2?.Connect(windowFocusChangedEventCallback2);
+                    using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
+                    signal.Ensure()?.Connect(windowFocusChangedEventCallback2);
                 }
-
                 windowFocusChangedEventHandler2 += value;
             }
             remove
             {
                 windowFocusChangedEventHandler2 -= value;
-
-                if (windowFocusChangedEventHandler2 == null && windowFocusChangedSignal2?.Empty() == false && windowFocusChangedEventCallback2 != null)
+                if (windowFocusChangedEventHandler2 == null && windowFocusChangedEventCallback2 != null)
                 {
-                    windowFocusChangedSignal2?.Disconnect(windowFocusChangedEventCallback2);
+                    using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
+                    signal.Ensure()?.Disconnect(windowFocusChangedEventCallback2);
+                    windowFocusChangedEventCallback2 = null;
                 }
             }
         }
@@ -276,16 +381,76 @@ namespace Tizen.NUI
                 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>
+        /// Emits the event when window is moved by user or the display server.<br />
+        /// </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)
+                {
+                    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)
                 {
-                    TransitionEffectEventSignal().Disconnect(transitionEffectEventCallback);
+                    using WindowOrientationChangedSignal signal = new WindowOrientationChangedSignal(Interop.WindowOrientationChangedSignal.GetSignal(SwigCPtr), false);
+                    signal.Ensure()?.Disconnect(orientationChangedEventCallback);
+                    orientationChangedEventCallback = null;
                 }
             }
         }
@@ -301,42 +466,130 @@ namespace Tizen.NUI
                 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;
+        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>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public event EventHandler<WindowResizeCompletedEventArgs> ResizeCompleted
+        {
+            add
+            {
+                if (resizeCompletedHandler == null)
+                {
+                    resizeCompletedEventCallback = OnResizeCompleted;
+                    using WindowResizeCompletedSignal signal = new WindowResizeCompletedSignal(Interop.WindowResizeCompletedSignal.GetSignal(SwigCPtr), false);
+                    signal.Ensure()?.Connect(resizeCompletedEventCallback);
+                }
+                resizeCompletedHandler += value;
+            }
+            remove
+            {
+                resizeCompletedHandler -= value;
+                if (resizeCompletedHandler == null && resizeCompletedEventCallback != null)
+                {
+                    using WindowResizeCompletedSignal signal = new WindowResizeCompletedSignal(Interop.WindowResizeCompletedSignal.GetSignal(SwigCPtr), false);
+                    signal.Ensure()?.Disconnect(resizeCompletedEventCallback);
+                    resizeCompletedEventCallback = null;
+                }
+            }
+        }
+
         private event EventHandler<FocusChangedEventArgs> windowFocusChangedEventHandler;
         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<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;
+        private event EventHandler<WindowMoveCompletedEventArgs> moveCompletedHandler;
+        private event EventHandler<WindowResizeCompletedEventArgs> resizeCompletedHandler;
 
-        internal void SendViewAdded(View view)
-        {
-            ViewAdded?.Invoke(view, EventArgs.Empty);
-        }
 
         internal event EventHandler EventProcessingFinished
         {
@@ -345,18 +598,19 @@ namespace Tizen.NUI
                 if (stageEventProcessingFinishedEventHandler == null)
                 {
                     stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished;
-                    eventProcessingFinishedSignal = EventProcessingFinishedSignal();
-                    eventProcessingFinishedSignal?.Connect(stageEventProcessingFinishedEventCallbackDelegate);
+                    using VoidSignal signal = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
+                    signal.Ensure()?.Connect(stageEventProcessingFinishedEventCallbackDelegate);
                 }
                 stageEventProcessingFinishedEventHandler += value;
-
             }
             remove
             {
                 stageEventProcessingFinishedEventHandler -= value;
-                if (stageEventProcessingFinishedEventHandler == null && eventProcessingFinishedSignal?.Empty() == false)
+                if (stageEventProcessingFinishedEventHandler == null && stageEventProcessingFinishedEventCallbackDelegate != null)
                 {
-                    eventProcessingFinishedSignal?.Disconnect(stageEventProcessingFinishedEventCallbackDelegate);
+                    using VoidSignal signal = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
+                    signal.Ensure()?.Disconnect(stageEventProcessingFinishedEventCallbackDelegate);
+                    stageEventProcessingFinishedEventCallbackDelegate = null;
                 }
             }
         }
@@ -368,17 +622,19 @@ namespace Tizen.NUI
                 if (stageContextLostEventHandler == null)
                 {
                     stageContextLostEventCallbackDelegate = OnContextLost;
-                    contextLostSignal = ContextLostSignal();
-                    contextLostSignal?.Connect(stageContextLostEventCallbackDelegate);
+                    using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
+                    signal.Ensure()?.Connect(stageContextLostEventCallbackDelegate);
                 }
                 stageContextLostEventHandler += value;
             }
             remove
             {
                 stageContextLostEventHandler -= value;
-                if (stageContextLostEventHandler == null && contextLostSignal?.Empty() == false)
+                if (stageContextLostEventHandler == null && stageContextLostEventCallbackDelegate != null)
                 {
-                    contextLostSignal?.Disconnect(stageContextLostEventCallbackDelegate);
+                    using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
+                    signal.Ensure()?.Disconnect(stageContextLostEventCallbackDelegate);
+                    stageContextLostEventCallbackDelegate = null;
                 }
             }
         }
@@ -390,17 +646,19 @@ namespace Tizen.NUI
                 if (stageContextRegainedEventHandler == null)
                 {
                     stageContextRegainedEventCallbackDelegate = OnContextRegained;
-                    contextRegainedSignal = ContextRegainedSignal();
-                    contextRegainedSignal?.Connect(stageContextRegainedEventCallbackDelegate);
+                    using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
+                    signal.Ensure()?.Connect(stageContextRegainedEventCallbackDelegate);
                 }
                 stageContextRegainedEventHandler += value;
             }
             remove
             {
                 stageContextRegainedEventHandler -= value;
-                if (stageContextRegainedEventHandler == null && contextRegainedSignal?.Empty() == false)
+                if (stageContextRegainedEventHandler == null && stageContextRegainedEventCallbackDelegate != null)
                 {
-                    contextRegainedSignal?.Disconnect(stageContextRegainedEventCallbackDelegate);
+                    using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
+                    signal.Ensure()?.Disconnect(stageContextRegainedEventCallbackDelegate);
+                    stageContextRegainedEventCallbackDelegate = null;
                 }
             }
         }
@@ -412,92 +670,23 @@ namespace Tizen.NUI
                 if (stageSceneCreatedEventHandler == null)
                 {
                     stageSceneCreatedEventCallbackDelegate = OnSceneCreated;
-                    sceneCreatedSignal = SceneCreatedSignal();
-                    sceneCreatedSignal?.Connect(stageSceneCreatedEventCallbackDelegate);
+                    using VoidSignal signal = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
+                    signal.Ensure()?.Connect(stageSceneCreatedEventCallbackDelegate);
                 }
                 stageSceneCreatedEventHandler += value;
             }
             remove
             {
                 stageSceneCreatedEventHandler -= value;
-                if (stageSceneCreatedEventHandler == null && sceneCreatedSignal?.Empty() == false)
+                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));
@@ -511,115 +700,172 @@ namespace Tizen.NUI
         /// <since_tizen> 5 </since_tizen>
         internal void DisconnectNativeSignals()
         {
+            if (HasBody() == false)
+            {
+                NUILog.Debug($"[Dispose] DisConnectFromSignals() No native body! No need to Disconnect Signals!");
+                return;
+            }
+
             if (windowFocusChangedEventCallback != null)
             {
-                windowFocusChangedSignal?.Disconnect(windowFocusChangedEventCallback);
+                using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(GetBaseHandleCPtrHandleRef), false);
+                signal?.Disconnect(windowFocusChangedEventCallback);
+                windowFocusChangedEventCallback = null;
             }
 
             if (rootLayerTouchDataCallback != null)
             {
-                touchDataSignal?.Disconnect(rootLayerTouchDataCallback);
+                Interop.ActorSignal.TouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerTouchDataCallback.ToHandleRef(this));
+                NDalicPINVOKE.ThrowExceptionIfExists();
+                rootLayerTouchDataCallback = null;
+            }
+
+            if (rootLayerInterceptTouchDataCallback != null)
+            {
+                Interop.ActorSignal.InterceptTouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerInterceptTouchDataCallback.ToHandleRef(this));
+                NDalicPINVOKE.ThrowExceptionIfExists();
+                rootLayerInterceptTouchDataCallback = 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 (interceptWheelCallback != null)
+            {
+                Interop.ActorSignal.InterceptWheelDisconnect(Layer.getCPtr(GetRootLayer()), interceptWheelCallback.ToHandleRef(this));
+                NDalicPINVOKE.ThrowExceptionIfExists();
+                interceptWheelCallback = null;
             }
 
             if (stageKeyCallbackDelegate != null)
             {
-                keyEventSignal?.Disconnect(stageKeyCallbackDelegate);
+                using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(GetBaseHandleCPtrHandleRef), false);
+                signal?.Disconnect(stageKeyCallbackDelegate);
+                stageKeyCallbackDelegate = null;
+            }
+
+            if (stageInterceptKeyCallbackDelegate != null)
+            {
+                using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(GetBaseHandleCPtrHandleRef), false);
+                signal?.Disconnect(stageInterceptKeyCallbackDelegate);
+                stageInterceptKeyCallbackDelegate = null;
             }
 
             if (stageEventProcessingFinishedEventCallbackDelegate != null)
             {
-                eventProcessingFinishedSignal?.Disconnect(stageEventProcessingFinishedEventCallbackDelegate);
+                using VoidSignal signal = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
+                signal?.Disconnect(stageEventProcessingFinishedEventCallbackDelegate);
+                stageEventProcessingFinishedEventCallbackDelegate = null;
             }
 
             if (stageContextLostEventCallbackDelegate != null)
             {
-                contextLostSignal?.Disconnect(stageContextLostEventCallbackDelegate);
+                using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
+                signal?.Disconnect(stageContextLostEventCallbackDelegate);
+                stageContextLostEventCallbackDelegate = null;
             }
 
             if (stageContextRegainedEventCallbackDelegate != null)
             {
-                contextRegainedSignal?.Disconnect(stageContextRegainedEventCallbackDelegate);
+                using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
+                signal?.Disconnect(stageContextRegainedEventCallbackDelegate);
+                stageContextRegainedEventCallbackDelegate = null;
             }
 
             if (stageSceneCreatedEventCallbackDelegate != null)
             {
-                sceneCreatedSignal?.Disconnect(stageSceneCreatedEventCallbackDelegate);
+                using VoidSignal signal = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
+                signal?.Disconnect(stageSceneCreatedEventCallbackDelegate);
+                stageSceneCreatedEventCallbackDelegate = null;
             }
 
             if (windowResizeEventCallback != null)
             {
-                resizeSignal?.Disconnect(windowResizeEventCallback);
+                using ResizeSignal signal = new ResizeSignal(Interop.Window.ResizeSignal(GetBaseHandleCPtrHandleRef), false);
+                signal?.Disconnect(windowResizeEventCallback);
+                windowResizeEventCallback = null;
             }
 
             if (windowFocusChangedEventCallback2 != null)
             {
-                windowFocusChangedSignal2?.Disconnect(windowFocusChangedEventCallback2);
+                using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(GetBaseHandleCPtrHandleRef), false);
+                signal?.Disconnect(windowFocusChangedEventCallback2);
+                windowFocusChangedEventCallback2 = null;
+            }
+
+            if (transitionEffectEventCallback != null)
+            {
+                using WindowTransitionEffectSignal signal = new WindowTransitionEffectSignal(Interop.WindowTransitionEffectSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+                signal?.Disconnect(transitionEffectEventCallback);
+                transitionEffectEventCallback = null;
+            }
+
+            if (movedEventCallback != null)
+            {
+                using WindowMovedSignal signal = new WindowMovedSignal(Interop.WindowMovedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+                signal?.Disconnect(movedEventCallback);
+                movedEventCallback = null;
             }
 
-            if (transitionEffectSignal != null)
+            if (orientationChangedEventCallback != null)
             {
-                TransitionEffectEventSignal().Disconnect(transitionEffectEventCallback);
+                using WindowOrientationChangedSignal signal = new WindowOrientationChangedSignal(Interop.WindowOrientationChangedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+                signal?.Disconnect(orientationChangedEventCallback);
+                orientationChangedEventCallback = null;
             }
 
-            if (keyboardRepeatSettingsChangedSignal != null)
+            if (keyboardRepeatSettingsChangedEventCallback != null)
             {
-                KeyboardRepeatSettingsChangedEventSignal().Disconnect(keyboardRepeatSettingsChangedEventCallback);
+                using KeyboardRepeatSettingsChangedSignal signal = new KeyboardRepeatSettingsChangedSignal(Interop.KeyboardRepeatSettingsChangedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+                signal?.Disconnect(keyboardRepeatSettingsChangedEventCallback);
+                keyboardRepeatSettingsChangedEventCallback = null;
             }
 
             if (auxiliaryMessageEventCallback != null)
             {
-                using var signal = new WindowAuxiliaryMessageSignal(this);
-                signal.Disconnect(auxiliaryMessageEventCallback);
-                auxiliaryMessageEventHandler= null;
+                using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(GetBaseHandleCPtrHandleRef), false);
+                signal?.Disconnect(auxiliaryMessageEventCallback);
                 auxiliaryMessageEventCallback = null;
             }
-        }
 
-        private StageWheelSignal StageWheelEventSignal()
-        {
-            StageWheelSignal ret = new StageWheelSignal(Interop.StageSignal.WheelEventSignal(stageCPtr), false);
-            if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
-            return ret;
-        }
+            if (AccessibilityHighlightEventCallback != null)
+            {
+                using WindowAccessibilityHighlightEvent signal = new WindowAccessibilityHighlightEvent(Interop.WindowAccessibilityHighlightSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+                signal?.Disconnect(AccessibilityHighlightEventCallback);
+                AccessibilityHighlightEventCallback = 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 (windowMouseInOutEventCallback != null)
+            {
+                using WindowMouseInOutEventSignal signal = new WindowMouseInOutEventSignal(Interop.WindowMouseInOutEventSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+                signal?.Disconnect(windowMouseInOutEventCallback);
+                windowMouseInOutEventCallback = null;
+            }
 
-        private WindowTransitionEffectSignal TransitionEffectEventSignal()
-        {
-            if (transitionEffectSignal == null)
+            if (moveCompletedEventCallback != null)
             {
-                transitionEffectSignal = new WindowTransitionEffectSignal(this);
-                if (NDalicPINVOKE.SWIGPendingException.Pending)
-                    throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                using WindowMoveCompletedSignal signal = new WindowMoveCompletedSignal(Interop.WindowMoveCompletedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+                signal?.Disconnect(moveCompletedEventCallback);
+                moveCompletedEventCallback = null;
             }
-            return transitionEffectSignal;
-        }
 
-        private KeyboardRepeatSettingsChangedSignal KeyboardRepeatSettingsChangedEventSignal()
-        {
-            if (keyboardRepeatSettingsChangedSignal == null)
+            if (resizeCompletedEventCallback != null)
             {
-                keyboardRepeatSettingsChangedSignal = new KeyboardRepeatSettingsChangedSignal(this);
-                if (NDalicPINVOKE.SWIGPendingException.Pending)
-                    throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                using WindowResizeCompletedSignal signal = new WindowResizeCompletedSignal(Interop.WindowResizeCompletedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+                signal?.Disconnect(resizeCompletedEventCallback);
+                resizeCompletedEventCallback = null;
             }
-            return keyboardRepeatSettingsChangedSignal;
         }
 
         private void OnWindowFocusedChanged(IntPtr window, bool focusGained)
@@ -655,6 +901,24 @@ namespace Tizen.NUI
             return false;
         }
 
+        private bool OnWindowInterceptTouch(IntPtr view, IntPtr touchData)
+        {
+            if (touchData == global::System.IntPtr.Zero)
+            {
+                NUILog.Error("touchData should not be null!");
+                return true;
+            }
+
+            bool consumed = false;
+            if (rootLayerInterceptTouchDataEventHandler != null)
+            {
+                TouchEventArgs e = new TouchEventArgs();
+                e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
+                consumed = rootLayerInterceptTouchDataEventHandler(this, e);
+            }
+            return consumed;
+        }
+
         private bool OnStageWheel(IntPtr rootLayer, IntPtr wheelEvent)
         {
             if (wheelEvent == global::System.IntPtr.Zero)
@@ -672,6 +936,24 @@ namespace Tizen.NUI
             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)
         {
@@ -684,6 +966,20 @@ namespace Tizen.NUI
             }
         }
 
+        // 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
+                consumed = stageInterceptKeyHandler(this, e);
+            }
+            return consumed;
+        }
+
         // Callback for Stage EventProcessingFinishedSignal
         private void OnEventProcessingFinished()
         {
@@ -764,12 +1060,90 @@ namespace Tizen.NUI
             return;
         }
 
+        private void OnMoved(IntPtr window, IntPtr position)
+        {
+            if (window == global::System.IntPtr.Zero)
+            {
+                return;
+            }
+
+            if (movedHandler != null)
+            {
+                WindowMovedEventArgs e = new WindowMovedEventArgs();
+                e.WindowPosition = this.WindowPosition;
+                movedHandler(this, e);
+            }
+            return;
+        }
+
+        private void OnOrientationChanged(IntPtr window, int orientation)
+        {
+            if (window == global::System.IntPtr.Zero)
+            {
+                return;
+            }
+
+            if (orientationChangedHandler != null)
+            {
+                WindowOrientationChangedEventArgs e = new WindowOrientationChangedEventArgs();
+                e.WindowOrientation = (WindowOrientation)orientation;
+                orientationChangedHandler(this, e);
+            }
+            return;
+        }
+
         private void OnKeyboardRepeatSettingsChanged()
         {
             keyboardRepeatSettingsChangedHandler?.Invoke(this, null);
             return;
         }
 
+        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 (window == global::System.IntPtr.Zero)
+            {
+                return;
+            }
+
+            if (resizeCompletedHandler != null)
+            {
+                WindowResizeCompletedEventArgs e = new WindowResizeCompletedEventArgs(this.WindowSize);
+                resizeCompletedHandler(this, e);
+            }
+            return;
+        }
+
         /// <summary>
         /// The focus changed event argument.
         /// </summary>
@@ -889,10 +1263,35 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Please do not use! this will be deprecated
+        /// 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>
-        [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) {...}")]
@@ -901,7 +1300,7 @@ namespace Tizen.NUI
         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
@@ -915,7 +1314,7 @@ namespace Tizen.NUI
         /// Contains and encapsulates Native Window handle.
         /// </summary>
         /// <since_tizen> 4 </since_tizen>
-        [Obsolete("Deprecated in API9, will be removed in API11. Please use Window.NativeHandle instead!")]
+        [Obsolete("This has been deprecated in API9 and will be removed in API11. Use Window.NativeHandle instead.")]
         public class SafeNativeWindowHandle : SafeHandle
         {
             /// <summary>
@@ -1062,23 +1461,19 @@ namespace Tizen.NUI
                 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;
                 }
             }
         }
@@ -1098,7 +1493,7 @@ namespace Tizen.NUI
 
         private void OnAuxiliaryMessage(IntPtr kData, IntPtr vData, IntPtr optionsArray)
         {
-            if(kData == IntPtr.Zero || vData == IntPtr.Zero)
+            if (kData == IntPtr.Zero || vData == IntPtr.Zero)
             {
                 return;
             }
@@ -1119,7 +1514,7 @@ namespace Tizen.NUI
 
             AuxiliaryMessageEventArgs e = new AuxiliaryMessageEventArgs();
             e.Key = StringToVoidSignal.GetResult(kData);
-            e.Value = StringToVoidSignal.GetResult(vData);;
+            e.Value = StringToVoidSignal.GetResult(vData); ;
             e.Options = tmpList;
 
             auxiliaryMessageEventHandler?.Invoke(this, e);
@@ -1139,30 +1534,174 @@ namespace Tizen.NUI
                 if (auxiliaryMessageEventHandler == null)
                 {
                     auxiliaryMessageEventCallback = OnAuxiliaryMessage;
-                    using var signal = new WindowAuxiliaryMessageSignal(this);
-                    signal.Connect(auxiliaryMessageEventCallback);
+                    using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(SwigCPtr), false);
+                    signal.Ensure()?.Connect(auxiliaryMessageEventCallback);
                 }
                 auxiliaryMessageEventHandler += value;
             }
             remove
             {
                 auxiliaryMessageEventHandler -= value;
-                if (auxiliaryMessageEventHandler == null)
+                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
                 {
-                    if (auxiliaryMessageEventCallback != null)
-                    {
-                        using var signal = new WindowAuxiliaryMessageSignal(this);
-                        signal.Disconnect(auxiliaryMessageEventCallback);
+                    accessibilityHighlight = value;
+                }
+            }
+        }
+
+        private void OnAccessibilityHighlight(IntPtr window, bool highlight)
+        {
+            if (window == global::System.IntPtr.Zero)
+            {
+                NUILog.Error("[ERR] OnAccessibilityHighlight() window is null");
+                return;
+            }
 
-                        if (signal.Empty())
-                        {
-                            auxiliaryMessageEventCallback = null;
-                        }
-                    }
+            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>
+    /// Move event is sent when window is resized by user or the display server.
+    /// </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;
+            }
+        }
+    }
+
+    /// <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;
+        }
     }
+
 }