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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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()
{
}
}
+ /// <summary>
+ /// TouchArea can expand the view's touchable area.<br/>
+ /// If you set the TouchAreaOffset on an view, when you touch the view, the touch area is used rather than the size of the view.<br/>
+ /// This is based on the top left x, y coordinates.<br/>
+ /// example) <br/>
+ /// view.Size = new Size(100, 100);<br/>
+ /// view.TouchAreaOffset = new Offset(-10, 20, 30, -40); // left, right, bottom, top <br/>
+ /// then touch area is 130x170.<br/>
+ /// this is view.width + TouchAreaOffset.right - TouchAreaOffset.left and view.height + TouchAreaOffset.bottom - TouchAreaOffset.top <br/>
+ /// +---------------------+ <br/>
+ /// | ^ | <br/>
+ /// | | | <br/>
+ /// | | -40 | <br/>
+ /// | | | <br/>
+ /// | | | <br/>
+ /// | +----+----+ | <br/>
+ /// | | | | <br/>
+ /// | -10| | 20 | <br/>
+ /// |<---+ +----->| <br/>
+ /// | | | | <br/>
+ /// | | | | <br/>
+ /// | +----+----+ | <br/>
+ /// | | | <br/>
+ /// | | 30 | <br/>
+ /// | | | <br/>
+ /// | v | <br/>
+ /// +---------------------+ <br/>
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public Offset TouchAreaOffset
+ {
+ get
+ {
+ Interop.ActorInternal.GetTouchAreaOffset(SwigCPtr, out int left, out int right, out int bottom, out int top);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return new Offset(left, right, bottom, top);
+ }
+ set
+ {
+ Interop.ActorInternal.SetTouchAreaOffset(SwigCPtr, value.Left, value.Right, value.Bottom, value.Top);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+ }
+
}
}
projects / platform / core / csapi / tizenfx.git / blobdiff