{
private HandleRef stageCPtr;
private Layer rootLayer;
+ private Layer overlayLayer;
+ private Layer borderLayer;
private string windowTitle;
private List<Layer> childLayers = new List<Layer>();
private LayoutController localController;
+ private Key internalLastKeyEvent;
+ private Touch internalLastTouchEvent;
+ private Timer internalHoverTimer;
static internal bool IsSupportedMultiWindow()
{
bool isSupported = false;
- Information.TryGetValue("http://tizen.org/feature/opengles.surfaceless_context", out isSupported);
+ try
+ {
+ Information.TryGetValue("http://tizen.org/feature/opengles.surfaceless_context", out isSupported);
+ }
+ catch (DllNotFoundException e)
+ {
+ Tizen.Log.Fatal("NUI", $"{e}\n");
+ }
return isSupported;
}
}
/// <summary>
+ /// A helper method to get the current window where the view is added
+ /// </summary>
+ /// <param name="view">The View added to the window</param>
+ /// <returns>A Window.</returns>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ static public Window Get(View view)
+ {
+ if (view == null)
+ {
+ NUILog.Error("if there is no view, it can not get a window");
+ return null;
+ }
+
+ //to fix memory leak issue, match the handle count with native side.
+ Window ret = view.GetInstanceSafely<Window>(Interop.Window.Get(View.getCPtr(view)));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ /// <summary>
/// Creates a new Window.<br />
/// This creates an extra window in addition to the default main window<br />
/// </summary>
}
/// <summary>
+ /// Creates a new Window with a specific name.<br />
+ /// This creates an extra window in addition to the default main window<br />
+ /// </summary>
+ /// <param name="name">The name for extra window. </param>
+ /// <param name="borderInterface"><see cref="Tizen.NUI.IBorderInterface"/>If borderInterface is null, defaultBorder is enabled.</param>
+ /// <param name="windowPosition">The position and size of the Window.</param>
+ /// <param name="isTranslucent">Whether Window is translucent.</param>
+ /// <returns>A new Window.</returns>
+ /// <feature> http://tizen.org/feature/opengles.surfaceless_context </feature>
+ /// <exception cref="NotSupportedException">The required feature is not supported.</exception>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public Window(string name, IBorderInterface borderInterface, Rectangle windowPosition = null, bool isTranslucent = false) : this(Interop.Window.New(Rectangle.getCPtr(windowPosition), name, isTranslucent), true)
+ {
+ if (IsSupportedMultiWindow() == false)
+ {
+ NUILog.Error("This device does not support surfaceless_context. So Window cannot be created. ");
+ }
+ this.windowTitle = name;
+ this.EnableBorder(borderInterface);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+
+ /// <summary>
/// Enumeration for orientation of the window is the way in which a rectangular page is oriented for normal viewing.
/// </summary>
/// <since_tizen> 3 </since_tizen>
/// <summary>
/// Enumeration for transition effect's state.
/// </summary>
- [Obsolete("Please do not use! This will be removed. Please use Window.EffectState instead!")]
+ [Obsolete("Do not use this, that will be removed. Use Window.EffectState instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
+ // This is already deprecated, so suppress warning here.
+ [System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1717:Only FlagsAttribute enums should have plural names", Justification = "<Pending>")]
public enum EffectStates
{
/// <summary>
/// None state.
/// </summary>
- [Obsolete("Please do not use! This will be removed. Please use Window.EffectState.None instead!")]
+ [Obsolete("Do not use this, that will be removed. Use Window.EffectState.None instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
None = 0,
/// <summary>
/// Transition effect is started.
/// </summary>
- [Obsolete("Please do not use! This will be removed. Please use Window.EffectState.Start instead!")]
+ [Obsolete("Do not use this, that will be removed. Use Window.EffectState.Start instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
Start,
/// <summary>
/// Transition effect is ended.
/// </summary>
- [Obsolete("Please do not use! This will be removed. Please use Window.EffectState.End instead!")]
+ [Obsolete("Do not use this, that will be removed. Use Window.EffectState.End instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
End,
}
/// <summary>
/// Enumeration for transition effect's type.
/// </summary>
- [Obsolete("Please do not use! This will be removed. Please use Window.EffectType instead!")]
+ [Obsolete("Do not use this, that will be removed. Use Window.EffectType instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
+ // This is already deprecated, so suppress warning here.
+ [System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1717:Only FlagsAttribute enums should have plural names", Justification = "<Pending>")]
public enum EffectTypes
{
/// <summary>
/// None type.
/// </summary>
- [Obsolete("Please do not use! This will be removed. Please use Window.EffectType.None instead!")]
+ [Obsolete("Do not use this, that will be removed. Use Window.EffectType.None instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
None = 0,
/// <summary>
/// Window show effect.
/// </summary>
- [Obsolete("Please do not use! This will be removed. Please use Window.EffectType.Show instead!")]
+ [Obsolete("Do not use this, that will be removed. Use Window.EffectType.Show instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
Show,
/// <summary>
/// Window hide effect.
/// </summary>
- [Obsolete("Please do not use! This will be removed. Please use Window.EffectType.Hide instead!")]
+ [Obsolete("Do not use this, that will be removed. Use Window.EffectType.Hide instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
Hide,
}
}
/// <summary>
+ /// Enumeration for result of window operation.
+ /// </summary>
+ internal enum OperationResult
+ {
+ /// <summary>
+ /// Failed for unknown reason
+ /// </summary>
+ UnknownError = 0,
+ /// <summary>
+ /// Succeed
+ /// </summary>
+ Succeed,
+ /// <summary>
+ /// Permission denied
+ /// </summary>
+ PermissionDenied,
+ /// <summary>
+ /// The operation is not supported.
+ /// </summary>
+ NotSupported,
+ }
+
+ /// <summary>
+ /// Enumeration for window resized mode by display server.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public enum ResizeDirection
+ {
+ /// <summary>
+ /// None type.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ None = 0,
+ /// <summary>
+ /// Start resizing window to the top-left edge.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ TopLeft = 1,
+ /// <summary>
+ /// Start resizing window to the top side.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ Top = 2,
+ /// <summary>
+ /// Start resizing window to the top-right edge.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ TopRight = 3,
+ /// <summary>
+ /// Start resizing window to the left side.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ Left = 4,
+ /// <summary>
+ /// Start resizing window to the right side.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ Right = 5,
+ /// <summary>
+ /// Start resizing window to the bottom-left edge.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ BottomLeft = 6,
+ /// <summary>
+ /// Start resizing window to the bottom side.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ Bottom = 7,
+ /// <summary>
+ /// Start resizing window to the bottom-right edge.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ BottomRight = 8,
+ }
+
+
+ /// <summary>
/// The stage instance property (read-only).<br />
/// Gets the current window.<br />
/// </summary>
/// <summary>
/// Gets or sets a window type.
+ /// Most of window type can be set to use WindowType, except for IME type.
+ /// IME type can be set to use one of NUIApplication's constrcutors.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public WindowType Type
{
Position2D position = GetPosition();
Size2D size = GetSize();
- Rectangle ret = new Rectangle(position.X, position.Y, size.Width, size.Height);
+ Rectangle ret = new Rectangle(position?.X ?? 0, position?.Y ?? 0, size?.Width ?? 0, size?.Height ?? 0);
position.Dispose();
return ret;
}
/// </summary>
/// <param name="keyEvent">The key event to feed.</param>
/// <since_tizen> 4 </since_tizen>
- [Obsolete("Please do not use! This will be deprecated! Please use FeedKey(Key keyEvent) instead!")]
+ [Obsolete("Do not use this, that will be deprecated. Use FeedKey(Key keyEvent) instead.")]
public static void FeedKeyEvent(Key keyEvent)
{
Interop.Window.FeedKeyEvent(Key.getCPtr(keyEvent));
/// <since_tizen> 3 </since_tizen>
public bool SetNotificationLevel(NotificationLevel level)
{
- bool ret = Interop.Window.SetNotificationLevel(SwigCPtr, (int)level);
+ var ret = (OperationResult)Interop.Window.SetNotificationLevel(SwigCPtr, (int)level);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
+ return ret == OperationResult.Succeed;
}
/// <summary>
/// <since_tizen> 4 </since_tizen>
public bool SetScreenOffMode(ScreenOffMode screenOffMode)
{
- bool ret = Interop.Window.SetScreenOffMode(SwigCPtr, (int)screenOffMode);
+ var ret = (OperationResult)Interop.Window.SetScreenOffMode(SwigCPtr, (int)screenOffMode);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
+ return ret == OperationResult.Succeed;
}
/// <summary>
/// <since_tizen> 3 </since_tizen>
public bool SetBrightness(int brightness)
{
- bool ret = Interop.Window.SetBrightness(SwigCPtr, brightness);
+ var ret = (OperationResult)Interop.Window.SetBrightness(SwigCPtr, brightness);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
+ return ret == OperationResult.Succeed;
}
/// <summary>
}
/// <summary>
+ /// Gets the overlay layer.
+ /// </summary>
+ /// <returns>The overlay layer.</returns>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public Layer GetOverlayLayer()
+ {
+ // Window.IsInstalled() is actually true only when called from event thread and
+ // Core has been initialized, not when Stage is ready.
+ if (overlayLayer == null && Window.IsInstalled())
+ {
+ overlayLayer = new Layer(Interop.Window.GetOverlayLayer(SwigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ LayersChildren?.Add(overlayLayer);
+ overlayLayer.SetWindow(this);
+ }
+ return overlayLayer;
+ }
+
+ /// <summary>
/// Add a child view to window.
/// </summary>
/// <param name="view">the child should be added to the window.</param>
/// <since_tizen> 3 </since_tizen>
public void Add(View view)
{
- Interop.Actor.Add(Layer.getCPtr(GetRootLayer()), View.getCPtr(view));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- this.GetRootLayer().AddViewToLayerList(view); // Maintain the children list in the Layer
- if (null != view)
- {
- view.InternalParent = this.GetRootLayer();
- }
+ this.GetRootLayer().Add(view);
}
/// <summary>
/// <since_tizen> 3 </since_tizen>
public void Remove(View view)
{
- Interop.Actor.Remove(Layer.getCPtr(GetRootLayer()), View.getCPtr(view));
- this.GetRootLayer().RemoveViewFromLayerList(view); // Maintain the children list in the Layer
- if (null != view)
- {
- view.InternalParent = null;
- }
+ this.GetRootLayer().Remove(view);
}
/// <summary>
/// <since_tizen> 3 </since_tizen>
public void KeepRendering(float durationSeconds)
{
- Interop.Stage.KeepRendering(stageCPtr, durationSeconds);
+ Interop.Window.KeepRendering(SwigCPtr, durationSeconds);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// <since_tizen> 5 </since_tizen>
public void FeedKey(Key keyEvent)
{
- Interop.Window.FeedKeyEvent(Key.getCPtr(keyEvent));
+ Interop.Window.FeedKeyEvent(SwigCPtr, Key.getCPtr(keyEvent));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Feeds a hover event into the window. <br />
+ /// This is feed after a default time of 48 ms. You can also set this time.
+ /// </summary>
+ /// <param name="time">The time of how much later it will be feed (default is 48ms)</param>
+ /// <remarks>If you want to do FeedHover after the UI is updated, it is recommended to set the time to at least 16ms. This will be a good time waiting for the UI to update.<br />
+ /// and LazyFeedHover called within the set time are ignored. Only the last request becomes a FeedHover.
+ /// </remarks>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void LazyFeedHover(uint time = 48)
+ {
+ if (internalHoverTimer == null)
+ {
+ internalHoverTimer = new Timer(time);
+ internalHoverTimer.Tick += (s, e) =>
+ {
+ FeedHover();
+ internalHoverTimer?.Stop();
+ internalHoverTimer?.Dispose();
+ internalHoverTimer = null;
+ return false;
+ };
+ internalHoverTimer.Start();
+ }
+ else
+ {
+ internalHoverTimer.Start();
+ }
+ }
+
+ /// <summary>
+ /// Feeds a touch point into the window.
+ /// </summary>
+ /// <param name="touchPoint">The touch point to feed.</param>
+ /// <param name="timeStamp">The timeStamp.</param>
+ internal void FeedTouch(TouchPoint touchPoint, int timeStamp)
+ {
+ Interop.Window.FeedTouchPoint(SwigCPtr, TouchPoint.getCPtr(touchPoint), timeStamp);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Feeds a wheel event into the window.
+ /// </summary>
+ /// <param name="wheelEvent">The wheel event to feed.</param>
+ internal void FeedWheel(Wheel wheelEvent)
+ {
+ Interop.Window.FeedWheelEvent(SwigCPtr, Wheel.getCPtr(wheelEvent));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Feeds a hover event into the window.
+ /// </summary>
+ /// <param name="touchPoint">The touch point to feed hover event. If null is entered, the feed hover event is generated with the last inputed touch point.</param>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal void FeedHover(TouchPoint touchPoint = null)
+ {
+ if (touchPoint == null)
+ {
+ using Touch touch = GetLastTouchEvent();
+ using Vector2 screenPosition = touch.GetScreenPosition(0);
+ touchPoint = new TouchPoint(touch.GetDeviceId(0), TouchPoint.StateType.Motion, screenPosition.X, screenPosition.Y);
+ }
+ Interop.Window.FeedHoverEvent(SwigCPtr, TouchPoint.getCPtr(touchPoint));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
/// <summary>
+ /// Sets parent window of the window.
+ /// After setting that, these windows do together when raise-up, lower and iconified/deiconified.
+ /// This function has the additional flag whether the child is located above or below of the parent.
+ /// </summary>
+ /// <param name="parent">The parent window.</param>
+ /// <param name="belowParent">The flag is whether the child is located above or below of the parent.</param>
+ /// <feature> http://tizen.org/feature/opengles.surfaceless_context </feature>
+ /// <exception cref="NotSupportedException">The required feature is not supported.</exception>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SetParent(Window parent, bool belowParent)
+ {
+ if (IsSupportedMultiWindow() == false)
+ {
+ NUILog.Error("This device does not support surfaceless_context. So Window cannot be created. ");
+ }
+ Interop.Window.SetParentWithStack(SwigCPtr, Window.getCPtr(parent), belowParent);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
/// Unsets parent window of the window.
/// After unsetting, the window is disconnected his parent window.
/// </summary>
{
NUILog.Error("This device does not support surfaceless_context. So Window cannot be created. ");
}
- Window ret = Registry.GetManagedBaseHandleFromNativePtr(Interop.Window.GetParent(SwigCPtr)) as Window;
+ Window ret = this.GetInstanceSafely<Window>(Interop.Window.GetParent(SwigCPtr));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
}
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Window obj)
- {
- return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.SwigCPtr;
- }
-
internal static bool IsInstalled()
{
bool ret = Interop.Stage.IsInstalled();
[EditorBrowsable(EditorBrowsableState.Never)]
public void SetAvailableOrientations(List<Window.WindowOrientation> orientations)
{
- PropertyArray orientationArray = new PropertyArray();
- if (null != orientations)
+ if (null == orientations)
{
- for (int i = 0; i < orientations.Count; i++)
- {
- PropertyValue value = new PropertyValue((int)orientations[i]);
- orientationArray.PushBack(value);
- }
+ throw new ArgumentNullException(nameof(orientations));
}
- Interop.Window.SetAvailableOrientations(SwigCPtr, PropertyArray.getCPtr(orientationArray));
- for (uint i = 0; i < orientationArray.Count(); i++)
+ PropertyArray orientationArray = new PropertyArray();
+ for (int i = 0; i < orientations.Count; i++)
{
- orientationArray[i].Dispose();
+ PropertyValue value = new PropertyValue((int)orientations[i]);
+ orientationArray.PushBack(value);
+ value.Dispose();
}
+
+ Interop.Window.SetAvailableOrientations(SwigCPtr, PropertyArray.getCPtr(orientationArray), orientations.Count);
orientationArray.Dispose();
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
{
throw new ArgumentNullException(nameof(layer));
}
- Interop.Window.Add(SwigCPtr, Layer.getCPtr(layer));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+
+ if (isBorderWindow)
+ {
+ Interop.Actor.Add(GetRootLayer().SwigCPtr, layer.SwigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) { throw NDalicPINVOKE.SWIGPendingException.Retrieve(); }
+ }
+ else
+ {
+ Interop.Window.Add(SwigCPtr, Layer.getCPtr(layer));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
LayersChildren?.Add(layer);
layer.SetWindow(this);
internal Vector2 GetSize()
{
var val = new Uint16Pair(Interop.Window.GetSize(SwigCPtr), true);
+
+ convertRealWindowSizeToBorderWindowSize(val);
+
Vector2 ret = new Vector2(val.GetWidth(), val.GetHeight());
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ val.Dispose();
return ret;
}
internal Layer GetRootLayer()
{
- // Window.IsInstalled() is actually true only when called from event thread and
- // Core has been initialized, not when Stage is ready.
- if (rootLayer == null && Window.IsInstalled())
+ if (isBorderWindow)
{
- rootLayer = new Layer(Interop.Window.GetRootLayer(SwigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- LayersChildren?.Add(rootLayer);
- rootLayer.SetWindow(this);
+ if (borderLayer == null)
+ {
+ borderLayer = GetBorderWindowRootLayer();
+ LayersChildren?.Add(borderLayer);
+ borderLayer.SetWindow(this);
+ }
+ return borderLayer;
+ }
+ else
+ {
+ // Window.IsInstalled() is actually true only when called from event thread and
+ // Core has been initialized, not when Stage is ready.
+ if (rootLayer == null && Window.IsInstalled())
+ {
+ rootLayer = new Layer(Interop.Window.GetRootLayer(SwigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ LayersChildren?.Add(rootLayer);
+ rootLayer.SetWindow(this);
+ }
+ return rootLayer;
}
- return rootLayer;
}
internal void SetBackgroundColor(Vector4 color)
throw new ArgumentNullException(nameof(size));
}
var val = new Uint16Pair((uint)size.Width, (uint)size.Height);
+
+ convertBorderWindowSizeToRealWindowSize(val);
+
Interop.Window.SetSize(SwigCPtr, Uint16Pair.getCPtr(val));
val.Dispose();
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
internal Size2D GetWindowSize()
{
var val = new Uint16Pair(Interop.Window.GetSize(SwigCPtr), true);
+
+ convertRealWindowSizeToBorderWindowSize(val);
+
Size2D ret = new Size2D(val.GetWidth(), val.GetHeight());
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ val.Dispose();
return ret;
}
{
throw new ArgumentNullException(nameof(position));
}
- var val = new Uint16Pair((uint)position.X, (uint)position.Y);
- Interop.Window.SetPosition(SwigCPtr, Uint16Pair.getCPtr(val));
+ var val = new Int32Pair(position.X, position.Y);
+ Interop.Window.SetPosition(SwigCPtr, Int32Pair.getCPtr(val));
val.Dispose();
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
// Setting Position of the window should request a relayout of the tree.
internal Position2D GetPosition()
{
- var val = new Uint16Pair(Interop.Window.GetPosition(SwigCPtr), true);
- Position2D ret = new Position2D(val.GetX(), val.GetY());
+ var val = new Int32Pair(Interop.Window.GetPosition(SwigCPtr), true);
+ Position2D ret = new Position2D((int)val.GetX(), (int)val.GetY());
val.Dispose();
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
internal void SetPositionSize(Rectangle positionSize)
{
+ if (positionSize == null)
+ {
+ throw new ArgumentNullException(nameof(positionSize));
+ }
+ var val = new Uint16Pair((uint)positionSize.Width, (uint)positionSize.Height);
+
+ convertBorderWindowSizeToRealWindowSize(val);
+
+ positionSize.Width = val.GetX();
+ positionSize.Height = val.GetY();
+
Interop.Window.SetPositionSize(SwigCPtr, Rectangle.getCPtr(positionSize));
+ val.Dispose();
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// <summary>
+ /// Enables the floating mode of window.
+ /// The floating mode is to support window is moved or resized by display server.
+ /// For example, if the video-player window sets the floating mode,
+ /// then display server changes its geometry and handles it like a popup.
+ /// The way of handling floating mode window is decided by display server.
+ /// A special display server(as a Tizen display server) supports this mode.
+ /// </summary>
+ /// <param name="enable">Enable floating mode or not.</param>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void EnableFloatingMode(bool enable)
+ {
+ Interop.Window.EnableFloatingMode(SwigCPtr, enable);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Requests to display server for the window is moved by display server.
+ /// It can be work with setting window floating mode.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void RequestMoveToServer()
+ {
+ Interop.Window.RequestMoveToServer(SwigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Requests to display server for the window is resized by display server.
+ /// It can be work with setting window floating mode.
+ /// </summary>
+ /// <param name="direction">It is indicated the window's side or edge for starting point.</param>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void RequestResizeToServer(ResizeDirection direction)
+ {
+ Interop.Window.RequestResizeToServer(SwigCPtr, (int)direction);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Includes input region.
+ /// This function inlcudes input regions.
+ /// It can be used multiple times and supports multiple regions.
+ /// It means input region will be extended.
+ /// This input is related to mouse and touch event.
+ /// If device has touch screen, this function is useful.
+ /// Otherwise device does not have that, we can use it after connecting mouse to the device.
+ /// </summary>
+ /// <param name="inputRegion">The included region to accept input events.</param>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void IncludeInputRegion(Rectangle inputRegion)
+ {
+ Interop.Window.IncludeInputRegion(SwigCPtr, Rectangle.getCPtr(inputRegion));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// This function excludes input regions.
+ /// It can be used multiple times and supports multiple regions.
+ /// It means input region will be reduced.
+ /// Nofice, should be set input area by IncludeInputRegion() before this function is used.
+ /// This input is related to mouse and touch event.
+ /// If device has touch screen, this function is useful.
+ /// Otherwise device does not have that, we can use it after connecting mouse to the device.
+ /// </summary>
+ /// <param name="inputRegion">The excluded region to except input events.</param>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void ExcludeInputRegion(Rectangle inputRegion)
+ {
+ Interop.Window.ExcludeInputRegion(SwigCPtr, Rectangle.getCPtr(inputRegion));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Maximizes window's size.
+ /// If this function is called with true, window will be resized with screen size.
+ /// Otherwise window will be resized with previous size.
+ /// It is for the window's MAX button in window's border.
+ /// If window border is supported by display server, it is not necessary.
+ /// </summary>
+ /// <param name="max">If window is maximized or unmaximized.</param>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void Maximize(bool max)
+ {
+ Interop.Window.Maximize(SwigCPtr, max);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Returns whether the window is maximized or not.
+ /// </summary>
+ /// <returns>True if the window is maximized, false otherwise.</returns>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public bool IsMaximized()
+ {
+ bool ret = Interop.Window.IsMaximized(SwigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ /// <summary>
+ /// Sets window's maximum size.
+ ///
+ /// It is to set the maximized size when window is maximized or the window's size is increased by RequestResizeToServer().
+ /// Although the size is set by this function, window's size can be increased over the limitation by SetPositionSize() or SetSize().
+ ///
+ /// After setting, if Maximize() is called, window is resized with the setting size and move the center.
+ ///
+ /// </summary>
+ /// <param name="size">the maximum size.</param>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SetMaximumSize(Size2D size)
+ {
+ if (null == size)
+ {
+ throw new ArgumentNullException(nameof(size));
+ }
+ var val = new Uint16Pair((uint)size.Width, (uint)size.Height);
+
+ Interop.Window.SetMaximumSize(SwigCPtr, Uint16Pair.getCPtr(val));
+ val.Dispose();
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Minimizes window's size.
+ /// If this function is called with true, window will be iconified.
+ /// Otherwise window will be activated.
+ /// It is for the window's MIN button in window border.
+ /// If window border is supported by display server, it is not necessary.
+ /// </summary>
+ /// <param name="min">If window is minimized or unminimized.</param>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void Minimize(bool min)
+ {
+ Interop.Window.Minimize(SwigCPtr, min);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Returns whether the window is minimized or not.
+ /// </summary>
+ /// <returns>True if the window is minimized, false otherwise.</returns>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public bool IsMinimized()
+ {
+ bool ret = Interop.Window.IsMinimized(SwigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ /// <summary>
+ /// Sets window's minimum size.
+ /// It is to set the minimum size when window's size is decreased by RequestResizeToServer().
+ /// Although the size is set by this function, window's size can be decreased over the limitation by SetPositionSize() or SetSize().
+ /// </summary>
+ /// <param name="size">the minimum size.</param>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SetMimimumSize(Size2D size)
+ {
+ if (null == size)
+ {
+ throw new ArgumentNullException(nameof(size));
+ }
+ var val = new Uint16Pair((uint)size.Width, (uint)size.Height);
+
+ Interop.Window.SetMimimumSize(SwigCPtr, Uint16Pair.getCPtr(val));
+ val.Dispose();
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Sets the layout of the window.
+ /// </summary>
+ /// <param name="numCols">The number of columns in the layout.</param>
+ /// <param name="numRows">The number of rows in the layout.</param>
+ /// <param name="column">The column number of the window within the layout.</param>
+ /// <param name="row">The row number of the window within the layout.</param>
+ /// <param name="colSpan">The number of columns the window should span within the layout.</param>
+ /// <param name="rowSpan">The number of rows the window should span within the layout.</param>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SetLayout(uint numCols, uint numRows, uint column, uint row, uint colSpan, uint rowSpan)
+ {
+ Interop.Window.SetLayout(SwigCPtr, numCols, numRows, column, row, colSpan, rowSpan);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+
+ }
+
+ /// <summary>
+ /// Sets the layout of the window.
+ /// </summary>
+ /// <param name="layoutType">The type of layout to set for the window.</param>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SetLayout(WindowLayoutType layoutType)
+ {
+ switch (layoutType)
+ {
+ case WindowLayoutType.LeftHalf:
+ Interop.Window.SetLayout(SwigCPtr, 2, 1, 0, 0, 1, 1);
+ break;
+ case WindowLayoutType.RightHalf:
+ Interop.Window.SetLayout(SwigCPtr, 2, 1, 1, 0, 1, 1);
+ break;
+
+ case WindowLayoutType.TopHalf:
+ Interop.Window.SetLayout(SwigCPtr, 1, 2, 0, 0, 1, 1);
+ break;
+ case WindowLayoutType.BottomHalf:
+ Interop.Window.SetLayout(SwigCPtr, 1, 2, 0, 1, 1, 1);
+ break;
+
+ case WindowLayoutType.UpperLeftQuarter:
+ Interop.Window.SetLayout(SwigCPtr, 2, 2, 0, 0, 1, 1);
+ break;
+ case WindowLayoutType.UpperRightQuarter:
+ Interop.Window.SetLayout(SwigCPtr, 2, 2, 1, 0, 1, 1);
+ break;
+ case WindowLayoutType.LowerLeftQuarter:
+ Interop.Window.SetLayout(SwigCPtr, 2, 2, 0, 1, 1, 1);
+ break;
+ case WindowLayoutType.LowerRightQuarter:
+ Interop.Window.SetLayout(SwigCPtr, 2, 2, 1, 1, 1, 1);
+ break;
+
+ case WindowLayoutType.LeftThird:
+ Interop.Window.SetLayout(SwigCPtr, 3, 1, 0, 0, 1, 1);
+ break;
+ case WindowLayoutType.CenterThird:
+ Interop.Window.SetLayout(SwigCPtr, 3, 1, 1, 0, 1, 1);
+ break;
+ case WindowLayoutType.RightThird:
+ Interop.Window.SetLayout(SwigCPtr, 3, 1, 2, 0, 1, 1);
+ break;
+
+ case WindowLayoutType.TopThird:
+ Interop.Window.SetLayout(SwigCPtr, 1, 3, 0, 0, 1, 1);
+ break;
+ case WindowLayoutType.MiddleThird:
+ Interop.Window.SetLayout(SwigCPtr, 1, 3, 0, 1, 1, 1);
+ break;
+ case WindowLayoutType.BottomThird:
+ Interop.Window.SetLayout(SwigCPtr, 1, 3, 0, 2, 1, 1);
+ break;
+ }
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+
+ }
+
+ /// <summary>
+ /// Query whether window is rotating or not.
+ /// </summary>
+ /// <returns>True if window is rotating, false otherwise.</returns>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public bool IsWindowRotating()
+ {
+ bool ret = Interop.Window.IsWindowRotating(SwigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ /// <summary>
+ /// Gets the last key event the window gets.
+ /// </summary>
+ /// <returns>The last key event the window gets.</returns>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public Key GetLastKeyEvent()
+ {
+ if(internalLastKeyEvent == null)
+ {
+ internalLastKeyEvent = new Key();
+ }
+ Interop.Window.InternalRetrievingLastKeyEvent(SwigCPtr, internalLastKeyEvent.SwigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return internalLastKeyEvent;
+ }
+
+ /// <summary>
+ /// Gets the last touch event the window gets.
+ /// </summary>
+ /// <returns>The last touch event the window gets.</returns>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public Touch GetLastTouchEvent()
+ {
+ if(internalLastTouchEvent == null)
+ {
+ internalLastTouchEvent = new Touch();
+ }
+ Interop.Window.InternalRetrievingLastTouchEvent(SwigCPtr, internalLastTouchEvent.SwigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return internalLastTouchEvent;
+ }
+
+ /// <summary>
+ /// Sets the necessary for window rotation Acknowledgement.
+ /// After this function called, SendRotationCompletedAcknowledgement() should be called to complete window rotation.
+ ///
+ /// This function is supprot that application has the window rotation acknowledgement's control.
+ /// It means display server waits when application's rotation work is finished.
+ /// It is useful application has the other rendering engine which works asynchronous.
+ /// For instance, GlView.
+ /// </summary>
+ /// <param name="needAcknowledgement">the flag is true if window rotation acknowledge is sent.</param>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SetNeedsRotationCompletedAcknowledgement(bool needAcknowledgement)
+ {
+ Interop.Window.SetNeedsRotationCompletedAcknowledgement(SwigCPtr, needAcknowledgement);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// send the Acknowledgement to complete window rotation.
+ /// For this function, SetNeedsRotationCompletedAcknowledgement should be already called with true.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SendRotationCompletedAcknowledgement()
+ {
+ Interop.Window.SendRotationCompletedAcknowledgement(SwigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
/// Add FrameUpdateCallback
/// </summary>
[EditorBrowsable(EditorBrowsableState.Never)]
return;
}
+ this.DisconnectNativeSignals();
+
if (type == DisposeTypes.Explicit)
{
//Called by User
//Release your own managed resources here.
//You should release all of your own disposable objects here.
- if (rootLayer != null)
+ if (IsBorderEnabled)
{
- rootLayer.Dispose();
+ DisposeBorder();
}
- localController?.Dispose();
-
foreach (var layer in childLayers)
{
if (layer != null)
}
childLayers.Clear();
+
+ localController?.Dispose();
+
+ internalLastKeyEvent?.Dispose();
+ internalLastKeyEvent = null;
+ internalLastTouchEvent?.Dispose();
+ internalLastTouchEvent = null;
+
+ internalHoverTimer?.Stop();
+ internalHoverTimer?.Dispose();
+ internalHoverTimer = null;
}
- this.DisconnectNativeSignals();
base.Dispose(type);
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+
+ /// <summary>
+ /// Search through this Window for a Layer with the given unique ID.
+ /// </summary>
+ /// <param name="id">The ID of the Layer to find.</param>
+ /// <remarks>Hidden-API</remarks>
+ /// <returns>A handle to the Layer if found, or an empty handle if not.</returns>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public Layer FindLayerByID(uint id)
+ {
+ Layer defaultLayer = this.GetDefaultLayer();
+ IntPtr cPtr = Interop.Actor.FindChildById(defaultLayer.SwigCPtr, id);
+ Layer ret = this.GetInstanceSafely<Layer>(cPtr);
+
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ /// <summary>
+ /// Get Native Window handle.
+ /// <example>
+ /// How to get Native Window handle
+ /// <code>
+ /// Window window = NUIApplication.GetDefaultWindow();
+ /// var handle = window.NativeHandle;
+ /// if(handle.IsInvalid == false)
+ /// {
+ /// IntPtr nativeHandle = handle.DangerousGetHandle();
+ /// // do something with nativeHandle
+ /// }
+ /// </code>
+ /// </example>
+ /// </summary>
+ /// <since_tizen> 9 </since_tizen>
+ public SafeHandle NativeHandle
+ {
+ get
+ {
+ return new NUI.SafeNativeWindowHandle(this);
+ }
+ }
}
}