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();
}
}
}
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();
}
}
}
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();
}
}
}
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();
}
-
}
}
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();
}
}
}
/// This prevents the parent from interceping touch.
/// </summary>
[EditorBrowsable(EditorBrowsableState.Never)]
- public bool DisallowInterceptTouchEvent {get; set;}
+ public bool DisallowInterceptTouchEvent { get; set; }
/// <summary>
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();
}
}
}
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();
}
-
}
}
if (_wheelEventHandler == null)
{
_wheelEventCallback = OnWheelEvent;
- this.WheelEventSignal().Connect(_wheelEventCallback);
+ var signal = WheelEventSignal();
+ signal?.Connect(_wheelEventCallback);
+ signal?.Dispose();
}
_wheelEventHandler += value;
}
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;
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();
}
}
}
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();
}
}
}
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();
}
}
}
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();
}
}
}
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();
}
}
}
[EditorBrowsable(EditorBrowsableState.Never)]
internal void EmitBackKeyPressed()
{
- _backKeyPressed.Invoke(this,null);
+ _backKeyPressed.Invoke(this, null);
}
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();
}
}
}
private EventHandlerWithReturnType<object, WheelEventArgs, bool> 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()
{
{
ThemeManager.ThemeChangedInternal -= OnThemeChanged;
}
- if(widthConstraint != null)
+ if (widthConstraint != null)
{
widthConstraint.Remove();
widthConstraint.Dispose();
}
- if(heightConstraint != null)
+ if (heightConstraint != null)
{
heightConstraint.Remove();
heightConstraint.Dispose();
[EditorBrowsable(EditorBrowsableState.Never)]
protected virtual bool HandleControlStateOnTouch(Touch touch)
{
- switch(touch.GetState(0))
+ switch (touch.GetState(0))
{
case PointStateType.Down:
ControlState += ControlState.Pressed;
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)
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)
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();
}
}
}
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();
}
}
}
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();
}
}
}
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();
}
}
}
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();
}
}
}
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();
}
}
+
}
/// <summary>
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();
}
}
}
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();
}
}
+
}
/// <summary>
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();
}
}
}
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();
}
}
}
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();
}
}
}
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();
}
}
}
/// <since_tizen> 5 </since_tizen>
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;
}
}
public bool Visibility
{
get => visibility;
- set {
+ set
+ {
visibility = value;
}
}
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;
}
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();
}
}
}
[EditorBrowsable(EditorBrowsableState.Never)]
public void VisibiltyChangedSignalEmit(bool visibility)
{
- if(VisibilityChangedEventSignal == null)
+ if (VisibilityChangedEventSignal == null)
{
VisibilityChangedEventSignal = new WindowVisibilityChangedEvent(this);
}
projects / platform / core / csapi / tizenfx.git / commitdiff