src/Tizen.NUI/src/public/Window.cs

   1 /*
   2  * Copyright(c) 2018 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17 using System;
  18 using System.Runtime.InteropServices;
  19 using Tizen.NUI.BaseComponents;
  20 using System.ComponentModel;
  21 using System.Collections.Generic;
  22
  23 namespace Tizen.NUI
  24 {
  25     /// <summary>
  26     /// The window class is used internally for drawing.<br />
  27     /// The window has an orientation and indicator properties.<br />
  28     /// </summary>
  29     /// <since_tizen> 3 </since_tizen>
  30     public class Window : BaseHandle
  31     {
  32         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  33         private global::System.Runtime.InteropServices.HandleRef stageCPtr;
  34         private global::System.Runtime.InteropServices.HandleRef rootLayoutCPtr;
  35         private global::System.IntPtr rootLayoutIntPtr;
  36         private Layer _rootLayer;
  37         private string _windowTitle;
  38
  39         private List<Layer> _childLayers = new List<Layer>();
  40         internal List<Layer> LayersChildren
  41         {
  42             get
  43             {
  44                 return _childLayers;
  45             }
  46         }
  47
  48         internal Window(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Window_SWIGUpcast(cPtr), cMemoryOwn)
  49         {
  50             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  51             if (NDalicPINVOKE.Stage_IsInstalled())
  52             {
  53                 stageCPtr = new global::System.Runtime.InteropServices.HandleRef(this, NDalicPINVOKE.Stage_GetCurrent());
  54                 // Create a root layout (AbsoluteLayout) that is invisible to the user but enables layouts added to the Window
  55                 // Enables layouts added to the Window to have a parent layout.  As parent layout is needed to store measure spec properties.
  56                 // Currently without these measure specs the new layout added will always be the size of the window.
  57                 rootLayoutIntPtr = NDalicManualPINVOKE.Window_NewRootLayout();
  58                 // Store HandleRef used by Add()
  59                 rootLayoutCPtr = new global::System.Runtime.InteropServices.HandleRef(this, rootLayoutIntPtr);
  60                 Layer rootLayer = GetRootLayer();
  61                 // Add the root layout created above to the root layer.
  62                 NDalicPINVOKE.Actor_Add(  Layer.getCPtr(rootLayer), rootLayoutCPtr );
  63             }
  64         }
  65
  66         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Window obj)
  67         {
  68             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  69         }
  70
  71         internal static Window GetCurrent()
  72         {
  73             Window ret = new Window(NDalicPINVOKE.Stage_GetCurrent(), true);
  74             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  75             return ret;
  76         }
  77
  78         internal static bool IsInstalled()
  79         {
  80             bool ret = NDalicPINVOKE.Stage_IsInstalled();
  81             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  82             return ret;
  83         }
  84
  85         /// <summary>
  86         /// Sets whether the window accepts a focus or not.
  87         /// </summary>
  88         /// <param name="accept">If a focus is accepted or not. The default is true.</param>
  89         /// <since_tizen> 3 </since_tizen>
  90         public void SetAcceptFocus(bool accept)
  91         {
  92             NDalicPINVOKE.SetAcceptFocus(swigCPtr, accept);
  93             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  94         }
  95
  96         /// <summary>
  97         /// Returns whether the window accepts a focus or not.
  98         /// </summary>
  99         /// <returns>True if the window accepts a focus, false otherwise.</returns>
 100         /// <since_tizen> 3 </since_tizen>
 101         public bool IsFocusAcceptable()
 102         {
 103             bool ret = NDalicPINVOKE.IsFocusAcceptable(swigCPtr);
 104             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 105
 106             return ret;
 107         }
 108
 109         /// <summary>
 110         /// Shows the window if it is hidden.
 111         /// </summary>
 112         /// <since_tizen> 3 </since_tizen>
 113         public void Show()
 114         {
 115             NDalicPINVOKE.Show(swigCPtr);
 116             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 117         }
 118
 119         /// <summary>
 120         /// Hides the window if it is showing.
 121         /// </summary>
 122         /// <since_tizen> 3 </since_tizen>
 123         public void Hide()
 124         {
 125             NDalicPINVOKE.Hide(swigCPtr);
 126             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 127         }
 128
 129         /// <summary>
 130         /// Retrieves whether the window is visible or not.
 131         /// </summary>
 132         /// <returns>True if the window is visible.</returns>
 133         /// <since_tizen> 3 </since_tizen>
 134         public bool IsVisible()
 135         {
 136             bool temp = NDalicPINVOKE.IsVisible(swigCPtr);
 137             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 138             return temp;
 139         }
 140
 141         /// <summary>
 142         /// Gets the count of supported auxiliary hints of the window.
 143         /// </summary>
 144         /// <returns>The number of supported auxiliary hints.</returns>
 145         /// <since_tizen> 3 </since_tizen>
 146         public uint GetSupportedAuxiliaryHintCount()
 147         {
 148             uint ret = NDalicPINVOKE.GetSupportedAuxiliaryHintCount(swigCPtr);
 149             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 150             return ret;
 151         }
 152
 153         /// <summary>
 154         /// Gets the supported auxiliary hint string of the window.
 155         /// </summary>
 156         /// <param name="index">The index of the supported auxiliary hint lists.</param>
 157         /// <returns>The auxiliary hint string of the index.</returns>
 158         /// <since_tizen> 3 </since_tizen>
 159         public string GetSupportedAuxiliaryHint(uint index)
 160         {
 161             string ret = NDalicPINVOKE.GetSupportedAuxiliaryHint(swigCPtr, index);
 162             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 163             return ret;
 164         }
 165
 166         /// <summary>
 167         /// Creates an auxiliary hint of the window.
 168         /// </summary>
 169         /// <param name="hint">The auxiliary hint string.</param>
 170         /// <param name="value">The value string.</param>
 171         /// <returns>The ID of created auxiliary hint, or 0 on failure.</returns>
 172         /// <since_tizen> 3 </since_tizen>
 173         public uint AddAuxiliaryHint(string hint, string value)
 174         {
 175             uint ret = NDalicPINVOKE.AddAuxiliaryHint(swigCPtr, hint, value);
 176             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 177             return ret;
 178         }
 179
 180         /// <summary>
 181         /// Removes an auxiliary hint of the window.
 182         /// </summary>
 183         /// <param name="id">The ID of the auxiliary hint.</param>
 184         /// <returns>True if no error occurred, false otherwise.</returns>
 185         /// <since_tizen> 3 </since_tizen>
 186         public bool RemoveAuxiliaryHint(uint id)
 187         {
 188             bool ret = NDalicPINVOKE.RemoveAuxiliaryHint(swigCPtr, id);
 189             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 190             return ret;
 191         }
 192
 193         /// <summary>
 194         /// Changes a value of the auxiliary hint.
 195         /// </summary>
 196         /// <param name="id">The auxiliary hint ID.</param>
 197         /// <param name="value">The value string to be set.</param>
 198         /// <returns>True if no error occurred, false otherwise.</returns>
 199         /// <since_tizen> 3 </since_tizen>
 200         public bool SetAuxiliaryHintValue(uint id, string value)
 201         {
 202             bool ret = NDalicPINVOKE.SetAuxiliaryHintValue(swigCPtr, id, value);
 203             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 204             return ret;
 205         }
 206
 207         /// <summary>
 208         /// Gets a value of the auxiliary hint.
 209         /// </summary>
 210         /// <param name="id">The auxiliary hint ID.</param>
 211         /// <returns>The string value of the auxiliary hint ID, or an empty string if none exists.</returns>
 212         /// <since_tizen> 3 </since_tizen>
 213         public string GetAuxiliaryHintValue(uint id)
 214         {
 215             string ret = NDalicPINVOKE.GetAuxiliaryHintValue(swigCPtr, id);
 216             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 217             return ret;
 218         }
 219
 220         /// <summary>
 221         /// Gets an ID of the auxiliary hint string.
 222         /// </summary>
 223         /// <param name="hint">The auxiliary hint string.</param>
 224         /// <returns>The ID of auxiliary hint string, or 0 on failure.</returns>
 225         /// <since_tizen> 3 </since_tizen>
 226         public uint GetAuxiliaryHintId(string hint)
 227         {
 228             uint ret = NDalicPINVOKE.GetAuxiliaryHintId(swigCPtr, hint);
 229             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 230             return ret;
 231         }
 232
 233         /// <summary>
 234         /// Sets a region to accept input events.
 235         /// </summary>
 236         /// <param name="inputRegion">The region to accept input events.</param>
 237         /// <since_tizen> 3 </since_tizen>
 238         public void SetInputRegion(Rectangle inputRegion)
 239         {
 240             NDalicPINVOKE.SetInputRegion(swigCPtr, Rectangle.getCPtr(inputRegion));
 241             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 242         }
 243
 244         /// <summary>
 245         /// Gets or sets a window type.
 246         /// </summary>
 247         /// <since_tizen> 3 </since_tizen>
 248         public WindowType Type
 249         {
 250             get
 251             {
 252                 WindowType ret = (WindowType)NDalicPINVOKE.GetType(swigCPtr);
 253                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 254                 return ret;
 255             }
 256             set
 257             {
 258                 NDalicPINVOKE.SetType(swigCPtr, (int)value);
 259                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 260             }
 261         }
 262
 263         /// <summary>
 264         /// Sets a priority level for the specified notification window.
 265         /// </summary>
 266         /// <param name="level">The notification window level.</param>
 267         /// <returns>True if no error occurred, false otherwise.</returns>
 268         /// <since_tizen> 3 </since_tizen>
 269         public bool SetNotificationLevel(NotificationLevel level)
 270         {
 271             bool ret = NDalicPINVOKE.SetNotificationLevel(swigCPtr, (int)level);
 272             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 273             return ret;
 274         }
 275
 276         /// <summary>
 277         /// Gets a priority level for the specified notification window.
 278         /// </summary>
 279         /// <returns>The notification window level.</returns>
 280         /// <since_tizen> 3 </since_tizen>
 281         public NotificationLevel GetNotificationLevel()
 282         {
 283             NotificationLevel ret = (NotificationLevel)NDalicPINVOKE.GetNotificationLevel(swigCPtr);
 284             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 285             return ret;
 286         }
 287
 288         /// <summary>
 289         /// Sets a transparent window's visual state to opaque. <br />
 290         /// If a visual state of a transparent window is opaque, <br />
 291         /// then the window manager could handle it as an opaque window when calculating visibility.
 292         /// </summary>
 293         /// <param name="opaque">Whether the window's visual state is opaque.</param>
 294         /// <remarks>This will have no effect on an opaque window. <br />
 295         /// It doesn't change transparent window to opaque window but lets the window manager know the visual state of the window.
 296         /// </remarks>
 297         /// <since_tizen> 3 </since_tizen>
 298         public void SetOpaqueState(bool opaque)
 299         {
 300             NDalicPINVOKE.SetOpaqueState(swigCPtr, opaque);
 301             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 302         }
 303
 304         /// <summary>
 305         /// Returns whether a transparent window's visual state is opaque or not.
 306         /// </summary>
 307         /// <returns>True if the window's visual state is opaque, false otherwise.</returns>
 308         /// <remarks> The return value has no meaning on an opaque window. </remarks>
 309         /// <since_tizen> 3 </since_tizen>
 310         public bool IsOpaqueState()
 311         {
 312             bool ret = NDalicPINVOKE.IsOpaqueState(swigCPtr);
 313             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 314             return ret;
 315         }
 316
 317         /// <summary>
 318         /// Sets a window's screen off mode.
 319         /// </summary>
 320         /// <param name="screenOffMode">The screen mode.</param>
 321         /// <returns>True if no error occurred, false otherwise.</returns>
 322         /// <since_tizen> 4 </since_tizen>
 323         public bool SetScreenOffMode(ScreenOffMode screenOffMode)
 324         {
 325             bool ret = NDalicPINVOKE.SetScreenOffMode(swigCPtr, (int)screenOffMode);
 326             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 327             return ret;
 328         }
 329
 330         /// <summary>
 331         /// Gets the screen mode of the window.
 332         /// </summary>
 333         /// <returns>The screen off mode.</returns>
 334         /// <since_tizen> 4 </since_tizen>
 335         public ScreenOffMode GetScreenOffMode()
 336         {
 337             ScreenOffMode ret = (ScreenOffMode)NDalicPINVOKE.GetScreenOffMode(swigCPtr);
 338             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 339             return ret;
 340         }
 341
 342         /// <summary>
 343         /// Sets preferred brightness of the window.
 344         /// </summary>
 345         /// <param name="brightness">The preferred brightness (0 to 100).</param>
 346         /// <returns>True if no error occurred, false otherwise.</returns>
 347         /// <since_tizen> 3 </since_tizen>
 348         public bool SetBrightness(int brightness)
 349         {
 350             bool ret = NDalicPINVOKE.SetBrightness(swigCPtr, brightness);
 351             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 352             return ret;
 353         }
 354
 355         /// <summary>
 356         /// Gets the preferred brightness of the window.
 357         /// </summary>
 358         /// <returns>The preferred brightness.</returns>
 359         /// <since_tizen> 3 </since_tizen>
 360         public int GetBrightness()
 361         {
 362             int ret = NDalicPINVOKE.GetBrightness(swigCPtr);
 363             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 364             return ret;
 365         }
 366
 367         /// <summary>
 368         /// The focus changed event argument.
 369         /// </summary>
 370         /// <since_tizen> 3 </since_tizen>
 371         public class FocusChangedEventArgs : EventArgs
 372         {
 373             /// <summary>
 374             /// FocusGained flag.
 375             /// </summary>
 376             /// <since_tizen> 3 </since_tizen>
 377             public bool FocusGained
 378             {
 379                 get;
 380                 set;
 381             }
 382         }
 383
 384         private WindowFocusChangedEventCallbackType _windowFocusChangedEventCallback;
 385         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 386         private delegate void WindowFocusChangedEventCallbackType(bool focusGained);
 387         private event EventHandler<FocusChangedEventArgs> _windowFocusChangedEventHandler;
 388
 389         /// <summary>
 390         /// FocusChanged event.
 391         /// </summary>
 392         /// <since_tizen> 3 </since_tizen>
 393         public event EventHandler<FocusChangedEventArgs> FocusChanged
 394         {
 395             add
 396             {
 397                 if (_windowFocusChangedEventHandler == null)
 398                 {
 399                     _windowFocusChangedEventCallback = OnWindowFocusedChanged;
 400                     WindowFocusChangedSignal().Connect(_windowFocusChangedEventCallback);
 401                 }
 402
 403                 _windowFocusChangedEventHandler += value;
 404             }
 405             remove
 406             {
 407                 _windowFocusChangedEventHandler -= value;
 408
 409                 if (_windowFocusChangedEventHandler == null && WindowFocusChangedSignal().Empty() == false && _windowFocusChangedEventCallback != null)
 410                 {
 411                     WindowFocusChangedSignal().Disconnect(_windowFocusChangedEventCallback);
 412                 }
 413             }
 414         }
 415
 416         private void OnWindowFocusedChanged(bool focusGained)
 417         {
 418             FocusChangedEventArgs e = new FocusChangedEventArgs();
 419
 420             e.FocusGained = focusGained;
 421
 422             if (_windowFocusChangedEventHandler != null)
 423             {
 424                 _windowFocusChangedEventHandler(this, e);
 425             }
 426         }
 427
 428         /// <summary>
 429         /// Gets/Sets a window title.
 430         /// </summary>
 431         /// <since_tizen> 4 </since_tizen>
 432         public string Title
 433         {
 434             get
 435             {
 436                 return _windowTitle;
 437             }
 438             set
 439             {
 440                 _windowTitle = value;
 441                 SetClass(_windowTitle, "");
 442             }
 443         }
 444
 445         internal WindowFocusSignalType WindowFocusChangedSignal()
 446         {
 447             WindowFocusSignalType ret = new WindowFocusSignalType(NDalicPINVOKE.FocusChangedSignal(swigCPtr), false);
 448             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 449             return ret;
 450         }
 451
 452         internal Window(Rectangle windowPosition, string name, bool isTransparent) : this(NDalicPINVOKE.Window_New__SWIG_0(Rectangle.getCPtr(windowPosition), name, isTransparent), true)
 453         {
 454             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 455         }
 456
 457         internal Window(Rectangle windowPosition, string name) : this(NDalicPINVOKE.Window_New__SWIG_1(Rectangle.getCPtr(windowPosition), name), true)
 458         {
 459             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 460         }
 461
 462         internal Window(Rectangle windowPosition, string name, string className, bool isTransparent) : this(NDalicPINVOKE.Window_New__SWIG_2(Rectangle.getCPtr(windowPosition), name, className, isTransparent), true)
 463         {
 464             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 465         }
 466
 467         internal Window(Rectangle windowPosition, string name, string className) : this(NDalicPINVOKE.Window_New__SWIG_3(Rectangle.getCPtr(windowPosition), name, className), true)
 468         {
 469             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 470         }
 471
 472         internal void ShowIndicator(Window.IndicatorVisibleMode visibleMode)
 473         {
 474             NDalicPINVOKE.Window_ShowIndicator(swigCPtr, (int)visibleMode);
 475             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 476         }
 477
 478         internal void SetIndicatorBackgroundOpacity(Window.IndicatorBackgroundOpacity opacity)
 479         {
 480             NDalicPINVOKE.Window_SetIndicatorBgOpacity(swigCPtr, (int)opacity);
 481             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 482         }
 483
 484         internal void RotateIndicator(Window.WindowOrientation orientation)
 485         {
 486             NDalicPINVOKE.Window_RotateIndicator(swigCPtr, (int)orientation);
 487             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 488         }
 489
 490         /// <summary>
 491         /// Sets the window name and the class string.
 492         /// </summary>
 493         /// <param name="name">The name of the window.</param>
 494         /// <param name="klass">The class of the window.</param>
 495         /// <since_tizen> 4 </since_tizen>
 496         public void SetClass(string name, string klass)
 497         {
 498             NDalicPINVOKE.Window_SetClass(swigCPtr, name, klass);
 499             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 500         }
 501
 502         /// <summary>
 503         /// Raises the window to the top of the window stack.
 504         /// </summary>
 505         /// <since_tizen> 3 </since_tizen>
 506         public void Raise()
 507         {
 508             NDalicPINVOKE.Window_Raise(swigCPtr);
 509             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 510         }
 511
 512         /// <summary>
 513         /// Lowers the window to the bottom of the window stack.
 514         /// </summary>
 515         /// <since_tizen> 3 </since_tizen>
 516         public void Lower()
 517         {
 518             NDalicPINVOKE.Window_Lower(swigCPtr);
 519             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 520         }
 521
 522         /// <summary>
 523         /// Activates the window to the top of the window stack even it is iconified.
 524         /// </summary>
 525         /// <since_tizen> 3 </since_tizen>
 526         public void Activate()
 527         {
 528             NDalicPINVOKE.Window_Activate(swigCPtr);
 529             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 530         }
 531
 532         internal void AddAvailableOrientation(Window.WindowOrientation orientation)
 533         {
 534             NDalicPINVOKE.Window_AddAvailableOrientation(swigCPtr, (int)orientation);
 535             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 536         }
 537
 538         internal void RemoveAvailableOrientation(Window.WindowOrientation orientation)
 539         {
 540             NDalicPINVOKE.Window_RemoveAvailableOrientation(swigCPtr, (int)orientation);
 541             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 542         }
 543
 544         internal void SetPreferredOrientation(Window.WindowOrientation orientation)
 545         {
 546             NDalicPINVOKE.Window_SetPreferredOrientation(swigCPtr, (int)orientation);
 547             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 548         }
 549
 550         internal Window.WindowOrientation GetPreferredOrientation()
 551         {
 552             Window.WindowOrientation ret = (Window.WindowOrientation)NDalicPINVOKE.Window_GetPreferredOrientation(swigCPtr);
 553             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 554             return ret;
 555         }
 556
 557         internal DragAndDropDetector GetDragAndDropDetector()
 558         {
 559             DragAndDropDetector ret = new DragAndDropDetector(NDalicPINVOKE.Window_GetDragAndDropDetector(swigCPtr), true);
 560             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 561             return ret;
 562         }
 563
 564         internal Any GetNativeHandle()
 565         {
 566             Any ret = new Any(NDalicPINVOKE.Window_GetNativeHandle(swigCPtr), true);
 567             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 568             return ret;
 569         }
 570
 571         internal WindowFocusSignalType FocusChangedSignal()
 572         {
 573             WindowFocusSignalType ret = new WindowFocusSignalType(NDalicPINVOKE.FocusChangedSignal(swigCPtr), false);
 574             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 575             return ret;
 576         }
 577
 578         /// <summary>
 579         /// Gets the default ( root ) layer.
 580         /// </summary>
 581         /// <returns>The root layer.</returns>
 582         /// <since_tizen> 3 </since_tizen>
 583         public Layer GetDefaultLayer()
 584         {
 585             return this.GetRootLayer();
 586         }
 587
 588         internal void Add(Layer layer)
 589         {
 590             NDalicPINVOKE.Stage_Add(stageCPtr, Layer.getCPtr(layer));
 591             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 592
 593             LayersChildren.Add(layer);
 594         }
 595
 596         internal void Remove(Layer layer)
 597         {
 598             NDalicPINVOKE.Stage_Remove(stageCPtr, Layer.getCPtr(layer));
 599             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 600
 601             LayersChildren.Remove(layer);
 602         }
 603
 604         /// <summary>
 605         /// Add a child view to window.
 606         /// </summary>
 607         /// <param name="view">the child should be added to the window.</param>
 608         /// <since_tizen> 3 </since_tizen>
 609         public void Add(View view)
 610         {
 611             NDalicPINVOKE.Actor_Add( rootLayoutCPtr, View.getCPtr(view) );
 612             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 613             this.GetRootLayer().AddViewToLayerList(view); // Maintain the children list in the Layer
 614             view.InternalParent = this.GetRootLayer();
 615         }
 616
 617         /// <summary>
 618         /// Remove a child view from window.
 619         /// </summary>
 620         /// <param name="view">the child to be removed.</param>
 621         /// <since_tizen> 3 </since_tizen>
 622         public void Remove(View view)
 623         {
 624             NDalicPINVOKE.Actor_Remove( rootLayoutCPtr, View.getCPtr(view) );
 625             this.GetRootLayer().RemoveViewFromLayerList(view); // Maintain the children list in the Layer
 626             view.InternalParent = null;
 627         }
 628
 629         internal Vector2 GetSize()
 630         {
 631             Vector2 ret = new Vector2(NDalicPINVOKE.Stage_GetSize(stageCPtr), true);
 632             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 633             return ret;
 634         }
 635
 636         internal RenderTaskList GetRenderTaskList()
 637         {
 638             RenderTaskList ret = new RenderTaskList(NDalicPINVOKE.Stage_GetRenderTaskList(stageCPtr), true);
 639             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 640             return ret;
 641         }
 642
 643         /// <summary>
 644         /// Queries the number of on-window layers.
 645         /// </summary>
 646         /// <returns>The number of layers.</returns>
 647         /// <remarks>Note that a default layer is always provided (count >= 1).</remarks>
 648         internal uint GetLayerCount()
 649         {
 650             if (LayersChildren == null || LayersChildren.Count < 0)
 651                 return 0;
 652
 653             return (uint) LayersChildren.Count;
 654         }
 655
 656         /// <summary>
 657         /// Retrieves the layer at a specified depth.
 658         /// </summary>
 659         /// <param name="depth">The layer's depth index.</param>
 660         /// <returns>The layer found at the given depth.</returns>
 661         /// <since_tizen> 3 </since_tizen>
 662         public Layer GetLayer(uint depth)
 663         {
 664             if (depth < LayersChildren.Count)
 665             {
 666                 Layer ret = LayersChildren[Convert.ToInt32(depth)];
 667                 return ret;
 668             }
 669             else
 670             {
 671                 return null;
 672             }
 673         }
 674
 675         internal Layer GetRootLayer()
 676         {
 677             // Window.IsInstalled() is actually true only when called from event thread and
 678             // Core has been initialized, not when Stage is ready.
 679             if (_rootLayer == null && Window.IsInstalled())
 680             {
 681                 _rootLayer = new Layer(NDalicPINVOKE.Stage_GetRootLayer(stageCPtr), true);
 682                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 683                 LayersChildren.Add(_rootLayer);
 684             }
 685             return _rootLayer;
 686         }
 687
 688         internal void SetBackgroundColor(Vector4 color)
 689         {
 690             NDalicPINVOKE.Stage_SetBackgroundColor(stageCPtr, Vector4.getCPtr(color));
 691             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 692         }
 693
 694         internal Vector4 GetBackgroundColor()
 695         {
 696             Vector4 ret = new Vector4(NDalicPINVOKE.Stage_GetBackgroundColor(stageCPtr), true);
 697             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 698             return ret;
 699         }
 700
 701         internal Vector2 GetDpi()
 702         {
 703             Vector2 ret = new Vector2(NDalicPINVOKE.Stage_GetDpi(stageCPtr), true);
 704             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 705             return ret;
 706         }
 707
 708         internal ObjectRegistry GetObjectRegistry()
 709         {
 710             ObjectRegistry ret = new ObjectRegistry(NDalicPINVOKE.Stage_GetObjectRegistry(stageCPtr), true);
 711             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 712             return ret;
 713         }
 714
 715         /// <summary>
 716         /// Keep rendering for at least the given amount of time.
 717         /// </summary>
 718         /// <param name="durationSeconds">Time to keep rendering, 0 means render at least one more frame.</param>
 719         /// <since_tizen> 3 </since_tizen>
 720         public void KeepRendering(float durationSeconds)
 721         {
 722             NDalicPINVOKE.Stage_KeepRendering(stageCPtr, durationSeconds);
 723             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 724         }
 725
 726         internal KeyEventSignal KeyEventSignal()
 727         {
 728             KeyEventSignal ret = new KeyEventSignal(NDalicPINVOKE.Stage_KeyEventSignal(stageCPtr), false);
 729             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 730             return ret;
 731         }
 732
 733         internal VoidSignal EventProcessingFinishedSignal()
 734         {
 735             VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_EventProcessingFinishedSignal(stageCPtr), false);
 736             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 737             return ret;
 738         }
 739
 740         internal TouchSignal TouchSignal()
 741         {
 742             TouchSignal ret = new TouchSignal(NDalicPINVOKE.Stage_TouchSignal(stageCPtr), false);
 743             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 744             return ret;
 745         }
 746
 747         internal TouchDataSignal TouchDataSignal()
 748         {
 749             TouchDataSignal ret = new TouchDataSignal(NDalicPINVOKE.Actor_TouchSignal(Layer.getCPtr(GetRootLayer())), false);
 750             if (NDalicPINVOKE.SWIGPendingException.Pending)
 751                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 752             return ret;
 753         }
 754
 755         private StageWheelSignal WheelEventSignal()
 756         {
 757             StageWheelSignal ret = new StageWheelSignal(NDalicPINVOKE.Stage_WheelEventSignal(stageCPtr), false);
 758             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 759             return ret;
 760         }
 761
 762
 763         private WheelSignal StageWheelEventSignal()
 764         {
 765             WheelSignal ret = new WheelSignal(NDalicPINVOKE.Actor_WheelEventSignal(Layer.getCPtr(this.GetRootLayer())), false);
 766             if (NDalicPINVOKE.SWIGPendingException.Pending)
 767                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 768             return ret;
 769         }
 770
 771
 772         internal VoidSignal ContextLostSignal()
 773         {
 774             VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextLostSignal(stageCPtr), false);
 775             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 776             return ret;
 777         }
 778
 779         internal VoidSignal ContextRegainedSignal()
 780         {
 781             VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextRegainedSignal(stageCPtr), false);
 782             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 783             return ret;
 784         }
 785
 786         internal VoidSignal SceneCreatedSignal()
 787         {
 788             VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_SceneCreatedSignal(stageCPtr), false);
 789             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 790             return ret;
 791         }
 792
 793         internal ResizedSignal ResizedSignal()
 794         {
 795             ResizedSignal ret = new ResizedSignal(NDalicManualPINVOKE.Window_ResizedSignal(swigCPtr), false);
 796             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 797             return ret;
 798         }
 799
 800         internal static Vector4 DEFAULT_BACKGROUND_COLOR
 801         {
 802             get
 803             {
 804                 global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEFAULT_BACKGROUND_COLOR_get();
 805                 Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
 806                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 807                 return ret;
 808             }
 809         }
 810
 811         internal static Vector4 DEBUG_BACKGROUND_COLOR
 812         {
 813             get
 814             {
 815                 global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEBUG_BACKGROUND_COLOR_get();
 816                 Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
 817                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 818                 return ret;
 819             }
 820         }
 821
 822         private static readonly Window instance = Application.Instance.GetWindow();
 823
 824         /// <summary>
 825         /// The stage instance property (read-only).<br />
 826         /// Gets the current window.<br />
 827         /// </summary>
 828         /// <since_tizen> 3 </since_tizen>
 829         public static Window Instance
 830         {
 831             get
 832             {
 833                 return instance;
 834             }
 835         }
 836
 837         /// <summary>
 838         /// Grabs the key specified by a key for a window only when a window is the topmost window.<br />
 839         /// This function can be used for following example scenarios: <br />
 840         /// - Mobile - Using volume up or down as zoom up or down in camera apps.<br />
 841         /// </summary>
 842         /// <param name="DaliKey">The key code to grab.</param>
 843         /// <returns>True if the grab succeeds.</returns>
 844         /// <since_tizen> 3 </since_tizen>
 845         public bool GrabKeyTopmost(int DaliKey)
 846         {
 847             bool ret = NDalicManualPINVOKE.GrabKeyTopmost(HandleRef.ToIntPtr(this.swigCPtr), DaliKey);
 848             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 849             return ret;
 850         }
 851
 852         /// <summary>
 853         /// Ungrabs the key specified by a key for the window.<br />
 854         /// Note: If this function is called between key down and up events of a grabbed key, an application doesn't receive the key up event.<br />
 855         /// </summary>
 856         /// <param name="DaliKey">The key code to ungrab.</param>
 857         /// <returns>True if the ungrab succeeds.</returns>
 858         /// <since_tizen> 3 </since_tizen>
 859         public bool UngrabKeyTopmost(int DaliKey)
 860         {
 861             bool ret = NDalicManualPINVOKE.UngrabKeyTopmost(HandleRef.ToIntPtr(this.swigCPtr), DaliKey);
 862             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 863             return ret;
 864         }
 865
 866         /// <summary>
 867         ///  Grabs the key specified by a key for a window in a GrabMode. <br />
 868         ///  Details: This function can be used for following example scenarios: <br />
 869         ///  - TV - A user might want to change the volume or channel of the background TV contents while focusing on the foregrund app. <br />
 870         ///  - Mobile - When a user presses the Home key, the homescreen appears regardless of the current foreground app. <br />
 871         ///  - Mobile - Using the volume up or down as zoom up or down in camera apps. <br />
 872         /// </summary>
 873         /// <param name="DaliKey">The key code to grab.</param>
 874         /// <param name="GrabMode">The grab mode for the key.</param>
 875         /// <returns>True if the grab succeeds.</returns>
 876         /// <since_tizen> 3 </since_tizen>
 877         public bool GrabKey(int DaliKey, KeyGrabMode GrabMode)
 878         {
 879             bool ret = NDalicManualPINVOKE.GrabKey(HandleRef.ToIntPtr(this.swigCPtr), DaliKey, (int)GrabMode);
 880             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 881             return ret;
 882         }
 883
 884         /// <summary>
 885         /// Ungrabs the key specified by a key for a window.<br />
 886         /// Note: If this function is called between key down and up events of a grabbed key, an application doesn't receive the key up event. <br />
 887         /// </summary>
 888         /// <param name="DaliKey">The key code to ungrab.</param>
 889         /// <returns>True if the ungrab succeeds.</returns>
 890         /// <since_tizen> 3 </since_tizen>
 891         public bool UngrabKey(int DaliKey)
 892         {
 893             bool ret = NDalicManualPINVOKE.UngrabKey(HandleRef.ToIntPtr(this.swigCPtr), DaliKey);
 894             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 895             return ret;
 896         }
 897
 898         /// <summary>
 899         /// Sets keyboard repeat information.
 900         /// </summary>
 901         /// <param name="rate">The key repeat rate value in seconds</param>
 902         /// <param name="delay">The key repeat delay value in seconds</param>
 903         /// <returns>True if setting the keyboard repeat succeeds.</returns>
 904         /// <since_tizen> 5 </since_tizen>
 905         public bool SetKeyboardRepeatInfo(float rate, float delay)
 906         {
 907             bool ret = NDalicManualPINVOKE.SetKeyboardRepeatInfo(rate, delay);
 908             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 909             return ret;
 910         }
 911
 912         /// <summary>
 913         /// Gets keyboard repeat information.
 914         /// </summary>
 915         /// <param name="rate">The key repeat rate value in seconds</param>
 916         /// <param name="delay">The key repeat delay value in seconds</param>
 917         /// <returns>True if setting the keyboard repeat succeeds.</returns>
 918         /// <since_tizen> 5 </since_tizen>
 919         public bool GetKeyboardRepeatInfo(out float rate, out float delay)
 920         {
 921             bool ret = NDalicManualPINVOKE.GetKeyboardRepeatInfo(out rate, out delay);
 922             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 923             return ret;
 924         }
 925
 926         internal System.IntPtr GetNativeWindowHandler()
 927         {
 928             System.IntPtr ret = NDalicManualPINVOKE.GetNativeWindowHandler(HandleRef.ToIntPtr(this.swigCPtr));
 929             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 930             return ret;
 931         }
 932
 933         /// <summary>
 934         /// Enumeration for orientation of the window is the way in which a rectangular page is oriented for normal viewing.
 935         /// </summary>
 936         /// <since_tizen> 3 </since_tizen>
 937         public enum WindowOrientation
 938         {
 939             /// <summary>
 940             /// Portrait orientation. The height of the display area is greater than the width.
 941             /// </summary>
 942             /// <since_tizen> 3 </since_tizen>
 943             Portrait = 0,
 944             /// <summary>
 945             /// Landscape orientation. A wide view area is needed.
 946             /// </summary>
 947             /// <since_tizen> 3 </since_tizen>
 948             Landscape = 90,
 949             /// <summary>
 950             /// Portrait inverse orientation.
 951             /// </summary>
 952             /// <since_tizen> 3 </since_tizen>
 953             PortraitInverse = 180,
 954             /// <summary>
 955             /// Landscape inverse orientation.
 956             /// </summary>
 957             /// <since_tizen> 3 </since_tizen>
 958             LandscapeInverse = 270
 959         }
 960
 961         /// <summary>
 962         /// Enumeration for the key grab mode for platform-level APIs.
 963         /// </summary>
 964         /// <since_tizen> 3 </since_tizen>
 965         public enum KeyGrabMode
 966         {
 967             /// <summary>
 968             /// Grabs a key only when on the top of the grabbing-window stack mode.
 969             /// </summary>
 970             Topmost = 0,
 971             /// <summary>
 972             /// Grabs a key together with the other client window(s) mode.
 973             /// </summary>
 974             Shared,
 975             /// <summary>
 976             /// Grabs a key exclusively regardless of the grabbing-window's position on the window stack with the possibility of overriding the grab by the other client window mode.
 977             /// </summary>
 978             OverrideExclusive,
 979             /// <summary>
 980             /// Grabs a key exclusively regardless of the grabbing-window's position on the window stack mode.
 981             /// </summary>
 982             Exclusive
 983         };
 984
 985         /// <summary>
 986         /// Enumeration for opacity of the indicator.
 987         /// </summary>
 988         internal enum IndicatorBackgroundOpacity
 989         {
 990             Opaque = 100,
 991             Translucent = 50,
 992             Transparent = 0
 993         }
 994
 995         /// <summary>
 996         /// Enumeration for visible mode of the indicator.
 997         /// </summary>
 998         internal enum IndicatorVisibleMode
 999         {
1000             Invisible = 0,
1001             Visible = 1,
1002             Auto = 2
1003         }
1004
1005         /// <summary>
1006         /// The touch event argument.
1007         /// </summary>
1008         /// <since_tizen> 3 </since_tizen>
1009         public class TouchEventArgs : EventArgs
1010         {
1011             private Touch _touch;
1012
1013             /// <summary>
1014             /// Touch.
1015             /// </summary>
1016             /// <since_tizen> 3 </since_tizen>
1017             public Touch Touch
1018             {
1019                 get
1020                 {
1021                     return _touch;
1022                 }
1023                 set
1024                 {
1025                     _touch = value;
1026                 }
1027             }
1028         }
1029
1030
1031         private event EventHandler<TouchEventArgs> _rootLayerTouchDataEventHandler;
1032         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1033         private delegate bool RootLayerTouchDataCallbackType(IntPtr view, IntPtr touchData);
1034         private RootLayerTouchDataCallbackType _rootLayerTouchDataCallback;
1035         /// <summary>
1036         /// This event is emitted when the screen is touched and when the touch ends.<br />
1037         /// If there are multiple touch points, then this will be emitted when the first touch occurs and
1038         /// then when the last finger is lifted.<br />
1039         /// An interrupted event will also be emitted (if it occurs).<br />
1040         /// </summary>
1041         /// <since_tizen> 3 </since_tizen>
1042         public event EventHandler<TouchEventArgs> TouchEvent
1043         {
1044             add
1045             {
1046                 if (_rootLayerTouchDataEventHandler == null)
1047                 {
1048                     _rootLayerTouchDataCallback = OnWindowTouch;
1049                     this.TouchDataSignal().Connect(_rootLayerTouchDataCallback);
1050                 }
1051                 _rootLayerTouchDataEventHandler += value;
1052             }
1053             remove
1054             {
1055                 _rootLayerTouchDataEventHandler -= value;
1056                 if (_rootLayerTouchDataEventHandler == null && TouchSignal().Empty() == false)
1057                 {
1058                     this.TouchDataSignal().Disconnect(_rootLayerTouchDataCallback);
1059                 }
1060             }
1061         }
1062
1063         private bool OnWindowTouch(IntPtr view, IntPtr touchData)
1064         {
1065             if (touchData == global::System.IntPtr.Zero)
1066             {
1067                 NUILog.Error("touchData should not be null!");
1068                 return false;
1069             }
1070
1071             TouchEventArgs e = new TouchEventArgs();
1072
1073             e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
1074
1075             if (_rootLayerTouchDataEventHandler != null)
1076             {
1077                 _rootLayerTouchDataEventHandler(this, e);
1078             }
1079             return false;
1080         }
1081
1082         /// <summary>
1083         /// Wheel event arguments.
1084         /// </summary>
1085         /// <since_tizen> 3 </since_tizen>
1086         public class WheelEventArgs : EventArgs
1087         {
1088             private Wheel _wheel;
1089
1090             /// <summary>
1091             /// Wheel.
1092             /// </summary>
1093             /// <since_tizen> 3 </since_tizen>
1094             public Wheel Wheel
1095             {
1096                 get
1097                 {
1098                     return _wheel;
1099                 }
1100                 set
1101                 {
1102                     _wheel = value;
1103                 }
1104             }
1105         }
1106
1107         private event EventHandler<WheelEventArgs> _stageWheelHandler;
1108
1109         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1110         private delegate bool WheelEventCallbackType(IntPtr view, IntPtr wheelEvent);
1111         private WheelEventCallbackType _wheelEventCallback;
1112
1113         /// <summary>
1114         /// This event is emitted when the wheel event is received.
1115         /// </summary>
1116         /// <since_tizen> 3 </since_tizen>
1117         public event EventHandler<WheelEventArgs> WheelEvent
1118         {
1119             add
1120             {
1121                 if (_stageWheelHandler == null)
1122                 {
1123                     _wheelEventCallback = OnStageWheel;
1124                     this.StageWheelEventSignal().Connect(_wheelEventCallback);
1125                 }
1126                 _stageWheelHandler += value;
1127             }
1128             remove
1129             {
1130                 _stageWheelHandler -= value;
1131                 if (_stageWheelHandler == null && StageWheelEventSignal().Empty() == false)
1132                 {
1133                     this.StageWheelEventSignal().Disconnect(_wheelEventCallback);
1134                 }
1135             }
1136         }
1137
1138         private bool OnStageWheel(IntPtr rootLayer, IntPtr wheelEvent)
1139         {
1140             if (wheelEvent == global::System.IntPtr.Zero)
1141         {
1142                 NUILog.Error("wheelEvent should not be null!");
1143                 return true;
1144             }
1145
1146             WheelEventArgs e = new WheelEventArgs();
1147
1148             e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
1149
1150             if (_stageWheelHandler != null)
1151             {
1152                 _stageWheelHandler(this, e);
1153             }
1154             return true;
1155         }
1156
1157         /// <summary>
1158         /// Key event arguments.
1159         /// </summary>
1160         /// <since_tizen> 3 </since_tizen>
1161         public class KeyEventArgs : EventArgs
1162         {
1163             private Key _key;
1164
1165             /// <summary>
1166             /// Key.
1167             /// </summary>
1168             /// <since_tizen> 3 </since_tizen>
1169             public Key Key
1170             {
1171                 get
1172                 {
1173                     return _key;
1174                 }
1175                 set
1176                 {
1177                     _key = value;
1178                 }
1179             }
1180         }
1181
1182         private event EventHandler<KeyEventArgs> _stageKeyHandler;
1183         private EventCallbackDelegateType1 _stageKeyCallbackDelegate;
1184
1185         /// <summary>
1186         /// This event is emitted when the key event is received.
1187         /// </summary>
1188         /// <since_tizen> 3 </since_tizen>
1189         public event EventHandler<KeyEventArgs> KeyEvent
1190         {
1191             add
1192             {
1193                 if (_stageKeyHandler == null)
1194                 {
1195                     _stageKeyCallbackDelegate = OnStageKey;
1196                     KeyEventSignal().Connect(_stageKeyCallbackDelegate);
1197                 }
1198                 _stageKeyHandler += value;
1199             }
1200             remove
1201             {
1202                 _stageKeyHandler -= value;
1203                 if (_stageKeyHandler == null && KeyEventSignal().Empty() == false)
1204                 {
1205                     KeyEventSignal().Disconnect(_stageKeyCallbackDelegate);
1206                 }
1207             }
1208         }
1209
1210         // Callback for Stage KeyEventsignal
1211         private void OnStageKey(IntPtr data)
1212         {
1213             KeyEventArgs e = new KeyEventArgs();
1214
1215             if (data != null)
1216             {
1217                 e.Key = Tizen.NUI.Key.GetKeyFromPtr(data);
1218             }
1219
1220             if (_stageKeyHandler != null)
1221             {
1222                 //here we send all data to user event handlers
1223                 _stageKeyHandler(this, e);
1224             }
1225         }
1226
1227
1228         private event EventHandler _stageEventProcessingFinishedEventHandler;
1229         private EventCallbackDelegateType0 _stageEventProcessingFinishedEventCallbackDelegate;
1230
1231         internal event EventHandler EventProcessingFinished
1232         {
1233             add
1234             {
1235                 if (_stageEventProcessingFinishedEventHandler == null)
1236                 {
1237                     _stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished;
1238                     EventProcessingFinishedSignal().Connect(_stageEventProcessingFinishedEventCallbackDelegate);
1239                 }
1240                 _stageEventProcessingFinishedEventHandler += value;
1241
1242             }
1243             remove
1244             {
1245                 _stageEventProcessingFinishedEventHandler -= value;
1246                 if (_stageEventProcessingFinishedEventHandler == null && EventProcessingFinishedSignal().Empty() == false)
1247                 {
1248                     EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate);
1249                 }
1250             }
1251         }
1252
1253         // Callback for Stage EventProcessingFinishedSignal
1254         private void OnEventProcessingFinished()
1255         {
1256             if (_stageEventProcessingFinishedEventHandler != null)
1257             {
1258                 _stageEventProcessingFinishedEventHandler(this, null);
1259             }
1260         }
1261
1262
1263         private EventHandler _stageContextLostEventHandler;
1264         private EventCallbackDelegateType0 _stageContextLostEventCallbackDelegate;
1265
1266         internal event EventHandler ContextLost
1267         {
1268             add
1269             {
1270                 if (_stageContextLostEventHandler == null)
1271                 {
1272                     _stageContextLostEventCallbackDelegate = OnContextLost;
1273                     ContextLostSignal().Connect(_stageContextLostEventCallbackDelegate);
1274                 }
1275                 _stageContextLostEventHandler += value;
1276             }
1277             remove
1278             {
1279                 _stageContextLostEventHandler -= value;
1280                 if (_stageContextLostEventHandler == null && ContextLostSignal().Empty() == false)
1281                 {
1282                     ContextLostSignal().Disconnect(_stageContextLostEventCallbackDelegate);
1283                 }
1284             }
1285         }
1286
1287         // Callback for Stage ContextLostSignal
1288         private void OnContextLost()
1289         {
1290             if (_stageContextLostEventHandler != null)
1291             {
1292                 _stageContextLostEventHandler(this, null);
1293             }
1294         }
1295
1296
1297         private EventHandler _stageContextRegainedEventHandler;
1298         private EventCallbackDelegateType0 _stageContextRegainedEventCallbackDelegate;
1299
1300         internal event EventHandler ContextRegained
1301         {
1302             add
1303             {
1304                 if (_stageContextRegainedEventHandler == null)
1305                 {
1306                     _stageContextRegainedEventCallbackDelegate = OnContextRegained;
1307                     ContextRegainedSignal().Connect(_stageContextRegainedEventCallbackDelegate);
1308                 }
1309                 _stageContextRegainedEventHandler += value;
1310             }
1311             remove
1312             {
1313                 _stageContextRegainedEventHandler -= value;
1314                 if (_stageContextRegainedEventHandler == null && ContextRegainedSignal().Empty() == false)
1315                 {
1316                     this.ContextRegainedSignal().Disconnect(_stageContextRegainedEventCallbackDelegate);
1317                 }
1318             }
1319         }
1320
1321         // Callback for Stage ContextRegainedSignal
1322         private void OnContextRegained()
1323         {
1324             if (_stageContextRegainedEventHandler != null)
1325             {
1326                 _stageContextRegainedEventHandler(this, null);
1327             }
1328         }
1329
1330
1331         private EventHandler _stageSceneCreatedEventHandler;
1332         private EventCallbackDelegateType0 _stageSceneCreatedEventCallbackDelegate;
1333
1334         internal event EventHandler SceneCreated
1335         {
1336             add
1337             {
1338                 if (_stageSceneCreatedEventHandler == null)
1339                 {
1340                     _stageSceneCreatedEventCallbackDelegate = OnSceneCreated;
1341                     SceneCreatedSignal().Connect(_stageSceneCreatedEventCallbackDelegate);
1342                 }
1343                 _stageSceneCreatedEventHandler += value;
1344             }
1345             remove
1346             {
1347                 _stageSceneCreatedEventHandler -= value;
1348                 if (_stageSceneCreatedEventHandler == null && SceneCreatedSignal().Empty() == false)
1349                 {
1350                     SceneCreatedSignal().Disconnect(_stageSceneCreatedEventCallbackDelegate);
1351                 }
1352             }
1353         }
1354
1355         // Callback for Stage SceneCreatedSignal
1356         private void OnSceneCreated()
1357         {
1358             if (_stageSceneCreatedEventHandler != null)
1359             {
1360                 _stageSceneCreatedEventHandler(this, null);
1361             }
1362         }
1363
1364         /// <summary>
1365         /// This resized event arguments.
1366         /// </summary>
1367         /// <since_tizen> 3 </since_tizen>
1368         public class ResizedEventArgs : EventArgs
1369         {
1370             Size2D _windowSize;
1371
1372             /// <summary>
1373             /// This window size.
1374             /// </summary>
1375             /// <since_tizen> 4 </since_tizen>
1376             public Size2D WindowSize
1377             {
1378                 get
1379                 {
1380                     return _windowSize;
1381                 }
1382                 set
1383                 {
1384                     _windowSize = value;
1385                 }
1386             }
1387         }
1388
1389         private WindowResizedEventCallbackType _windowResizedEventCallback;
1390         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1391         private delegate void WindowResizedEventCallbackType(IntPtr windowSize);
1392         private event EventHandler<ResizedEventArgs> _windowResizedEventHandler;
1393
1394         /// <summary>
1395         /// This event is emitted when the window resized.
1396         /// </summary>
1397         /// <since_tizen> 3 </since_tizen>
1398         public event EventHandler<ResizedEventArgs> Resized
1399         {
1400             add
1401             {
1402                 if (_windowResizedEventHandler == null)
1403                 {
1404                     _windowResizedEventCallback = OnResized;
1405                     ResizedSignal().Connect(_windowResizedEventCallback);
1406                 }
1407
1408                 _windowResizedEventHandler += value;
1409             }
1410             remove
1411             {
1412                 _windowResizedEventHandler -= value;
1413
1414                 if (_windowResizedEventHandler == null && ResizedSignal().Empty() == false && _windowResizedEventCallback != null)
1415                 {
1416                     ResizedSignal().Disconnect(_windowResizedEventCallback);
1417                 }
1418             }
1419         }
1420
1421         private void OnResized(IntPtr windowSize)
1422         {
1423             ResizedEventArgs e = new ResizedEventArgs();
1424             var val = new Uint16Pair(windowSize, false);
1425             e.WindowSize = new Size2D(val.GetWidth(), val.GetHeight());
1426             val.Dispose();
1427
1428             if (_windowResizedEventHandler != null)
1429             {
1430                 _windowResizedEventHandler(this, e);
1431             }
1432         }
1433
1434         internal void SetWindowSize(Size2D size)
1435         {
1436             var val = new Uint16Pair((uint)size.Width, (uint)size.Height);
1437             NDalicManualPINVOKE.SetSize(swigCPtr, Uint16Pair.getCPtr(val));
1438
1439             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1440         }
1441
1442         internal Size2D GetWindowSize()
1443         {
1444             var val = new Uint16Pair(NDalicManualPINVOKE.GetSize(swigCPtr), false);
1445             Size2D ret = new Size2D(val.GetWidth(), val.GetHeight());
1446
1447             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1448             return ret;
1449         }
1450
1451         internal void SetPosition(Position2D position)
1452         {
1453             var val = new Uint16Pair((uint)position.X, (uint)position.Y);
1454             NDalicManualPINVOKE.SetPosition(swigCPtr, Uint16Pair.getCPtr(val));
1455
1456             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1457         }
1458
1459         internal Position2D GetPosition()
1460         {
1461             var val = new Uint16Pair(NDalicManualPINVOKE.GetPosition(swigCPtr), true);
1462             Position2D ret = new Position2D(val.GetX(), val.GetY());
1463
1464             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1465             return ret;
1466         }
1467
1468         /// <summary>
1469         /// Sets whether the window is transparent or not.
1470         /// </summary>
1471         /// <param name="transparent">Whether the window is transparent.</param>
1472         /// <since_tizen> 5 </since_tizen>
1473         public void SetTransparency(bool transparent) {
1474             NDalicManualPINVOKE.SetTransparency(swigCPtr, transparent);
1475             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1476         }
1477
1478         /// <summary>
1479         /// The window size property (read-only).
1480         /// </summary>
1481         /// <since_tizen> 3 </since_tizen>
1482         public Size2D Size
1483         {
1484             get
1485             {
1486                 Size2D ret = GetSize();
1487                 return ret;
1488             }
1489         }
1490
1491         /// <summary>
1492         /// The background color property.
1493         /// </summary>
1494         /// <since_tizen> 3 </since_tizen>
1495         public Color BackgroundColor
1496         {
1497             set
1498             {
1499                 SetBackgroundColor(value);
1500             }
1501             get
1502             {
1503                 Color ret = GetBackgroundColor();
1504                 return ret;
1505             }
1506         }
1507
1508         /// <summary>
1509         /// The DPI property (read-only).<br />
1510         /// Retrieves the DPI of the display device to which the Window is connected.<br />
1511         /// </summary>
1512         /// <since_tizen> 3 </since_tizen>
1513         public Vector2 Dpi
1514         {
1515             get
1516             {
1517                 return GetDpi();
1518             }
1519         }
1520
1521         /// <summary>
1522         /// The layer count property (read-only).<br />
1523         /// Queries the number of on-Window layers.<br />
1524         /// </summary>
1525         /// <since_tizen> 3 </since_tizen>
1526         public uint LayerCount
1527         {
1528             get
1529             {
1530                 return GetLayerCount();
1531             }
1532         }
1533
1534
1535         /// <summary>
1536         /// Adds a layer to the stage.
1537         /// </summary>
1538         /// <param name="layer">Layer to add.</param>
1539         /// <since_tizen> 3 </since_tizen>
1540         public void AddLayer(Layer layer)
1541         {
1542             NDalicPINVOKE.Stage_Add(stageCPtr, Layer.getCPtr(layer));
1543             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1544
1545             LayersChildren.Add(layer);
1546         }
1547
1548         /// <summary>
1549         /// Removes a layer from the stage.
1550         /// </summary>
1551         /// <param name="layer">Layer to remove.</param>
1552         /// <since_tizen> 3 </since_tizen>
1553         public void RemoveLayer(Layer layer)
1554         {
1555             NDalicPINVOKE.Stage_Remove(stageCPtr, Layer.getCPtr(layer));
1556             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1557
1558             LayersChildren.Remove(layer);
1559         }
1560
1561         /// <summary>
1562         /// Please do not use! this will be deprecated
1563         /// </summary>
1564         /// <since_tizen> 3 </since_tizen>
1565         [Obsolete("Please do not use! This will be deprecated! Please use FocusChangedEventArgs instead! " +
1566             "Like: " +
1567             "Window.Instance.FocusChanged = OnFocusChanged; " +
1568             "private void OnFocusChanged(object source, Window.FocusChangedEventArgs args) {...}")]
1569         [EditorBrowsable(EditorBrowsableState.Never)]
1570         public class WindowFocusChangedEventArgs : EventArgs
1571         {
1572             /// <summary>
1573             /// Please do not use! this will be deprecated
1574             /// </summary>
1575             /// <since_tizen> 3 </since_tizen>
1576             public bool FocusGained
1577             {
1578                 get;
1579                 set;
1580             }
1581         }
1582
1583         private WindowFocusChangedEventCallbackType _windowFocusChangedEventCallback2;
1584         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1585         private delegate void WindowFocusChangedEventCallbackType2(bool focusGained);
1586         private event EventHandler<WindowFocusChangedEventArgs> _windowFocusChangedEventHandler2;
1587
1588         /// <summary>
1589         /// Please do not use! this will be deprecated. Please use 'FocusChanged' event instead.
1590         /// </summary>
1591         /// <since_tizen> 3 </since_tizen>
1592         /// Please do not use! this will be deprecated!
1593         /// Instead please use FocusChanged.
1594         [Obsolete("Please do not use! This will be deprecated! Please use FocusChanged instead! " +
1595             "Like: " +
1596             "Window.Instance.FocusChanged = OnFocusChanged; " +
1597             "private void OnFocusChanged(object source, Window.FocusChangedEventArgs args) {...}")]
1598         [EditorBrowsable(EditorBrowsableState.Never)]
1599         public event EventHandler<WindowFocusChangedEventArgs> WindowFocusChanged
1600         {
1601             add
1602             {
1603                 if (_windowFocusChangedEventHandler2 == null)
1604                 {
1605                     _windowFocusChangedEventCallback2 = OnWindowFocusedChanged2;
1606                     WindowFocusChangedSignal().Connect(_windowFocusChangedEventCallback2);
1607                 }
1608
1609                 _windowFocusChangedEventHandler2 += value;
1610             }
1611             remove
1612             {
1613                 _windowFocusChangedEventHandler2 -= value;
1614
1615                 if (_windowFocusChangedEventHandler2 == null && WindowFocusChangedSignal().Empty() == false && _windowFocusChangedEventCallback2 != null)
1616                 {
1617                     WindowFocusChangedSignal().Disconnect(_windowFocusChangedEventCallback2);
1618                 }
1619             }
1620         }
1621
1622         private void OnWindowFocusedChanged2(bool focusGained)
1623         {
1624             WindowFocusChangedEventArgs e = new WindowFocusChangedEventArgs();
1625
1626             e.FocusGained = focusGained;
1627
1628             if (_windowFocusChangedEventHandler2 != null)
1629             {
1630                 _windowFocusChangedEventHandler2(this, e);
1631             }
1632         }
1633
1634         /// <summary>
1635         /// Gets or sets a size of the window.
1636         /// </summary>
1637         /// <since_tizen> 4 </since_tizen>
1638         public Size2D WindowSize
1639         {
1640             get
1641             {
1642                 return GetWindowSize();
1643             }
1644             set
1645             {
1646                 SetWindowSize(value);
1647             }
1648         }
1649
1650         /// <summary>
1651         /// Gets or sets a position of the window.
1652         /// </summary>
1653         /// <since_tizen> 4 </since_tizen>
1654         public Position2D WindowPosition
1655         {
1656             get
1657             {
1658                 return GetPosition();
1659             }
1660             set
1661             {
1662                 SetPosition(value);
1663             }
1664         }
1665
1666         /// <summary>
1667         /// Feed a key-event into the window.
1668         /// </summary>
1669         /// <param name="keyEvent">The key event to feed.</param>
1670         /// <since_tizen> 5 </since_tizen>
1671         public void FeedKey(Key keyEvent)
1672         {
1673             NDalicManualPINVOKE.Window_FeedKeyEvent(Key.getCPtr(keyEvent));
1674             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1675         }
1676
1677         /// <summary>
1678         /// Feed a key-event into the window.
1679         /// </summary>
1680         /// <param name="keyEvent">The key event to feed.</param>
1681         /// <since_tizen> 4 </since_tizen>
1682         [Obsolete("Please do not use! This will be deprecated! Please use FeedKey(Key keyEvent) instead!")]
1683         public static void FeedKeyEvent(Key keyEvent)
1684         {
1685             NDalicManualPINVOKE.Window_FeedKeyEvent(Key.getCPtr(keyEvent));
1686             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1687         }
1688
1689         /// <summary>
1690         /// Allows at least one more render, even when paused.
1691         /// The window should be shown, not minimised.
1692         /// </summary>
1693         /// <since_tizen> 4 </since_tizen>
1694         public void RenderOnce()
1695         {
1696             NDalicManualPINVOKE.Window_RenderOnce(swigCPtr);
1697             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1698         }
1699
1700         /// <summary>
1701         /// Contains and encapsulates Native Window handle.
1702         /// </summary>
1703         /// <since_tizen> 4 </since_tizen>
1704         public class SafeNativeWindowHandle : SafeHandle
1705         {
1706             /// <summary>
1707             /// Contructor, Native window handle is set to handle.
1708             /// </summary>
1709             /// <since_tizen> 4 </since_tizen>
1710             public SafeNativeWindowHandle() : base(IntPtr.Zero, false)
1711             {
1712                 SetHandle(Tizen.NUI.Window.Instance.GetNativeWindowHandler());
1713             }
1714             /// <summary>
1715             /// Null check if the handle is valid or not.
1716             /// </summary>
1717             /// <since_tizen> 4 </since_tizen>
1718             public override bool IsInvalid
1719             {
1720                 get
1721                 {
1722                     return this.handle == IntPtr.Zero;
1723                 }
1724             }
1725             /// <summary>
1726             /// Release handle itself.
1727             /// </summary>
1728             /// <returns>true when released successfully.</returns>
1729             /// <since_tizen> 4 </since_tizen>
1730             protected override bool ReleaseHandle()
1731             {
1732                 return true;
1733             }
1734         }
1735
1736     }
1737 }