/*
- * Copyright(c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright(c) 2020 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*/
using System;
+using System.ComponentModel;
using System.Runtime.InteropServices;
+using Tizen.NUI.Components;
namespace Tizen.NUI.BaseComponents
{
private WheelEventCallbackType _wheelEventCallback;
private EventHandlerWithReturnType<object, KeyEventArgs, bool> _keyEventHandler;
private KeyCallbackType _keyCallback;
+ private EventHandlerWithReturnType<object, TouchEventArgs, bool> _interceptTouchDataEventHandler;
+ private TouchDataCallbackType _interceptTouchDataCallback;
private EventHandlerWithReturnType<object, TouchEventArgs, bool> _touchDataEventHandler;
private TouchDataCallbackType _touchDataCallback;
private EventHandlerWithReturnType<object, HoverEventArgs, bool> _hoverEventHandler;
private void SendViewAddedEventToWindow(IntPtr data)
{
- Window.Instance?.SendViewAdded(this);
+ NUIApplication.GetDefaultWindow()?.SendViewAdded(this);
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
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();
}
+ }
+ }
+ /// <summary>
+ /// An event for the touched signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
+ /// The touched signal is emitted when the touch input is received.<br />
+ /// This can receive touch events before child. <br />
+ /// If it returns false, the child can receive the touch event. If it returns true, the touch event is intercepted. So child cannot receive touch event.<br />
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandlerWithReturnType<object, TouchEventArgs, bool> InterceptTouchEvent
+ {
+ add
+ {
+ if (_interceptTouchDataEventHandler == null)
+ {
+ _interceptTouchDataCallback = OnInterceptTouch;
+ var signal = InterceptTouchSignal();
+ signal?.Connect(_interceptTouchDataCallback);
+ signal?.Dispose();
+ }
+ _interceptTouchDataEventHandler += value;
+ }
+ remove
+ {
+ _interceptTouchDataEventHandler -= value;
+ if (_interceptTouchDataEventHandler == null)
+ {
+ var signal = InterceptTouchSignal();
+ if (signal?.Empty() == false)
+ {
+ signal?.Disconnect(_interceptTouchDataCallback);
+ _interceptTouchDataCallback = null;
+ }
+ signal?.Dispose();
+ }
}
}
/// <summary>
+ /// If child view doesn't want the parent's view to intercept the touch, you can set it to true.
+ /// for example :
+ /// parent.Add(child);
+ /// parent.InterceptTouchEvent += OnInterceptTouchEvent;
+ /// View view = child.GetParent() as View;
+ /// view.DisallowInterceptTouchEvent = true;
+ /// This prevents the parent from interceping touch.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public bool DisallowInterceptTouchEvent { get; set; }
+
+
+ /// <summary>
/// An event for the touched signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
/// The touched signal is emitted when the touch input is received.<br />
/// </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;
- }
+ if (WindowWheelEventHandler == null)
+ {
+ NUIApplication.GetDefaultWindow().WheelEvent += OnWindowWheelEvent;
+ }
+ 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 (WindowWheelEventHandler == null)
+ {
+ NUIApplication.GetDefaultWindow().WheelEvent -= OnWindowWheelEvent;
+ }
}
}
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();
}
}
}
+ private EventHandler _backKeyPressed;
+
+ /// <summary>
+ /// An event for getting notice when physical back key is pressed.<br />
+ /// This event is emitted BackKey is up.<br />
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler BackKeyPressed
+ {
+ add
+ {
+ _backKeyPressed += value;
+ BackKeyManager.Instance.Subscriber.Add(this);
+ }
+
+ remove
+ {
+ BackKeyManager.Instance.Subscriber.Remove(this);
+ _backKeyPressed -= value;
+ }
+ }
+
+ /// <summary>
+ /// Function for emitting BackKeyPressed event outside of View instance
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal void EmitBackKeyPressed()
+ {
+ _backKeyPressed.Invoke(this, null);
+ }
+
+
internal event EventHandler<BackgroundResourceLoadedEventArgs> BackgroundResourceLoaded
{
add
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();
}
}
}
+ internal TouchDataSignal InterceptTouchSignal()
+ {
+ TouchDataSignal ret = new TouchDataSignal(Interop.ActorSignal.Actor_InterceptTouchSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
internal TouchDataSignal TouchSignal()
{
TouchDataSignal ret = new TouchDataSignal(Interop.ActorSignal.Actor_TouchSignal(swigCPtr), false);
internal ViewSignal OnWindowSignal()
{
- ViewSignal ret = new ViewSignal(Interop.ActorSignal.Actor_OnStageSignal(swigCPtr), false);
+ ViewSignal ret = new ViewSignal(Interop.ActorSignal.Actor_OnSceneSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
internal ViewSignal OffWindowSignal()
{
- ViewSignal ret = new ViewSignal(Interop.ActorSignal.Actor_OffStageSignal(swigCPtr), false);
+ ViewSignal ret = new ViewSignal(Interop.ActorSignal.Actor_OffSceneSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
return ret;
}
- private void OnSize2DChanged(int width, int height)
+ private void OnSize2DChanged(int? width, int? height)
{
- Size2D = new Size2D(width, height);
+ if (width != null)
+ {
+ Tizen.NUI.Object.SetProperty(this.swigCPtr, View.Property.SIZE_WIDTH, new Tizen.NUI.PropertyValue((float)width));
+ }
+ if (height != null)
+ {
+ Tizen.NUI.Object.SetProperty(this.swigCPtr, View.Property.SIZE_HEIGHT, new Tizen.NUI.PropertyValue((float)height));
+ }
}
- private void OnMinimumSizeChanged(int width, int height)
+ private void OnMinimumSizeChanged(int? width, int? height)
{
- MinimumSize = new Size2D(width, height);
+ if (width != null && height != null)
+ {
+ MinimumSize = new Size2D((int)width, (int)height);
+ }
+ else if (width != null && height == null)
+ {
+ MinimumSize = new Size2D((int)width, (int)this.GetMinimumSize().Height);
+ }
+ else if (width == null && height != null)
+ {
+ MinimumSize = new Size2D((int)this.GetMinimumSize().Width, (int)height);
+ }
+ else
+ {
+ //both are null, do nothing.
+ }
}
- private void OnMaximumSizeChanged(int width, int height)
+ private void OnMaximumSizeChanged(int? width, int? height)
{
- MaximumSize = new Size2D(width, height);
+ if (width != null && height != null)
+ {
+ MaximumSize = new Size2D((int)width, (int)height);
+ }
+ else if (width != null && height == null)
+ {
+ MaximumSize = new Size2D((int)width, (int)this.GetMaximumSize().Height);
+ }
+ else if (width == null && height != null)
+ {
+ MaximumSize = new Size2D((int)this.GetMaximumSize().Width, (int)height);
+ }
+ else
+ {
+ //both are null, do nothing.
+ }
}
private void OnPosition2DChanged(int x, int y)
Position2D = new Position2D(x, y);
}
- private void OnSizeChanged(float width, float height, float depth)
+ private void OnSizeChanged(float? width, float? height, float? depth)
{
- Size = new Size(width, height, depth);
+ if (width != null)
+ {
+ Tizen.NUI.Object.SetProperty(this.swigCPtr, View.Property.SIZE_WIDTH, new Tizen.NUI.PropertyValue((float)width));
+ }
+ if (height != null)
+ {
+ Tizen.NUI.Object.SetProperty(this.swigCPtr, View.Property.SIZE_HEIGHT, new Tizen.NUI.PropertyValue((float)height));
+ }
+ if (depth != null)
+ {
+ Tizen.NUI.Object.SetProperty(this.swigCPtr, View.Property.SIZE_DEPTH, new Tizen.NUI.PropertyValue((float)depth));
+ }
}
private void OnPositionChanged(float x, float y, float z)
PivotPoint = new Position(x, y, z);
}
+ private void OnImageShadowChanged(ShadowBase instance)
+ {
+ ImageShadow = (ImageShadow)instance;
+ }
+
+ private void OnBoxShadowChanged(ShadowBase instance)
+ {
+ BoxShadow = (Shadow)instance;
+ }
+
+ private void OnBackgroundImageBorderChanged(int left, int right, int bottom, int top)
+ {
+ BackgroundImageBorder = new Rectangle(left, right, bottom, top);
+ }
+
private void OnKeyInputFocusGained(IntPtr view)
{
if (_keyInputFocusGainedEventHandler != null)
}
// Callback for View TouchSignal
+ private bool OnInterceptTouch(IntPtr view, IntPtr touchData)
+ {
+ if (touchData == global::System.IntPtr.Zero)
+ {
+ NUILog.Error("touchData should not be null!");
+ return true;
+ }
+
+ // DisallowInterceptTouchEvent prevents the parent from intercepting touch.
+ if (DisallowInterceptTouchEvent)
+ {
+ return false;
+ }
+
+ TouchEventArgs e = new TouchEventArgs();
+
+ e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
+
+ bool consumed = false;
+
+ if (_interceptTouchDataEventHandler != null)
+ {
+ consumed = _interceptTouchDataEventHandler(this, e);
+ }
+
+ return consumed;
+ }
+
+ // Callback for View TouchSignal
private bool OnTouch(IntPtr view, IntPtr touchData)
{
if (touchData == global::System.IntPtr.Zero)
e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
+ bool consumed = false;
+
if (_touchDataEventHandler != null)
{
- return _touchDataEventHandler(this, e);
+ consumed = _touchDataEventHandler(this, e);
}
- return false;
+
+ if (enableControlState && !consumed)
+ {
+ consumed = HandleControlStateOnTouch(e.Touch);
+ }
+
+ return consumed;
}
// Callback for View Hover signal
}
}
}
+
+ /// <summary>
+ /// The class represents the information of the situation where the View's control state changes.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public class ControlStateChangedEventArgs : EventArgs
+ {
+ /// <summary>
+ /// Create an instance with mandatory fields.
+ /// </summary>
+ /// <param name="previousState">The previous control state.</param>
+ /// <param name="currentState">The current control state.</param>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public ControlStateChangedEventArgs(ControlState previousState, ControlState currentState)
+ {
+ PreviousState = previousState;
+ CurrentState = currentState;
+ }
+
+ /// <summary>
+ /// The previous control state.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public ControlState PreviousState { get; }
+
+ /// <summary>
+ /// The current control state.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public ControlState CurrentState { get; }
+ }
+
+ private EventHandlerWithReturnType<object, WheelEventArgs, bool> WindowWheelEventHandler;
+ private void OnWindowWheelEvent(object sender, Window.WheelEventArgs e)
+ {
+ if (e != null)
+ {
+ if (e.Wheel.Type == Wheel.WheelType.CustomWheel)
+ {
+ var arg = new WheelEventArgs()
+ {
+ Wheel = e.Wheel,
+ };
+ WindowWheelEventHandler?.Invoke(this, arg);
+ }
+ }
+ }
+
+ /// <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