From: dongsug.song Date: Tue, 8 Nov 2022 14:07:18 +0000 (+0900) Subject: [NUI] change View,Window events pattern matching with latest NUI X-Git-Tag: accepted/tizen/6.0/unified/20221109.122316~1^2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=d10e0ce2edf0046e0cf08ca58d271950d80baa2a;p=platform%2Fcore%2Fcsapi%2Ftizenfx.git [NUI] change View,Window events pattern matching with latest NUI --- diff --git a/src/Tizen.NUI/src/public/BaseComponents/ViewEvent.cs b/src/Tizen.NUI/src/public/BaseComponents/ViewEvent.cs index 3f491fd..3a50044 100755 --- a/src/Tizen.NUI/src/public/BaseComponents/ViewEvent.cs +++ b/src/Tizen.NUI/src/public/BaseComponents/ViewEvent.cs @@ -115,19 +115,24 @@ namespace Tizen.NUI.BaseComponents if (_keyInputFocusGainedEventHandler == null) { _keyInputFocusGainedCallback = OnKeyInputFocusGained; - this.KeyInputFocusGainedSignal().Connect(_keyInputFocusGainedCallback); + var signal = KeyInputFocusGainedSignal(); + signal?.Connect(_keyInputFocusGainedCallback); + signal?.Dispose(); } - _keyInputFocusGainedEventHandler += value; } - remove { _keyInputFocusGainedEventHandler -= value; - - if (_keyInputFocusGainedEventHandler == null && KeyInputFocusGainedSignal().Empty() == false) + if (_keyInputFocusGainedEventHandler == null) { - this.KeyInputFocusGainedSignal().Disconnect(_keyInputFocusGainedCallback); + var signal = KeyInputFocusGainedSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_keyInputFocusGainedCallback); + _keyInputFocusGainedCallback = null; + } + signal?.Dispose(); } } } @@ -144,19 +149,24 @@ namespace Tizen.NUI.BaseComponents if (_keyInputFocusLostEventHandler == null) { _keyInputFocusLostCallback = OnKeyInputFocusLost; - this.KeyInputFocusLostSignal().Connect(_keyInputFocusLostCallback); + var signal = KeyInputFocusLostSignal(); + signal?.Connect(_keyInputFocusLostCallback); + signal?.Dispose(); } - _keyInputFocusLostEventHandler += value; } - remove { _keyInputFocusLostEventHandler -= value; - - if (_keyInputFocusLostEventHandler == null && KeyInputFocusLostSignal().Empty() == false) + if (_keyInputFocusLostEventHandler == null) { - this.KeyInputFocusLostSignal().Disconnect(_keyInputFocusLostCallback); + var signal = KeyInputFocusLostSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_keyInputFocusLostCallback); + _keyInputFocusLostCallback = null; + } + signal?.Dispose(); } } } @@ -173,19 +183,24 @@ namespace Tizen.NUI.BaseComponents if (_keyEventHandler == null) { _keyCallback = OnKeyEvent; - this.KeyEventSignal().Connect(_keyCallback); + var signal = KeyEventSignal(); + signal?.Connect(_keyCallback); + signal?.Dispose(); } - _keyEventHandler += value; } - remove { _keyEventHandler -= value; - - if (_keyEventHandler == null && KeyEventSignal().Empty() == false) + if (_keyEventHandler == null) { - this.KeyEventSignal().Disconnect(_keyCallback); + var signal = KeyEventSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_keyCallback); + _keyCallback = null; + } + signal?.Dispose(); } } } @@ -202,22 +217,25 @@ namespace Tizen.NUI.BaseComponents if (_onRelayoutEventHandler == null) { _onRelayoutEventCallback = OnRelayout; - this.OnRelayoutSignal().Connect(_onRelayoutEventCallback); + var signal = OnRelayoutSignal(); + signal?.Connect(_onRelayoutEventCallback); + signal?.Dispose(); } - _onRelayoutEventHandler += value; } - remove { _onRelayoutEventHandler -= value; - - if (_onRelayoutEventHandler == null && OnRelayoutSignal().Empty() == false) + if (_onRelayoutEventHandler == null) { - this.OnRelayoutSignal().Disconnect(_onRelayoutEventCallback); - _onRelayoutEventCallback = null; + var signal = OnRelayoutSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_onRelayoutEventCallback); + _onRelayoutEventCallback = null; + } + signal?.Dispose(); } - } } @@ -235,19 +253,24 @@ namespace Tizen.NUI.BaseComponents if (_interceptTouchDataEventHandler == null) { _interceptTouchDataCallback = OnInterceptTouch; - this.InterceptTouchSignal().Connect(_interceptTouchDataCallback); + var signal = InterceptTouchSignal(); + signal?.Connect(_interceptTouchDataCallback); + signal?.Dispose(); } - _interceptTouchDataEventHandler += value; } - remove { _interceptTouchDataEventHandler -= value; - - if (_interceptTouchDataEventHandler == null && InterceptTouchSignal().Empty() == false) + if (_interceptTouchDataEventHandler == null) { - this.InterceptTouchSignal().Disconnect(_interceptTouchDataCallback); + var signal = InterceptTouchSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_interceptTouchDataCallback); + _interceptTouchDataCallback = null; + } + signal?.Dispose(); } } } @@ -262,7 +285,7 @@ namespace Tizen.NUI.BaseComponents /// This prevents the parent from interceping touch. /// [EditorBrowsable(EditorBrowsableState.Never)] - public bool DisallowInterceptTouchEvent {get; set;} + public bool DisallowInterceptTouchEvent { get; set; } /// @@ -277,19 +300,24 @@ namespace Tizen.NUI.BaseComponents if (_touchDataEventHandler == null) { _touchDataCallback = OnTouch; - this.TouchSignal().Connect(_touchDataCallback); + var signal = TouchSignal(); + signal?.Connect(_touchDataCallback); + signal?.Dispose(); } - _touchDataEventHandler += value; } - remove { _touchDataEventHandler -= value; - - if (_touchDataEventHandler == null && TouchSignal().Empty() == false) + if (_touchDataEventHandler == null) { - this.TouchSignal().Disconnect(_touchDataCallback); + var signal = TouchSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_touchDataCallback); + _touchDataCallback = null; + } + signal?.Dispose(); } } } @@ -306,21 +334,25 @@ namespace Tizen.NUI.BaseComponents if (_hoverEventHandler == null) { _hoverEventCallback = OnHoverEvent; - this.HoveredSignal().Connect(_hoverEventCallback); + var signal = HoveredSignal(); + signal?.Connect(_hoverEventCallback); + signal?.Dispose(); } - _hoverEventHandler += value; } - remove { _hoverEventHandler -= value; - - if (_hoverEventHandler == null && HoveredSignal().Empty() == false) + if (_hoverEventHandler == null) { - this.HoveredSignal().Disconnect(_hoverEventCallback); + var signal = HoveredSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_hoverEventCallback); + _hoverEventCallback = null; + } + signal?.Dispose(); } - } } @@ -336,7 +368,9 @@ namespace Tizen.NUI.BaseComponents if (_wheelEventHandler == null) { _wheelEventCallback = OnWheelEvent; - this.WheelEventSignal().Connect(_wheelEventCallback); + var signal = WheelEventSignal(); + signal?.Connect(_wheelEventCallback); + signal?.Dispose(); } _wheelEventHandler += value; @@ -346,13 +380,18 @@ namespace Tizen.NUI.BaseComponents } WindowWheelEventHandler += value; } - remove { _wheelEventHandler -= value; - if (_wheelEventHandler == null && WheelEventSignal().Empty() == false) + if (_wheelEventHandler == null) { - this.WheelEventSignal().Disconnect(_wheelEventCallback); + var signal = WheelEventSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_wheelEventCallback); + _wheelEventCallback = null; + } + signal?.Dispose(); } WindowWheelEventHandler -= value; @@ -375,20 +414,24 @@ namespace Tizen.NUI.BaseComponents if (_onWindowEventHandler == null) { _onWindowEventCallback = OnWindow; - this.OnWindowSignal().Connect(_onWindowEventCallback); + var signal = OnWindowSignal(); + signal?.Connect(_onWindowEventCallback); + signal?.Dispose(); } - _onWindowEventHandler += value; } - remove { _onWindowEventHandler -= value; - - if (_onWindowEventHandler == null && OnWindowSignal().Empty() == false) + if (_onWindowEventHandler == null) { - this.OnWindowSignal().Disconnect(_onWindowEventCallback); - _onWindowEventCallback = null; + var signal = OnWindowSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_onWindowEventCallback); + _onWindowEventCallback = null; + } + signal?.Dispose(); } } } @@ -405,20 +448,24 @@ namespace Tizen.NUI.BaseComponents if (_offWindowEventHandler == null) { _offWindowEventCallback = OffWindow; - this.OffWindowSignal().Connect(_offWindowEventCallback); + var signal = OffWindowSignal(); + signal?.Connect(_offWindowEventCallback); + signal?.Dispose(); } - _offWindowEventHandler += value; } - remove { _offWindowEventHandler -= value; - - if (_offWindowEventHandler == null && OffWindowSignal().Empty() == false) + if (_offWindowEventHandler == null) { - this.OffWindowSignal().Disconnect(_offWindowEventCallback); - _offWindowEventCallback = null; + var signal = OffWindowSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_offWindowEventCallback); + _offWindowEventCallback = null; + } + signal?.Dispose(); } } } @@ -435,19 +482,24 @@ namespace Tizen.NUI.BaseComponents if (_visibilityChangedEventHandler == null) { _visibilityChangedEventCallback = OnVisibilityChanged; - VisibilityChangedSignal(this).Connect(_visibilityChangedEventCallback); + var signal = VisibilityChangedSignal(this); + signal?.Connect(_visibilityChangedEventCallback); + signal?.Dispose(); } - _visibilityChangedEventHandler += value; } - remove { _visibilityChangedEventHandler -= value; - - if (_visibilityChangedEventHandler == null && VisibilityChangedSignal(this).Empty() == false) + if (_visibilityChangedEventHandler == null) { - VisibilityChangedSignal(this).Disconnect(_visibilityChangedEventCallback); + var signal = VisibilityChangedSignal(this); + if (signal?.Empty() == false) + { + signal?.Disconnect(_visibilityChangedEventCallback); + _visibilityChangedEventCallback = null; + } + signal?.Dispose(); } } } @@ -464,19 +516,24 @@ namespace Tizen.NUI.BaseComponents if (_layoutDirectionChangedEventHandler == null) { _layoutDirectionChangedEventCallback = OnLayoutDirectionChanged; - LayoutDirectionChangedSignal(this).Connect(_layoutDirectionChangedEventCallback); + var signal = LayoutDirectionChangedSignal(this); + signal?.Connect(_layoutDirectionChangedEventCallback); + signal?.Dispose(); } - _layoutDirectionChangedEventHandler += value; } - remove { _layoutDirectionChangedEventHandler -= value; - - if (_layoutDirectionChangedEventHandler == null && LayoutDirectionChangedSignal(this).Empty() == false) + if (_layoutDirectionChangedEventHandler == null) { - LayoutDirectionChangedSignal(this).Disconnect(_layoutDirectionChangedEventCallback); + var signal = LayoutDirectionChangedSignal(this); + if (signal?.Empty() == false) + { + signal?.Disconnect(_layoutDirectionChangedEventCallback); + _layoutDirectionChangedEventCallback = null; + } + signal?.Dispose(); } } } @@ -493,20 +550,24 @@ namespace Tizen.NUI.BaseComponents if (_resourcesLoadedEventHandler == null) { _ResourcesLoadedCallback = OnResourcesLoaded; - this.ResourcesLoadedSignal().Connect(_ResourcesLoadedCallback); + var signal = ResourcesLoadedSignal(); + signal?.Connect(_ResourcesLoadedCallback); + signal?.Dispose(); } - _resourcesLoadedEventHandler += value; } - remove { _resourcesLoadedEventHandler -= value; - - if (_resourcesLoadedEventHandler == null && ResourcesLoadedSignal().Empty() == false) + if (_resourcesLoadedEventHandler == null) { - this.ResourcesLoadedSignal().Disconnect(_ResourcesLoadedCallback); - _ResourcesLoadedCallback = null; + var signal = ResourcesLoadedSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_ResourcesLoadedCallback); + _ResourcesLoadedCallback = null; + } + signal?.Dispose(); } } } @@ -539,7 +600,7 @@ namespace Tizen.NUI.BaseComponents [EditorBrowsable(EditorBrowsableState.Never)] internal void EmitBackKeyPressed() { - _backKeyPressed.Invoke(this,null); + _backKeyPressed.Invoke(this, null); } @@ -550,19 +611,24 @@ namespace Tizen.NUI.BaseComponents if (_backgroundResourceLoadedEventHandler == null) { _backgroundResourceLoadedCallback = OnBackgroundResourceLoaded; - this.ResourcesLoadedSignal().Connect(_backgroundResourceLoadedCallback); + var signal = ResourcesLoadedSignal(); + signal?.Connect(_backgroundResourceLoadedCallback); + signal?.Dispose(); } - _backgroundResourceLoadedEventHandler += value; } remove { _backgroundResourceLoadedEventHandler -= value; - - if (_backgroundResourceLoadedEventHandler == null && ResourcesLoadedSignal().Empty() == false) + if (_backgroundResourceLoadedEventHandler == null) { - this.ResourcesLoadedSignal().Disconnect(_backgroundResourceLoadedCallback); - _backgroundResourceLoadedCallback = null; + var signal = ResourcesLoadedSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_backgroundResourceLoadedCallback); + _backgroundResourceLoadedCallback = null; + } + signal?.Dispose(); } } } @@ -1265,9 +1331,9 @@ namespace Tizen.NUI.BaseComponents private EventHandlerWithReturnType WindowWheelEventHandler; private void OnWindowWheelEvent(object sender, Window.WheelEventArgs e) { - if(e != null) + if (e != null) { - if(e.Wheel.Type == Wheel.WheelType.CustomWheel) + if (e.Wheel.Type == Wheel.WheelType.CustomWheel) { var arg = new WheelEventArgs() { diff --git a/src/Tizen.NUI/src/public/BaseComponents/ViewInternal.cs b/src/Tizen.NUI/src/public/BaseComponents/ViewInternal.cs index f88b9e5..a6f142a 100755 --- a/src/Tizen.NUI/src/public/BaseComponents/ViewInternal.cs +++ b/src/Tizen.NUI/src/public/BaseComponents/ViewInternal.cs @@ -1116,12 +1116,12 @@ namespace Tizen.NUI.BaseComponents { ThemeManager.ThemeChangedInternal -= OnThemeChanged; } - if(widthConstraint != null) + if (widthConstraint != null) { widthConstraint.Remove(); widthConstraint.Dispose(); } - if(heightConstraint != null) + if (heightConstraint != null) { heightConstraint.Remove(); heightConstraint.Dispose(); @@ -1158,7 +1158,7 @@ namespace Tizen.NUI.BaseComponents [EditorBrowsable(EditorBrowsableState.Never)] protected virtual bool HandleControlStateOnTouch(Touch touch) { - switch(touch.GetState(0)) + switch (touch.GetState(0)) { case PointStateType.Down: ControlState += ControlState.Pressed; @@ -1179,33 +1179,42 @@ namespace Tizen.NUI.BaseComponents private void DisConnectFromSignals() { - // Save current CPtr. - global::System.Runtime.InteropServices.HandleRef currentCPtr = swigCPtr; - - // Use BaseHandle CPtr as current might have been deleted already in derived classes. - swigCPtr = GetBaseHandleCPtrHandleRef; + if (HasBody() == false) + { + NUILog.Debug($"View.DisConnectFromSignals() No native body! No need to Disconnect Signals!"); + return; + } if (_onRelayoutEventCallback != null) { - this.OnRelayoutSignal().Disconnect(_onRelayoutEventCallback); + ViewSignal signal = new ViewSignal(Interop.ActorSignal.Actor_OnRelayoutSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_onRelayoutEventCallback); + signal?.Dispose(); _onRelayoutEventCallback = null; } if (_offWindowEventCallback != null) { - this.OffWindowSignal().Disconnect(_offWindowEventCallback); + ViewSignal signal = new ViewSignal(Interop.ActorSignal.Actor_OffSceneSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_offWindowEventCallback); + signal?.Dispose(); _offWindowEventCallback = null; } if (_onWindowEventCallback != null) { - this.OnWindowSignal().Disconnect(_onWindowEventCallback); + ViewSignal signal = new ViewSignal(Interop.ActorSignal.Actor_OnSceneSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_onWindowEventCallback); + signal?.Dispose(); _onWindowEventCallback = null; } if (_wheelEventCallback != null) { - this.WheelEventSignal().Disconnect(_wheelEventCallback); + WheelSignal signal = new WheelSignal(Interop.ActorSignal.Actor_WheelEventSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_wheelEventCallback); + signal?.Dispose(); + _wheelEventCallback = null; } if (WindowWheelEventHandler != null) @@ -1215,55 +1224,91 @@ namespace Tizen.NUI.BaseComponents if (_hoverEventCallback != null) { - this.HoveredSignal().Disconnect(_hoverEventCallback); + HoverSignal signal = new HoverSignal(Interop.ActorSignal.Actor_HoveredSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_hoverEventCallback); + signal?.Dispose(); + _hoverEventCallback = null; } if (_interceptTouchDataCallback != null) { - this.InterceptTouchSignal().Disconnect(_interceptTouchDataCallback); + TouchDataSignal signal = new TouchDataSignal(Interop.ActorSignal.Actor_InterceptTouchSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_interceptTouchDataCallback); + signal?.Dispose(); + _interceptTouchDataCallback = null; } if (_touchDataCallback != null) { - this.TouchSignal().Disconnect(_touchDataCallback); + TouchDataSignal signal = new TouchDataSignal(Interop.ActorSignal.Actor_TouchSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_touchDataCallback); + signal?.Dispose(); + _touchDataCallback = null; } if (_ResourcesLoadedCallback != null) { - this.ResourcesLoadedSignal().Disconnect(_ResourcesLoadedCallback); + ViewSignal signal = new ViewSignal(Interop.View.ResourceReadySignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_ResourcesLoadedCallback); + signal?.Dispose(); _ResourcesLoadedCallback = null; } if (_keyCallback != null) { - this.KeyEventSignal().Disconnect(_keyCallback); + ControlKeySignal signal = new ControlKeySignal(Interop.ViewSignal.View_KeyEventSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_keyCallback); + signal?.Dispose(); + _keyCallback = null; } if (_keyInputFocusLostCallback != null) { - this.KeyInputFocusLostSignal().Disconnect(_keyInputFocusLostCallback); + KeyInputFocusSignal signal = new KeyInputFocusSignal(Interop.ViewSignal.View_KeyInputFocusLostSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_keyInputFocusLostCallback); + signal?.Dispose(); + _keyInputFocusLostCallback = null; } if (_keyInputFocusGainedCallback != null) { - this.KeyInputFocusGainedSignal().Disconnect(_keyInputFocusGainedCallback); + KeyInputFocusSignal signal = new KeyInputFocusSignal(Interop.ViewSignal.View_KeyInputFocusGainedSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_keyInputFocusGainedCallback); + signal?.Dispose(); + _keyInputFocusGainedCallback = null; } if (_backgroundResourceLoadedCallback != null) { - this.ResourcesLoadedSignal().Disconnect(_backgroundResourceLoadedCallback); + ViewSignal signal = new ViewSignal(Interop.View.ResourceReadySignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_backgroundResourceLoadedCallback); + signal?.Dispose(); _backgroundResourceLoadedCallback = null; } if (_onWindowSendEventCallback != null) { - this.OnWindowSignal().Disconnect(_onWindowSendEventCallback); + ViewSignal signal = new ViewSignal(Interop.ActorSignal.Actor_OnSceneSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_onWindowSendEventCallback); + signal?.Dispose(); _onWindowSendEventCallback = null; } - // BaseHandle CPtr is used in Registry and there is danger of deletion if we keep using it here. - // Restore current CPtr. - swigCPtr = currentCPtr; + if (_visibilityChangedEventCallback != null) + { + ViewVisibilityChangedSignal signal = new ViewVisibilityChangedSignal(Interop.NDalic.VisibilityChangedSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_visibilityChangedEventCallback); + signal?.Dispose(); + _visibilityChangedEventCallback = null; + } + + if (_layoutDirectionChangedEventCallback != null) + { + ViewLayoutDirectionChangedSignal signal = new ViewLayoutDirectionChangedSignal(Interop.Layout.LayoutDirectionChangedSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_layoutDirectionChangedEventCallback); + signal?.Dispose(); + _layoutDirectionChangedEventCallback = null; + } } private View ConvertIdToView(uint id) diff --git a/src/Tizen.NUI/src/public/WindowEvent.cs b/src/Tizen.NUI/src/public/WindowEvent.cs index e39beec..d297fb2 100755 --- a/src/Tizen.NUI/src/public/WindowEvent.cs +++ b/src/Tizen.NUI/src/public/WindowEvent.cs @@ -73,18 +73,24 @@ namespace Tizen.NUI if (_windowFocusChangedEventHandler == null) { _windowFocusChangedEventCallback = OnWindowFocusedChanged; - WindowFocusChangedSignal().Connect(_windowFocusChangedEventCallback); + var signal = WindowFocusChangedSignal(); + signal?.Connect(_windowFocusChangedEventCallback); + signal?.Dispose(); } - _windowFocusChangedEventHandler += value; } remove { _windowFocusChangedEventHandler -= value; - - if (_windowFocusChangedEventHandler == null && WindowFocusChangedSignal().Empty() == false && _windowFocusChangedEventCallback != null) + if (_windowFocusChangedEventHandler == null) { - WindowFocusChangedSignal().Disconnect(_windowFocusChangedEventCallback); + var signal = WindowFocusChangedSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_windowFocusChangedEventCallback); + _windowFocusChangedEventCallback = null; + } + signal?.Dispose(); } } } @@ -103,16 +109,24 @@ namespace Tizen.NUI if (_rootLayerTouchDataEventHandler == null) { _rootLayerTouchDataCallback = OnWindowTouch; - this.TouchDataSignal().Connect(_rootLayerTouchDataCallback); + var signal = TouchDataSignal(); + signal?.Connect(_rootLayerTouchDataCallback); + signal?.Dispose(); } _rootLayerTouchDataEventHandler += value; } remove { _rootLayerTouchDataEventHandler -= value; - if (_rootLayerTouchDataEventHandler == null && TouchSignal().Empty() == false && _rootLayerTouchDataCallback != null) + if (_rootLayerTouchDataEventHandler == null) { - this.TouchDataSignal().Disconnect(_rootLayerTouchDataCallback); + var signal = TouchDataSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_rootLayerTouchDataCallback); + _rootLayerTouchDataCallback = null; + } + signal?.Dispose(); } } } @@ -128,29 +142,24 @@ namespace Tizen.NUI if (_stageWheelHandler == null) { _wheelEventCallback = OnStageWheel; - WheelEventSignal().Connect(_wheelEventCallback); + var signal = WheelEventSignal(); + signal?.Connect(_wheelEventCallback); + signal?.Dispose(); } _stageWheelHandler += value; - - if (DetentEventHandler == null) - { - DetentEventCallback = OnDetentEvent; - StageWheelEventSignal().Connect(DetentEventCallback); - } - DetentEventHandler += value; } remove { _stageWheelHandler -= value; - if (_stageWheelHandler == null && WheelEventSignal().Empty() == false) - { - WheelEventSignal().Disconnect(_wheelEventCallback); - } - - DetentEventHandler -= value; - if(DetentEventHandler == null && StageWheelEventSignal().Empty() == false) + if (_stageWheelHandler == null) { - StageWheelEventSignal().Disconnect(DetentEventCallback); + var signal = WheelEventSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_wheelEventCallback); + _wheelEventCallback = null; + } + signal?.Dispose(); } } } @@ -166,16 +175,24 @@ namespace Tizen.NUI if (_stageKeyHandler == null) { _stageKeyCallbackDelegate = OnStageKey; - KeyEventSignal().Connect(_stageKeyCallbackDelegate); + var signal = KeyEventSignal(); + signal?.Connect(_stageKeyCallbackDelegate); + signal?.Dispose(); } _stageKeyHandler += value; } remove { _stageKeyHandler -= value; - if (_stageKeyHandler == null && KeyEventSignal().Empty() == false) + if (_stageKeyHandler == null) { - KeyEventSignal().Disconnect(_stageKeyCallbackDelegate); + var signal = KeyEventSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_stageKeyCallbackDelegate); + _stageKeyCallbackDelegate = null; + } + signal?.Dispose(); } } } @@ -191,18 +208,24 @@ namespace Tizen.NUI if (_windowResizeEventHandler == null) { _windowResizeEventCallback = OnResized; - ResizeSignal().Connect(_windowResizeEventCallback); + var signal = ResizeSignal(); + signal?.Connect(_windowResizeEventCallback); + signal?.Dispose(); } - _windowResizeEventHandler += value; } remove { _windowResizeEventHandler -= value; - - if (_windowResizeEventHandler == null && ResizeSignal().Empty() == false && _windowResizeEventCallback != null) + if (_windowResizeEventHandler == null) { - ResizeSignal().Disconnect(_windowResizeEventCallback); + var signal = ResizeSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_windowResizeEventCallback); + _windowResizeEventCallback = null; + } + signal?.Dispose(); } } } @@ -225,20 +248,27 @@ namespace Tizen.NUI if (_windowFocusChangedEventHandler2 == null) { _windowFocusChangedEventCallback2 = OnWindowFocusedChanged2; - WindowFocusChangedSignal().Connect(_windowFocusChangedEventCallback2); + var signal = WindowFocusChangedSignal(); + signal?.Connect(_windowFocusChangedEventCallback2); + signal?.Dispose(); } - _windowFocusChangedEventHandler2 += value; } remove { _windowFocusChangedEventHandler2 -= value; - - if (_windowFocusChangedEventHandler2 == null && WindowFocusChangedSignal().Empty() == false && _windowFocusChangedEventCallback2 != null) + if (_windowFocusChangedEventHandler2 == null) { - WindowFocusChangedSignal().Disconnect(_windowFocusChangedEventCallback2); + var signal = WindowFocusChangedSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_windowFocusChangedEventCallback2); + _windowFocusChangedEventCallback2 = null; + } + signal?.Dispose(); } } + } /// @@ -252,16 +282,24 @@ namespace Tizen.NUI if (transitionEffectHandler == null) { transitionEffectEventCallback = OnTransitionEffect; - TransitionEffectEventSignal().Connect(transitionEffectEventCallback); + var signal = new WindowTransitionEffectSignal(this); + signal?.Connect(transitionEffectEventCallback); + signal?.Dispose(); } transitionEffectHandler += value; } remove { transitionEffectHandler -= value; - if (transitionEffectHandler == null && TransitionEffectEventSignal().Empty() == false) + if (transitionEffectHandler == null) { - TransitionEffectEventSignal().Disconnect(transitionEffectEventCallback); + var signal = new WindowTransitionEffectSignal(this); + if (signal?.Empty() == false) + { + signal?.Disconnect(transitionEffectEventCallback); + transitionEffectEventCallback = null; + } + signal?.Dispose(); } } } @@ -277,18 +315,27 @@ namespace Tizen.NUI if (keyboardRepeatSettingsChangedHandler == null) { keyboardRepeatSettingsChangedEventCallback = OnKeyboardRepeatSettingsChanged; - KeyboardRepeatSettingsChangedEventSignal().Connect(keyboardRepeatSettingsChangedEventCallback); + var signal = new KeyboardRepeatSettingsChangedSignal(this); + signal?.Connect(keyboardRepeatSettingsChangedEventCallback); + signal?.Dispose(); } keyboardRepeatSettingsChangedHandler += value; } remove { keyboardRepeatSettingsChangedHandler -= value; - if (keyboardRepeatSettingsChangedHandler == null && KeyboardRepeatSettingsChangedEventSignal().Empty() == false) + if (keyboardRepeatSettingsChangedHandler == null) { - KeyboardRepeatSettingsChangedEventSignal().Disconnect(keyboardRepeatSettingsChangedEventCallback); + var signal = new KeyboardRepeatSettingsChangedSignal(this); + if (signal?.Empty() == false) + { + signal?.Disconnect(keyboardRepeatSettingsChangedEventCallback); + keyboardRepeatSettingsChangedEventCallback = null; + } + signal?.Dispose(); } } + } /// @@ -320,17 +367,24 @@ namespace Tizen.NUI if (_stageEventProcessingFinishedEventHandler == null) { _stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished; - EventProcessingFinishedSignal().Connect(_stageEventProcessingFinishedEventCallbackDelegate); + var signal = EventProcessingFinishedSignal(); + signal?.Connect(_stageEventProcessingFinishedEventCallbackDelegate); + signal?.Dispose(); } _stageEventProcessingFinishedEventHandler += value; - } remove { _stageEventProcessingFinishedEventHandler -= value; - if (_stageEventProcessingFinishedEventHandler == null && EventProcessingFinishedSignal().Empty() == false) + if (_stageEventProcessingFinishedEventHandler == null) { - EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate); + var signal = EventProcessingFinishedSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_stageEventProcessingFinishedEventCallbackDelegate); + _stageEventProcessingFinishedEventCallbackDelegate = null; + } + signal?.Dispose(); } } } @@ -342,16 +396,24 @@ namespace Tizen.NUI if (_stageContextLostEventHandler == null) { _stageContextLostEventCallbackDelegate = OnContextLost; - ContextLostSignal().Connect(_stageContextLostEventCallbackDelegate); + var signal = ContextLostSignal(); + signal?.Connect(_stageContextLostEventCallbackDelegate); + signal?.Dispose(); } _stageContextLostEventHandler += value; } remove { _stageContextLostEventHandler -= value; - if (_stageContextLostEventHandler == null && ContextLostSignal().Empty() == false) + if (_stageContextLostEventHandler == null) { - ContextLostSignal().Disconnect(_stageContextLostEventCallbackDelegate); + var signal = ContextLostSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_stageContextLostEventCallbackDelegate); + _stageContextLostEventCallbackDelegate = null; + } + signal?.Dispose(); } } } @@ -363,16 +425,24 @@ namespace Tizen.NUI if (_stageContextRegainedEventHandler == null) { _stageContextRegainedEventCallbackDelegate = OnContextRegained; - ContextRegainedSignal().Connect(_stageContextRegainedEventCallbackDelegate); + var signal = ContextRegainedSignal(); + signal?.Connect(_stageContextRegainedEventCallbackDelegate); + signal?.Dispose(); } _stageContextRegainedEventHandler += value; } remove { _stageContextRegainedEventHandler -= value; - if (_stageContextRegainedEventHandler == null && ContextRegainedSignal().Empty() == false) + if (_stageContextRegainedEventHandler == null) { - this.ContextRegainedSignal().Disconnect(_stageContextRegainedEventCallbackDelegate); + var signal = ContextRegainedSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_stageContextRegainedEventCallbackDelegate); + _stageContextRegainedEventCallbackDelegate = null; + } + signal?.Dispose(); } } } @@ -384,16 +454,24 @@ namespace Tizen.NUI if (_stageSceneCreatedEventHandler == null) { _stageSceneCreatedEventCallbackDelegate = OnSceneCreated; - SceneCreatedSignal().Connect(_stageSceneCreatedEventCallbackDelegate); + var signal = SceneCreatedSignal(); + signal?.Connect(_stageSceneCreatedEventCallbackDelegate); + signal?.Dispose(); } _stageSceneCreatedEventHandler += value; } remove { _stageSceneCreatedEventHandler -= value; - if (_stageSceneCreatedEventHandler == null && SceneCreatedSignal().Empty() == false) + if (_stageSceneCreatedEventHandler == null) { - SceneCreatedSignal().Disconnect(_stageSceneCreatedEventCallbackDelegate); + var signal = SceneCreatedSignal(); + if (signal?.Empty() == false) + { + signal?.Disconnect(_stageSceneCreatedEventCallbackDelegate); + _stageSceneCreatedEventCallbackDelegate = null; + } + signal?.Dispose(); } } } @@ -482,69 +560,119 @@ namespace Tizen.NUI /// 5 internal void DisconnectNativeSignals() { + if (HasBody() == false) + { + NUILog.Debug($"Window.DisconnectNativeSignals() No native body! No need to Disconnect Signals!"); + return; + } + if (_windowFocusChangedEventCallback != null) { - WindowFocusChangedSignal().Disconnect(_windowFocusChangedEventCallback); + WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_windowFocusChangedEventCallback); + signal?.Dispose(); + _windowFocusChangedEventCallback = null; } if (_rootLayerTouchDataCallback != null) { - TouchDataSignal().Disconnect(_rootLayerTouchDataCallback); + TouchDataSignal signal = new TouchDataSignal(Interop.ActorSignal.Actor_TouchSignal(Layer.getCPtr(GetRootLayer())), false); + signal?.Disconnect(_rootLayerTouchDataCallback); + signal?.Dispose(); + _rootLayerTouchDataCallback = null; } if (_wheelEventCallback != null) { - WheelEventSignal().Disconnect(_wheelEventCallback); + WheelSignal signal = new WheelSignal(Interop.ActorSignal.Actor_WheelEventSignal(Layer.getCPtr(this.GetRootLayer())), false); + signal?.Disconnect(_wheelEventCallback); + signal?.Dispose(); + _wheelEventCallback = null; } - if(DetentEventCallback != null) + if (DetentEventCallback != null) { StageWheelEventSignal().Disconnect(DetentEventCallback); } if (_stageKeyCallbackDelegate != null) { - KeyEventSignal().Disconnect(_stageKeyCallbackDelegate); + KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_stageKeyCallbackDelegate); + signal?.Dispose(); + _stageKeyCallbackDelegate = null; } if (_stageEventProcessingFinishedEventCallbackDelegate != null) { - EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate); + VoidSignal signal = new VoidSignal(Interop.StageSignal.Stage_EventProcessingFinishedSignal(stageCPtr), false); + signal?.Disconnect(_stageEventProcessingFinishedEventCallbackDelegate); + signal?.Dispose(); + _stageEventProcessingFinishedEventCallbackDelegate = null; } if (_stageContextLostEventCallbackDelegate != null) { - ContextLostSignal().Disconnect(_stageContextLostEventCallbackDelegate); + VoidSignal signal = new VoidSignal(Interop.StageSignal.Stage_ContextLostSignal(stageCPtr), false); + signal?.Disconnect(_stageContextLostEventCallbackDelegate); + signal?.Dispose(); + _stageContextLostEventCallbackDelegate = null; } if (_stageContextRegainedEventCallbackDelegate != null) { - ContextRegainedSignal().Disconnect(_stageContextRegainedEventCallbackDelegate); + VoidSignal signal = new VoidSignal(Interop.StageSignal.Stage_ContextRegainedSignal(stageCPtr), false); + signal?.Disconnect(_stageContextRegainedEventCallbackDelegate); + signal?.Dispose(); + _stageContextRegainedEventCallbackDelegate = null; } if (_stageSceneCreatedEventCallbackDelegate != null) { - SceneCreatedSignal().Disconnect(_stageSceneCreatedEventCallbackDelegate); + VoidSignal signal = new VoidSignal(Interop.StageSignal.Stage_SceneCreatedSignal(stageCPtr), false); + signal?.Disconnect(_stageSceneCreatedEventCallbackDelegate); + signal?.Dispose(); + _stageSceneCreatedEventCallbackDelegate = null; } if (_windowResizeEventCallback != null) { - ResizeSignal().Disconnect(_windowResizeEventCallback); + ResizeSignal signal = new ResizeSignal(Interop.Window.Window_ResizeSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_windowResizeEventCallback); + signal?.Dispose(); + _windowResizeEventCallback = null; } if (_windowFocusChangedEventCallback2 != null) { - WindowFocusChangedSignal().Disconnect(_windowFocusChangedEventCallback2); + WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(_windowFocusChangedEventCallback2); + signal?.Dispose(); + _windowFocusChangedEventCallback2 = null; } - if (transitionEffectSignal != null) + if (transitionEffectEventCallback != null) { - TransitionEffectEventSignal().Disconnect(transitionEffectEventCallback); + var signal = new WindowTransitionEffectSignal(this); + signal?.Disconnect(transitionEffectEventCallback); + signal?.Dispose(); + transitionEffectEventCallback = null; } - if (keyboardRepeatSettingsChangedSignal != null) + if (keyboardRepeatSettingsChangedEventCallback != null) { - KeyboardRepeatSettingsChangedEventSignal().Disconnect(keyboardRepeatSettingsChangedEventCallback); + var signal = new KeyboardRepeatSettingsChangedSignal(this); + signal?.Disconnect(keyboardRepeatSettingsChangedEventCallback); + signal?.Dispose(); + keyboardRepeatSettingsChangedEventCallback = null; + } + + if (VisibilityChangedEventCallback != null) + { + var signal = new WindowVisibilityChangedEvent(Interop.WindowVisibilityChangedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false); + signal?.Disconnect(VisibilityChangedEventCallback); + signal?.Dispose(); + VisibilityChangedEventCallback = null; } } @@ -1012,7 +1140,8 @@ namespace Tizen.NUI public bool Visibility { get => visibility; - set { + set + { visibility = value; } } @@ -1051,8 +1180,9 @@ namespace Tizen.NUI if (VisibilityChangedEventHandler == null) { VisibilityChangedEventCallback = OnVisibilityChanged; - VisibilityChangedEventSignal = new WindowVisibilityChangedEvent(this); - VisibilityChangedEventSignal.Connect(VisibilityChangedEventCallback); + var signal = new WindowVisibilityChangedEvent(Interop.WindowVisibilityChangedSignal.GetSignal(swigCPtr), false); + signal?.Connect(VisibilityChangedEventCallback); + signal?.Dispose(); } VisibilityChangedEventHandler += value; } @@ -1061,13 +1191,13 @@ namespace Tizen.NUI VisibilityChangedEventHandler -= value; if (VisibilityChangedEventHandler == null) { - if(VisibilityChangedEventSignal != null) + var signal = new WindowVisibilityChangedEvent(Interop.WindowVisibilityChangedSignal.GetSignal(swigCPtr), false); + if (signal?.Empty() == false) { - if(VisibilityChangedEventSignal.Empty() == false) - { - VisibilityChangedEventSignal.Disconnect(VisibilityChangedEventCallback); - } + signal?.Disconnect(VisibilityChangedEventCallback); + VisibilityChangedEventCallback = null; } + signal?.Dispose(); } } } @@ -1078,7 +1208,7 @@ namespace Tizen.NUI [EditorBrowsable(EditorBrowsableState.Never)] public void VisibiltyChangedSignalEmit(bool visibility) { - if(VisibilityChangedEventSignal == null) + if (VisibilityChangedEventSignal == null) { VisibilityChangedEventSignal = new WindowVisibilityChangedEvent(this); }