using System;
using System.Runtime.InteropServices;
+
+
/// <summary>
/// View is the base class for all views.
/// </summary>
/// Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
/// KeyPressed signal is emitted when key event is received.<br>
/// </summary>
- public event EventHandlerWithReturnType<object, KeyEventArgs, bool> Key
+ public event EventHandlerWithReturnType<object, KeyEventArgs, bool> KeyEvent
{
add
{
/// <summary>
/// Event arguments that passed via Touch signal.
/// </summary>
- public class TouchedEventArgs : EventArgs
+ public class TouchEventArgs : EventArgs
{
private Touch _touch;
}
}
- private EventHandlerWithReturnType<object, TouchedEventArgs, bool> _touchDataEventHandler;
+ private EventHandlerWithReturnType<object, TouchEventArgs, bool> _touchDataEventHandler;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool TouchDataCallbackType(IntPtr view, IntPtr touchData);
private TouchDataCallbackType _touchDataCallback;
/// Event for Touched signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
/// Touched signal is emitted when touch input is received.<br>
/// </summary>
- public event EventHandlerWithReturnType<object, TouchedEventArgs, bool> Touched
+ public event EventHandlerWithReturnType<object, TouchEventArgs, bool> TouchEvent
{
add
{
// Callback for View TouchSignal
private bool OnTouch(IntPtr view, IntPtr touchData)
{
- TouchedEventArgs e = new TouchedEventArgs();
+ TouchEventArgs e = new TouchEventArgs();
e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
/// <summary>
/// Event arguments that passed via Hover signal.
/// </summary>
- public class HoveredEventArgs : EventArgs
+ public class HoverEventArgs : EventArgs
{
private Hover _hover;
}
}
- private EventHandlerWithReturnType<object, HoveredEventArgs, bool> _hoverEventHandler;
+ private EventHandlerWithReturnType<object, HoverEventArgs, bool> _hoverEventHandler;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool HoverEventCallbackType(IntPtr view, IntPtr hoverEvent);
private HoverEventCallbackType _hoverEventCallback;
/// Event for Hovered signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
/// Hovered signal is emitted when hover input is received.<br>
/// </summary>
- public event EventHandlerWithReturnType<object, HoveredEventArgs, bool> Hovered
+ public event EventHandlerWithReturnType<object, HoverEventArgs, bool> HoverEvent
{
add
{
// Callback for View Hover signal
private bool OnHoverEvent(IntPtr view, IntPtr hoverEvent)
{
- HoveredEventArgs e = new HoveredEventArgs();
+ HoverEventArgs e = new HoverEventArgs();
e.Hover = Tizen.NUI.Hover.GetHoverFromPtr(hoverEvent);
/// <summary>
/// Event arguments that passed via Wheel signal.
/// </summary>
- public class WheelRolledEventArgs : EventArgs
+ public class WheelEventArgs : EventArgs
{
private Wheel _wheel;
}
}
- private EventHandlerWithReturnType<object, WheelRolledEventArgs, bool> _wheelEventHandler;
+ private EventHandlerWithReturnType<object, WheelEventArgs, bool> _wheelEventHandler;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool WheelEventCallbackType(IntPtr view, IntPtr wheelEvent);
private WheelEventCallbackType _wheelEventCallback;
/// Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
/// WheelMoved signal is emitted when wheel event is received.<br>
/// </summary>
- public event EventHandlerWithReturnType<object, WheelRolledEventArgs, bool> WheelRolled
+ public event EventHandlerWithReturnType<object, WheelEventArgs, bool> WheelEvent
{
add
{
// Callback for View Wheel signal
private bool OnWheelEvent(IntPtr view, IntPtr wheelEvent)
{
- WheelRolledEventArgs e = new WheelRolledEventArgs();
+ WheelEventArgs e = new WheelEventArgs();
e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
return ret;
}
+ [Obsolete("Please do not use! this will be deprecated")]
+ public static T DownCast<T>(View view) where T : View
+ {
+ //View ret = ViewRegistry.GetViewFromBaseHandle(view);
+ View ret = View.DownCast(view);
+ if (ret != null)
+ {
+ return (T)ret;
+ }
+ return null;
+ }
+
private View ConvertIdToView(uint id)
{
View view = null;
}
}
+ [Obsolete("Please do not use! this will be deprecated")]
+ public bool PositionUsesAnchorPoint
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.POSITION_USES_ANCHOR_POINT).Get(out temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.POSITION_USES_ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
internal bool FocusState
{
get
}
}
- /// <summary>
- /// Gets the natural size of the view.<br>
- /// </summary>
- /// <remarks>
- /// Readonly.
- /// </remarks>
- internal Vector3 NaturalSize
+ [Obsolete("Please do not use! this will be internal property")]
+ public Vector3 NaturalSize
{
get
{
return GetRendererCount();
}
}
+
+
+
+
+ [Obsolete("Please do not use! this will be deprecated")]
+ public event EventHandlerWithReturnType<object, TouchEventArgs, bool> Touched
+ {
+ add
+ {
+ if (_touchDataEventHandler == null)
+ {
+ _touchDataCallback = OnTouch;
+ this.TouchSignal().Connect(_touchDataCallback);
+ }
+
+ _touchDataEventHandler += value;
+ }
+
+ remove
+ {
+ _touchDataEventHandler -= value;
+
+ if (_touchDataEventHandler == null && TouchSignal().Empty() == false)
+ {
+ this.TouchSignal().Disconnect(_touchDataCallback);
+ }
+
+ }
+ }
+
+ [Obsolete("Please do not use! this will be deprecated")]
+ public event EventHandlerWithReturnType<object, HoverEventArgs, bool> Hovered
+ {
+ add
+ {
+ if (_hoverEventHandler == null)
+ {
+ _hoverEventCallback = OnHoverEvent;
+ this.HoveredSignal().Connect(_hoverEventCallback);
+ }
+
+ _hoverEventHandler += value;
+ }
+
+ remove
+ {
+ _hoverEventHandler -= value;
+
+ if (_hoverEventHandler == null && HoveredSignal().Empty() == false)
+ {
+ this.HoveredSignal().Disconnect(_hoverEventCallback);
+ }
+
+ }
+ }
+
+ [Obsolete("Please do not use! this will be deprecated")]
+ public event EventHandlerWithReturnType<object, WheelEventArgs, bool> WheelMoved
+ {
+ add
+ {
+ if (_wheelEventHandler == null)
+ {
+ _wheelEventCallback = OnWheelEvent;
+ this.WheelEventSignal().Connect(_wheelEventCallback);
+ }
+
+ _wheelEventHandler += value;
+ }
+
+ remove
+ {
+ _wheelEventHandler -= value;
+
+ if (_wheelEventHandler == null && WheelEventSignal().Empty() == false)
+ {
+ this.WheelEventSignal().Disconnect(_wheelEventCallback);
+ }
+
+ }
+ }
+
+ [Obsolete("Please do not use! this will be deprecated")]
+ public Position AnchorPoint
+ {
+ get
+ {
+ Position temp = new Position(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.ANCHOR_POINT).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ [Obsolete("Please do not use! this will be deprecated")]
+ public Size Size
+ {
+ get
+ {
+ Size temp = new Size(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.SIZE).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SIZE, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ [Obsolete("Please do not use! this will be deprecated")]
+ public event EventHandler OnWindowEvent
+ {
+ add
+ {
+ if (_onWindowEventHandler == null)
+ {
+ _onWindowEventCallback = OnWindow;
+ this.OnWindowSignal().Connect(_onWindowEventCallback);
+ }
+
+ _onWindowEventHandler += value;
+ }
+
+ remove
+ {
+ _onWindowEventHandler -= value;
+
+ if (_onWindowEventHandler == null && OnWindowSignal().Empty() == false)
+ {
+ this.OnWindowSignal().Disconnect(_onWindowEventCallback);
+ }
+ }
+ }
+
+ [Obsolete("Please do not use! this will be deprecated")]
+ public event EventHandler OffWindowEvent
+ {
+ add
+ {
+ if (_offWindowEventHandler == null)
+ {
+ _offWindowEventCallback = OffWindow;
+ this.OffWindowSignal().Connect(_offWindowEventCallback);
+ }
+
+ _offWindowEventHandler += value;
+ }
+
+ remove
+ {
+ _offWindowEventHandler -= value;
+
+ if (_offWindowEventHandler == null && OffWindowSignal().Empty() == false)
+ {
+ this.OffWindowSignal().Disconnect(_offWindowEventCallback);
+ }
+ }
+ }
+
+ [Obsolete("Please do not use! this will be deprecated")]
+ public event EventHandler OnRelayoutEvent
+ {
+ add
+ {
+ if (_onRelayoutEventHandler == null)
+ {
+ _onRelayoutEventCallback = OnRelayout;
+ this.OnRelayoutSignal().Connect(_onRelayoutEventCallback);
+ }
+
+ _onRelayoutEventHandler += value;
+ }
+
+ remove
+ {
+ _onRelayoutEventHandler -= value;
+
+ if (_onRelayoutEventHandler == null && OnRelayoutSignal().Empty() == false)
+ {
+ this.OnRelayoutSignal().Disconnect(_onRelayoutEventCallback);
+ }
+
+ }
+ }
+
+
+
+
}
}
projects / platform / core / csapi / tizenfx.git / blobdiff