private MovedEventCallbackType movedEventCallback;
private OrientationChangedEventCallbackType orientationChangedEventCallback;
private KeyboardRepeatSettingsChangedEventCallbackType keyboardRepeatSettingsChangedEventCallback;
- private ViewAddedEventCallbackType viewAddedEventCallback;
private AuxiliaryMessageEventCallbackType auxiliaryMessageEventCallback;
+ private WindowMouseInOutEventCallbackType windowMouseInOutEventCallback;
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void WindowFocusChangedEventCallbackType(IntPtr window, bool focusGained);
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void KeyboardRepeatSettingsChangedEventCallbackType();
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void ViewAddedEventCallbackType(IntPtr view);
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AuxiliaryMessageEventCallbackType(IntPtr kData, IntPtr vData, IntPtr optionsArray);
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool InterceptKeyEventDelegateType(IntPtr arg1);
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ private delegate void WindowMouseInOutEventCallbackType(IntPtr window, IntPtr mouseEvent);
/// <summary>
/// FocusChanged event.
{
windowFocusChangedEventCallback = OnWindowFocusedChanged;
using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
- signal?.Connect(windowFocusChangedEventCallback);
+ signal.Ensure()?.Connect(windowFocusChangedEventCallback);
}
windowFocusChangedEventHandler += value;
}
if (windowFocusChangedEventHandler == null && windowFocusChangedEventCallback != null)
{
using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
- signal?.Disconnect(windowFocusChangedEventCallback);
- if (signal?.Empty() == true)
- {
- windowFocusChangedEventCallback = null;
- }
+ signal.Ensure()?.Disconnect(windowFocusChangedEventCallback);
+ windowFocusChangedEventCallback = null;
}
}
}
if (rootLayerTouchDataEventHandler == null)
{
rootLayerTouchDataCallback = OnWindowTouch;
- using TouchDataSignal signal = new TouchDataSignal(Interop.ActorSignal.ActorTouchSignal(Layer.getCPtr(GetRootLayer())), false);
- signal?.Connect(rootLayerTouchDataCallback);
+ Interop.ActorSignal.TouchConnect(Layer.getCPtr(GetRootLayer()), rootLayerTouchDataCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
}
rootLayerTouchDataEventHandler += value;
}
rootLayerTouchDataEventHandler -= value;
if (rootLayerTouchDataEventHandler == null && rootLayerTouchDataCallback != null)
{
- using TouchDataSignal signal = new TouchDataSignal(Interop.ActorSignal.ActorTouchSignal(Layer.getCPtr(GetRootLayer())), false);
- signal?.Disconnect(rootLayerTouchDataCallback);
- if (signal?.Empty() == true)
- {
- rootLayerTouchDataCallback = null;
- }
+ Interop.ActorSignal.TouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerTouchDataCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ rootLayerTouchDataCallback = null;
}
}
}
if (rootLayerInterceptTouchDataEventHandler == null)
{
rootLayerInterceptTouchDataCallback = OnWindowInterceptTouch;
- using TouchDataSignal signal = new TouchDataSignal(Interop.ActorSignal.ActorInterceptTouchSignal(Layer.getCPtr(GetRootLayer())), false);
- signal?.Connect(rootLayerInterceptTouchDataCallback);
+ Interop.ActorSignal.InterceptTouchConnect(Layer.getCPtr(GetRootLayer()), rootLayerInterceptTouchDataCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
}
rootLayerInterceptTouchDataEventHandler += value;
}
rootLayerInterceptTouchDataEventHandler -= value;
if (rootLayerInterceptTouchDataEventHandler == null && rootLayerInterceptTouchDataCallback != null)
{
- using TouchDataSignal signal = new TouchDataSignal(Interop.ActorSignal.ActorInterceptTouchSignal(Layer.getCPtr(GetRootLayer())), false);
- signal?.Disconnect(rootLayerInterceptTouchDataCallback);
- if (signal?.Empty() == true)
- {
- rootLayerInterceptTouchDataCallback = null;
- }
+ Interop.ActorSignal.InterceptTouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerInterceptTouchDataCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ rootLayerInterceptTouchDataCallback = null;
}
}
}
if (stageWheelHandler == null)
{
wheelEventCallback = OnStageWheel;
- using WheelSignal signal = new WheelSignal(Interop.ActorSignal.ActorWheelEventSignal(Layer.getCPtr(this.GetRootLayer())), false);
- signal?.Connect(wheelEventCallback);
+ Interop.ActorSignal.WheelEventConnect(Layer.getCPtr(GetRootLayer()), wheelEventCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
}
stageWheelHandler += value;
{
DetentEventCallback = OnDetentEvent;
using StageWheelSignal signal = new StageWheelSignal(Interop.StageSignal.WheelEventSignal(stageCPtr), false);
- signal?.Connect(DetentEventCallback);
+ signal.Ensure()?.Connect(DetentEventCallback);
}
DetentEventHandler += value;
}
stageWheelHandler -= value;
if (stageWheelHandler == null && wheelEventCallback != null)
{
- using WheelSignal signal = new WheelSignal(Interop.ActorSignal.ActorWheelEventSignal(Layer.getCPtr(this.GetRootLayer())), false);
- signal?.Disconnect(wheelEventCallback);
- if (signal?.Empty() == true)
- {
- wheelEventCallback = null;
- }
+ Interop.ActorSignal.WheelEventDisconnect(Layer.getCPtr(GetRootLayer()), wheelEventCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ wheelEventCallback = null;
}
DetentEventHandler -= value;
if (DetentEventHandler == null && DetentEventCallback != null)
{
using StageWheelSignal signal = new StageWheelSignal(Interop.StageSignal.WheelEventSignal(stageCPtr), false);
- signal?.Disconnect(DetentEventCallback);
- if (signal?.Empty() == true)
- {
- DetentEventCallback = null;
- }
+ signal.Ensure()?.Disconnect(DetentEventCallback);
+ DetentEventCallback = null;
}
}
}
{
stageKeyCallbackDelegate = OnStageKey;
using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(SwigCPtr), false);
- signal?.Connect(stageKeyCallbackDelegate);
+ signal.Ensure()?.Connect(stageKeyCallbackDelegate);
}
stageKeyHandler += value;
}
if (stageKeyHandler == null && stageKeyCallbackDelegate != null)
{
using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(SwigCPtr), false);
- signal?.Disconnect(stageKeyCallbackDelegate);
- if (signal?.Empty() == true)
- {
- stageKeyCallbackDelegate = null;
- }
+ signal.Ensure()?.Disconnect(stageKeyCallbackDelegate);
+ stageKeyCallbackDelegate = null;
}
}
}
{
stageInterceptKeyCallbackDelegate = OnStageInterceptKey;
using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(SwigCPtr), false);
- signal?.Connect(stageInterceptKeyCallbackDelegate);
+ signal.Ensure()?.Connect(stageInterceptKeyCallbackDelegate);
}
stageInterceptKeyHandler += value;
}
if (stageInterceptKeyHandler == null && stageInterceptKeyCallbackDelegate != null)
{
using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(SwigCPtr), false);
- signal?.Disconnect(stageInterceptKeyCallbackDelegate);
- if (signal?.Empty() == true)
- {
- stageInterceptKeyCallbackDelegate = null;
- }
+ signal.Ensure()?.Disconnect(stageInterceptKeyCallbackDelegate);
+ stageInterceptKeyCallbackDelegate = null;
}
}
}
{
windowResizeEventCallback = OnResized;
using ResizeSignal signal = new ResizeSignal(Interop.Window.ResizeSignal(SwigCPtr), false);
- signal?.Connect(windowResizeEventCallback);
+ signal.Ensure()?.Connect(windowResizeEventCallback);
}
windowResizeEventHandler += value;
if (windowResizeEventHandler == null && windowResizeEventCallback != null)
{
using ResizeSignal signal = new ResizeSignal(Interop.Window.ResizeSignal(SwigCPtr), false);
- signal?.Disconnect(windowResizeEventCallback);
- if (signal?.Empty() == true)
- {
- windowResizeEventCallback = null;
- }
+ signal.Ensure()?.Disconnect(windowResizeEventCallback);
+ windowResizeEventCallback = null;
}
}
}
{
windowFocusChangedEventCallback2 = OnWindowFocusedChanged2;
using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
- signal?.Connect(windowFocusChangedEventCallback2);
+ signal.Ensure()?.Connect(windowFocusChangedEventCallback2);
}
windowFocusChangedEventHandler2 += value;
}
if (windowFocusChangedEventHandler2 == null && windowFocusChangedEventCallback2 != null)
{
using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
- signal?.Disconnect(windowFocusChangedEventCallback2);
- if (signal?.Empty() == true)
- {
- windowFocusChangedEventCallback2 = null;
- }
+ signal.Ensure()?.Disconnect(windowFocusChangedEventCallback2);
+ windowFocusChangedEventCallback2 = null;
}
}
}
{
transitionEffectEventCallback = OnTransitionEffect;
using WindowTransitionEffectSignal signal = new WindowTransitionEffectSignal(Interop.WindowTransitionEffectSignal.GetSignal(SwigCPtr), false);
- signal?.Connect(transitionEffectEventCallback);
+ signal.Ensure()?.Connect(transitionEffectEventCallback);
}
transitionEffectHandler += value;
}
if (transitionEffectHandler == null && transitionEffectEventCallback != null)
{
using WindowTransitionEffectSignal signal = new WindowTransitionEffectSignal(Interop.WindowTransitionEffectSignal.GetSignal(SwigCPtr), false);
- signal?.Disconnect(transitionEffectEventCallback);
- if (signal?.Empty() == true)
- {
- transitionEffectEventCallback = null;
- }
+ signal.Ensure()?.Disconnect(transitionEffectEventCallback);
+ transitionEffectEventCallback = null;
}
}
}
{
movedEventCallback = OnMoved;
using WindowMovedSignal signal = new WindowMovedSignal(Interop.WindowMovedSignal.GetSignal(SwigCPtr), false);
- signal?.Connect(movedEventCallback);
+ signal.Ensure()?.Connect(movedEventCallback);
}
movedHandler += value;
}
if (movedHandler == null && movedEventCallback != null)
{
using WindowMovedSignal signal = new WindowMovedSignal(Interop.WindowMovedSignal.GetSignal(SwigCPtr), false);
- signal?.Disconnect(movedEventCallback);
- if (signal?.Empty() == true)
- {
- movedEventCallback = null;
- }
+ signal.Ensure()?.Disconnect(movedEventCallback);
+ movedEventCallback = null;
}
}
}
{
orientationChangedEventCallback = OnOrientationChanged;
using WindowOrientationChangedSignal signal = new WindowOrientationChangedSignal(Interop.WindowOrientationChangedSignal.GetSignal(SwigCPtr), false);
- signal?.Connect(orientationChangedEventCallback);
+ signal.Ensure()?.Connect(orientationChangedEventCallback);
}
orientationChangedHandler += value;
}
if (orientationChangedHandler == null && orientationChangedEventCallback != null)
{
using WindowOrientationChangedSignal signal = new WindowOrientationChangedSignal(Interop.WindowOrientationChangedSignal.GetSignal(SwigCPtr), false);
- signal?.Disconnect(orientationChangedEventCallback);
- if (signal?.Empty() == true)
- {
- orientationChangedEventCallback = null;
- }
+ signal.Ensure()?.Disconnect(orientationChangedEventCallback);
+ orientationChangedEventCallback = null;
}
}
}
{
keyboardRepeatSettingsChangedEventCallback = OnKeyboardRepeatSettingsChanged;
using KeyboardRepeatSettingsChangedSignal signal = new KeyboardRepeatSettingsChangedSignal(Interop.KeyboardRepeatSettingsChangedSignal.GetSignal(SwigCPtr), false);
- signal?.Connect(keyboardRepeatSettingsChangedEventCallback);
+ signal.Ensure()?.Connect(keyboardRepeatSettingsChangedEventCallback);
}
keyboardRepeatSettingsChangedHandler += value;
}
if (keyboardRepeatSettingsChangedHandler == null && keyboardRepeatSettingsChangedEventCallback != null)
{
using KeyboardRepeatSettingsChangedSignal signal = new KeyboardRepeatSettingsChangedSignal(Interop.KeyboardRepeatSettingsChangedSignal.GetSignal(SwigCPtr), false);
- signal?.Disconnect(keyboardRepeatSettingsChangedEventCallback);
- if (signal?.Empty() == true)
- {
- keyboardRepeatSettingsChangedEventCallback = null;
- }
+ 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 (viewAddedHandler == null)
+ if (windowMouseInOutEventHandler == null)
{
- viewAddedEventCallback = OnViewAdded;
- using WindowViewAddedSignal signal = new WindowViewAddedSignal(Interop.WindowViewAddedSignal.GetSignal(SwigCPtr), false);
- signal?.Connect(viewAddedEventCallback);
+ windowMouseInOutEventCallback = OnWindowMouseInOutEvent;
+ using WindowMouseInOutEventSignal signal = new WindowMouseInOutEventSignal(Interop.WindowMouseInOutEventSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Connect(windowMouseInOutEventCallback);
}
- viewAddedHandler += value;
+ windowMouseInOutEventHandler += value;
}
remove
{
- viewAddedHandler -= value;
- if (viewAddedHandler == null && viewAddedEventCallback != null)
+ windowMouseInOutEventHandler -= value;
+ if (windowMouseInOutEventHandler == null && windowMouseInOutEventCallback != null)
{
- using WindowViewAddedSignal signal = new WindowViewAddedSignal(Interop.WindowViewAddedSignal.GetSignal(SwigCPtr), false);
- signal?.Disconnect(viewAddedEventCallback);
- if (signal?.Empty() == true)
- {
- viewAddedEventCallback = null;
- }
+ using WindowMouseInOutEventSignal signal = new WindowMouseInOutEventSignal(Interop.WindowMouseInOutEventSignal.GetSignal(SwigCPtr), false);
+ signal.Ensure()?.Disconnect(windowMouseInOutEventCallback);
+ windowMouseInOutEventCallback = null;
}
}
}
private event EventHandler<WindowMovedEventArgs> movedHandler;
private event EventHandler<WindowOrientationChangedEventArgs> orientationChangedHandler;
private event EventHandler keyboardRepeatSettingsChangedHandler;
- private event EventHandler viewAddedHandler;
private event EventHandler<AuxiliaryMessageEventArgs> auxiliaryMessageEventHandler;
+ private event EventHandler<MouseInOutEventArgs> windowMouseInOutEventHandler;
internal event EventHandler EventProcessingFinished
{
stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished;
using VoidSignal signal = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
- signal?.Connect(stageEventProcessingFinishedEventCallbackDelegate);
+ signal.Ensure()?.Connect(stageEventProcessingFinishedEventCallbackDelegate);
}
stageEventProcessingFinishedEventHandler += value;
}
if (stageEventProcessingFinishedEventHandler == null && stageEventProcessingFinishedEventCallbackDelegate != null)
{
using VoidSignal signal = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
- signal?.Disconnect(stageEventProcessingFinishedEventCallbackDelegate);
- if (signal?.Empty() == true)
- {
- stageEventProcessingFinishedEventCallbackDelegate = null;
- }
-
+ signal.Ensure()?.Disconnect(stageEventProcessingFinishedEventCallbackDelegate);
+ stageEventProcessingFinishedEventCallbackDelegate = null;
}
}
}
{
stageContextLostEventCallbackDelegate = OnContextLost;
using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
- signal?.Connect(stageContextLostEventCallbackDelegate);
+ signal.Ensure()?.Connect(stageContextLostEventCallbackDelegate);
}
stageContextLostEventHandler += value;
}
if (stageContextLostEventHandler == null && stageContextLostEventCallbackDelegate != null)
{
using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
- signal?.Disconnect(stageContextLostEventCallbackDelegate);
- if (signal?.Empty() == true)
- {
- stageContextLostEventCallbackDelegate = null;
- }
+ signal.Ensure()?.Disconnect(stageContextLostEventCallbackDelegate);
+ stageContextLostEventCallbackDelegate = null;
}
}
}
{
stageContextRegainedEventCallbackDelegate = OnContextRegained;
using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
- signal?.Connect(stageContextRegainedEventCallbackDelegate);
+ signal.Ensure()?.Connect(stageContextRegainedEventCallbackDelegate);
}
stageContextRegainedEventHandler += value;
}
if (stageContextRegainedEventHandler == null && stageContextRegainedEventCallbackDelegate != null)
{
using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
- signal?.Disconnect(stageContextRegainedEventCallbackDelegate);
- if (signal?.Empty() == true)
- {
- stageContextRegainedEventCallbackDelegate = null;
- }
+ signal.Ensure()?.Disconnect(stageContextRegainedEventCallbackDelegate);
+ stageContextRegainedEventCallbackDelegate = null;
}
}
}
{
stageSceneCreatedEventCallbackDelegate = OnSceneCreated;
using VoidSignal signal = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
- signal?.Connect(stageSceneCreatedEventCallbackDelegate);
+ signal.Ensure()?.Connect(stageSceneCreatedEventCallbackDelegate);
}
stageSceneCreatedEventHandler += value;
}
if (stageSceneCreatedEventHandler == null && stageSceneCreatedEventCallbackDelegate != null)
{
using VoidSignal signal = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
- signal?.Disconnect(stageSceneCreatedEventCallbackDelegate);
- if (signal?.Empty() == true)
- {
- stageSceneCreatedEventCallbackDelegate = null;
- }
+ signal.Ensure()?.Disconnect(stageSceneCreatedEventCallbackDelegate);
+ stageSceneCreatedEventCallbackDelegate = null;
}
}
}
if (rootLayerTouchDataCallback != null)
{
- using TouchDataSignal signal = new TouchDataSignal(Interop.ActorSignal.ActorTouchSignal(Layer.getCPtr(GetRootLayer())), false);
- signal?.Disconnect(rootLayerTouchDataCallback);
+ Interop.ActorSignal.TouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerTouchDataCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
rootLayerTouchDataCallback = null;
}
if (rootLayerInterceptTouchDataCallback != null)
{
- using TouchDataSignal signal = new TouchDataSignal(Interop.ActorSignal.ActorInterceptTouchSignal(Layer.getCPtr(GetRootLayer())), false);
- signal?.Disconnect(rootLayerInterceptTouchDataCallback);
+ Interop.ActorSignal.InterceptTouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerInterceptTouchDataCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
rootLayerInterceptTouchDataCallback = null;
}
if (wheelEventCallback != null)
{
- using WheelSignal signal = new WheelSignal(Interop.ActorSignal.ActorWheelEventSignal(Layer.getCPtr(this.GetRootLayer())), false);
- signal?.Disconnect(wheelEventCallback);
+ Interop.ActorSignal.WheelEventDisconnect(Layer.getCPtr(GetRootLayer()), wheelEventCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExists();
wheelEventCallback = null;
}
keyboardRepeatSettingsChangedEventCallback = null;
}
- if (viewAddedEventCallback != null)
- {
- using WindowViewAddedSignal signal = new WindowViewAddedSignal(Interop.WindowViewAddedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
- signal?.Disconnect(viewAddedEventCallback);
- viewAddedEventCallback = null;
- }
-
if (auxiliaryMessageEventCallback != null)
{
using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(GetBaseHandleCPtrHandleRef), false);
signal?.Disconnect(AccessibilityHighlightEventCallback);
AccessibilityHighlightEventCallback = null;
}
+
+ if (windowMouseInOutEventCallback != null)
+ {
+ using WindowMouseInOutEventSignal signal = new WindowMouseInOutEventSignal(Interop.WindowMouseInOutEventSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
+ signal?.Disconnect(windowMouseInOutEventCallback);
+ windowMouseInOutEventCallback = null;
+ }
+
}
private void OnWindowFocusedChanged(IntPtr window, bool focusGained)
return;
}
- private void OnViewAdded(IntPtr view)
+ private void OnWindowMouseInOutEvent(IntPtr view, IntPtr mouseEvent)
{
- if (view == global::System.IntPtr.Zero)
+ if (mouseEvent == global::System.IntPtr.Zero)
{
+ NUILog.Error("mouseEvent should not be null!");
return;
}
- View addedView = Extensions.GetInstanceSafely<View>(this, view);
- if (addedView)
+ if (windowMouseInOutEventHandler != null)
{
- // Note : object sender is View, not window it selfs (Since tizen_5.5, Pull Request #705)
- viewAddedHandler?.Invoke(view, EventArgs.Empty);
+ MouseInOutEventArgs e = new MouseInOutEventArgs();
+ e.MouseInOut = Tizen.NUI.MouseInOut.GetMouseInOutFromPtr(mouseEvent);
+ windowMouseInOutEventHandler(this, e);
}
- return;
}
/// <summary>
}
/// <summary>
+ /// MouseInOut evnet arguments.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public class MouseInOutEventArgs : EventArgs
+ {
+ private MouseInOut mouseEvent;
+
+ /// <summary>
+ /// MouseInOut event.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public MouseInOut MouseInOut
+ {
+ get
+ {
+ return mouseEvent;
+ }
+ set
+ {
+ mouseEvent = value;
+ }
+ }
+ }
+
+ /// <summary>
/// Do not use this, that will be deprecated.
/// </summary>
/// <since_tizen> 3 </since_tizen>
{
VisibilityChangedEventCallback = OnVisibilityChanged;
using WindowVisibilityChangedEvent signal = new WindowVisibilityChangedEvent(Interop.WindowVisibilityChangedSignal.GetSignal(Window.getCPtr(this)), false);
- signal?.Connect(VisibilityChangedEventCallback);
+ signal.Ensure()?.Connect(VisibilityChangedEventCallback);
}
VisibilityChangedEventHandler += value;
}
if (VisibilityChangedEventHandler == null && VisibilityChangedEventCallback != null)
{
using WindowVisibilityChangedEvent signal = new WindowVisibilityChangedEvent(Interop.WindowVisibilityChangedSignal.GetSignal(Window.getCPtr(this)), false);
- signal?.Disconnect(VisibilityChangedEventCallback);
- if (signal?.Empty() == true)
- {
- VisibilityChangedEventCallback = null;
- }
+ signal.Ensure()?.Disconnect(VisibilityChangedEventCallback);
+ VisibilityChangedEventCallback = null;
}
}
}
{
auxiliaryMessageEventCallback = OnAuxiliaryMessage;
using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(SwigCPtr), false);
- signal?.Connect(auxiliaryMessageEventCallback);
+ signal.Ensure()?.Connect(auxiliaryMessageEventCallback);
}
auxiliaryMessageEventHandler += value;
}
if (auxiliaryMessageEventHandler == null && auxiliaryMessageEventCallback != null)
{
using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(SwigCPtr), false);
- signal?.Disconnect(auxiliaryMessageEventCallback);
- if (signal?.Empty() == true)
- {
- auxiliaryMessageEventCallback = null;
- }
+ signal.Ensure()?.Disconnect(auxiliaryMessageEventCallback);
+ auxiliaryMessageEventCallback = null;
}
}
}
{
AccessibilityHighlightEventCallback = OnAccessibilityHighlight;
using WindowAccessibilityHighlightEvent signal = new WindowAccessibilityHighlightEvent(Interop.WindowAccessibilityHighlightSignal.GetSignal(SwigCPtr), false);
- signal?.Connect(AccessibilityHighlightEventCallback);
+ signal.Ensure()?.Connect(AccessibilityHighlightEventCallback);
}
AccessibilityHighlightEventHandler += value;
}
if (AccessibilityHighlightEventHandler == null && AccessibilityHighlightEventCallback != null)
{
using WindowAccessibilityHighlightEvent signal = new WindowAccessibilityHighlightEvent(Interop.WindowAccessibilityHighlightSignal.GetSignal(SwigCPtr), false);
- signal?.Disconnect(AccessibilityHighlightEventCallback);
- if (signal?.Empty() == true)
- {
- AccessibilityHighlightEventCallback = null;
- }
+ signal.Ensure()?.Disconnect(AccessibilityHighlightEventCallback);
+ AccessibilityHighlightEventCallback = null;
}
}
}
projects / platform / core / csapi / tizenfx.git / blobdiff