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

   1 /** Copyright (c) 2017 Samsung Electronics Co., Ltd.
   2 *
   3 * Licensed under the Apache License, Version 2.0 (the "License");
   4 * you may not use this file except in compliance with the License.
   5 * You may obtain a copy of the License at
   6 *
   7 * http://www.apache.org/licenses/LICENSE-2.0
   8 *
   9 * Unless required by applicable law or agreed to in writing, software
  10 * distributed under the License is distributed on an "AS IS" BASIS,
  11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 * See the License for the specific language governing permissions and
  13 * limitations under the License.
  14 *
  15 */
  16
  17 namespace Tizen.NUI
  18 {
  19
  20     using System;
  21     using System.Runtime.InteropServices;
  22     using Tizen.NUI.BaseComponents;
  23
  24     /// <summary>
  25     /// The window class is used internally for drawing.<br>
  26     /// A Window has an orientation and indicator properties.<br>
  27     /// </summary>
  28     public class Window : BaseHandle
  29     {
  30         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  31         private global::System.Runtime.InteropServices.HandleRef stageCPtr;
  32         private Layer _rootLayer;
  33
  34         internal Window(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Window_SWIGUpcast(cPtr), cMemoryOwn)
  35         {
  36             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  37             if (NDalicPINVOKE.Stage_IsInstalled())
  38             {
  39                 stageCPtr = new global::System.Runtime.InteropServices.HandleRef(this, NDalicPINVOKE.Stage_GetCurrent());
  40             }
  41         }
  42
  43         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Window obj)
  44         {
  45             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  46         }
  47
  48         /// <summary>
  49         /// To make Window instance be disposed.
  50         /// </summary>
  51         protected override void Dispose(DisposeTypes type)
  52         {
  53             if(disposed)
  54             {
  55                 return;
  56             }
  57
  58             if(type == DisposeTypes.Explicit)
  59             {
  60                 //Called by User
  61                 //Release your own managed resources here.
  62                 //You should release all of your own disposable objects here.
  63             }
  64
  65             //Release your own unmanaged resources here.
  66             //You should not access any managed member here except static instance.
  67             //because the execution order of Finalizes is non-deterministic.
  68
  69             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  70             {
  71                 if (swigCMemOwn)
  72                 {
  73                     swigCMemOwn = false;
  74                     NDalicPINVOKE.delete_Window(swigCPtr);
  75                     NDalicPINVOKE.delete_Stage(stageCPtr);
  76                 }
  77                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  78             }
  79
  80             base.Dispose(type);
  81         }
  82
  83         internal static Window GetCurrent()
  84         {
  85             Window ret = new Window(NDalicPINVOKE.Stage_GetCurrent(), true);
  86             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  87             return ret;
  88         }
  89
  90        internal static bool IsInstalled()
  91        {
  92             bool ret = NDalicPINVOKE.Stage_IsInstalled();
  93             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  94             return ret;
  95        }
  96
  97         [Obsolete("Please do not use! this will be internal method")]
  98         public void SetAcceptFocus(bool accept)
  99         {
 100             NDalicPINVOKE.SetAcceptFocus(swigCPtr, accept);
 101             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 102         }
 103
 104         [Obsolete("Please do not use! this will be internal method")]
 105         public bool IsFocusAcceptable()
 106         {
 107             return NDalicPINVOKE.IsFocusAcceptable(swigCPtr);
 108             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 109         }
 110
 111         /// <summary>
 112         /// Shows the window if it is hidden.
 113         /// </summary>
 114         public void Show()
 115         {
 116             NDalicPINVOKE.Show(swigCPtr);
 117             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 118         }
 119
 120         /// <summary>
 121         /// Hides the window if it is showing.
 122         /// </summary>
 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 windoe is visible</returns>
 133         public bool IsVisible()
 134         {
 135             bool temp = NDalicPINVOKE.IsVisible(swigCPtr);
 136             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 137             return temp;
 138         }
 139
 140         /// <summary>
 141         /// Gets the count of supported auxiliary hints of the window.
 142         /// </summary>
 143         /// <returns>The number of supported auxiliary hints.</returns>
 144         public uint GetSupportedAuxiliaryHintCount() {
 145             uint ret = NDalicPINVOKE.GetSupportedAuxiliaryHintCount(swigCPtr);
 146             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 147             return ret;
 148         }
 149
 150         /// <summary>
 151         /// Gets the supported auxiliary hint string of the window.
 152         /// </summary>
 153         /// <param name="index">The index of the supported auxiliary hint lists.</param>
 154         /// <returns>The auxiliary hint string of the index.</returns>
 155         public string GetSupportedAuxiliaryHint(uint index) {
 156             string ret = NDalicPINVOKE.GetSupportedAuxiliaryHint(swigCPtr, index);
 157             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 158             return ret;
 159         }
 160
 161         /// <summary>
 162         /// Creates an auxiliary hint of the window.
 163         /// </summary>
 164         /// <param name="hint">The auxiliary hint string.</param>
 165         /// <param name="value">The value string.</param>
 166         /// <returns>The ID of created auxiliary hint, or 0 on failure.</returns>
 167         public uint AddAuxiliaryHint(string hint, string value) {
 168             uint ret = NDalicPINVOKE.AddAuxiliaryHint(swigCPtr, hint, value);
 169             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 170             return ret;
 171         }
 172
 173         /// <summary>
 174         /// Removes an auxiliary hint of the window.
 175         /// </summary>
 176         /// <param name="id">The ID of the auxiliary hint.</param>
 177         /// <returns>True if no error occurred, false otherwise.</returns>
 178         public bool RemoveAuxiliaryHint(uint id) {
 179             bool ret = NDalicPINVOKE.RemoveAuxiliaryHint(swigCPtr, id);
 180             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 181             return ret;
 182         }
 183
 184         /// <summary>
 185         /// Changes a value of the auxiliary hint.
 186         /// </summary>
 187         /// <param name="id">The auxiliary hint ID.</param>
 188         /// <param name="value">The value string to be set.</param>
 189         /// <returns>True if no error occurred, false otherwise.</returns>
 190         public bool SetAuxiliaryHintValue(uint id, string value) {
 191             bool ret = NDalicPINVOKE.SetAuxiliaryHintValue(swigCPtr, id, value);
 192             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 193             return ret;
 194         }
 195
 196         /// <summary>
 197         /// Gets a value of the auxiliary hint.
 198         /// </summary>
 199         /// <param name="id">The auxiliary hint ID.</param>
 200         /// <returns>The string value of the auxiliary hint ID, or an empty string if none exists.</returns>
 201         public string GetAuxiliaryHintValue(uint id) {
 202             string ret = NDalicPINVOKE.GetAuxiliaryHintValue(swigCPtr, id);
 203             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 204             return ret;
 205         }
 206
 207         /// <summary>
 208         /// Gets an ID of the auxiliary hint string.
 209         /// </summary>
 210         /// <param name="hint">The auxiliary hint string.</param>
 211         /// <returns>The ID of auxiliary hint string, or 0 on failure.</returns>
 212         public uint GetAuxiliaryHintId(string hint) {
 213             uint ret = NDalicPINVOKE.GetAuxiliaryHintId(swigCPtr, hint);
 214             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 215             return ret;
 216         }
 217
 218         /// <summary>
 219         /// Sets a region to accept input events.
 220         /// </summary>
 221         /// <param name="inputRegion">The region to accept input events.</param>
 222         public void SetInputRegion(Rectangle inputRegion) {
 223             NDalicPINVOKE.SetInputRegion(swigCPtr, Rectangle.getCPtr(inputRegion));
 224             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 225         }
 226
 227         /// <summary>
 228         /// Gets/Sets a window type.
 229         /// </summary>
 230         public WindowType Type
 231         {
 232             get
 233             {
 234                 WindowType ret = (WindowType)NDalicPINVOKE.GetType(swigCPtr);
 235                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 236                 return ret;
 237             }
 238             set
 239             {
 240                 NDalicPINVOKE.SetType(swigCPtr, (int)value);
 241                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 242             }
 243         }
 244
 245         /// <summary>
 246         /// Sets a priority level for the specified notification window.
 247         /// </summary>
 248         /// <param name="level">The notification window level.</param>
 249         /// <returns>True if no error occurred, false otherwise.</returns>
 250         public bool SetNotificationLevel(NotificationLevel level) {
 251             bool ret = NDalicPINVOKE.SetNotificationLevel(swigCPtr, (int)level);
 252             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 253             return ret;
 254         }
 255
 256         /// <summary>
 257         /// Gets a priority level for the specified notification window.
 258         /// </summary>
 259         /// <returns>The notification window level.</returns>
 260         public NotificationLevel GetNotificationLevel() {
 261             NotificationLevel ret = (NotificationLevel)NDalicPINVOKE.GetNotificationLevel(swigCPtr);
 262             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 263             return ret;
 264         }
 265
 266         /// <summary>
 267         /// Sets a transparent window's visual state to opaque.
 268         /// </summary>
 269         /// <param name="opaque">Whether the window's visual state is opaque.</param>
 270         public void SetOpaqueState(bool opaque) {
 271             NDalicPINVOKE.SetOpaqueState(swigCPtr, opaque);
 272             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 273         }
 274
 275         /// <summary>
 276         /// Returns whether a transparent window's visual state is opaque or not.
 277         /// </summary>
 278         /// <returns>True if the window's visual state is opaque, false otherwise.</returns>
 279         public bool IsOpaqueState() {
 280             bool ret = NDalicPINVOKE.IsOpaqueState(swigCPtr);
 281             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 282             return ret;
 283         }
 284
 285         /// <summary>
 286         /// Sets a window's screen mode.
 287         /// </summary>
 288         /// <param name="screenMode">The screen mode.</param>
 289         /// <returns>True if no error occurred, false otherwise.</returns>
 290         public bool SetScreenMode(ScreenMode screenMode) {
 291             bool ret = NDalicPINVOKE.SetScreenMode(swigCPtr, (int)screenMode);
 292             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 293             return ret;
 294         }
 295
 296         /// <summary>
 297         /// Gets a screen mode of the window.
 298         /// </summary>
 299         /// <returns>The screen mode.</returns>
 300         public ScreenMode GetScreenMode() {
 301             ScreenMode ret = (ScreenMode)NDalicPINVOKE.GetScreenMode(swigCPtr);
 302             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 303             return ret;
 304         }
 305
 306         /// <summary>
 307         /// Sets preferred brightness of the window.
 308         /// </summary>
 309         /// <param name="brightness">The preferred brightness (0 to 100).</param>
 310         /// <returns>True if no error occurred, false otherwise.</returns>
 311         public bool SetBrightness(int brightness) {
 312             bool ret = NDalicPINVOKE.SetBrightness(swigCPtr, brightness);
 313             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 314             return ret;
 315         }
 316
 317         /// <summary>
 318         /// Gets preffered brightness of the window.
 319         /// </summary>
 320         /// <returns>The preffered brightness.</returns>
 321         public int GetBrightness() {
 322             int ret = NDalicPINVOKE.GetBrightness(swigCPtr);
 323             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 324             return ret;
 325         }
 326
 327         public class FocusChangedEventArgs : EventArgs
 328         {
 329             public bool FocusGained
 330             {
 331                 get;
 332                 set;
 333             }
 334         }
 335
 336         private WindowFocusChangedEventCallbackType _windowFocusChangedEventCallback;
 337         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 338         private delegate void WindowFocusChangedEventCallbackType(bool focusGained);
 339         private event EventHandler<FocusChangedEventArgs> _windowFocusChangedEventHandler;
 340
 341         public event EventHandler<FocusChangedEventArgs> FocusChanged
 342         {
 343             add
 344             {
 345                 if (_windowFocusChangedEventHandler == null)
 346                 {
 347                     _windowFocusChangedEventCallback = OnWindowFocusedChanged;
 348                     WindowFocusChangedSignal().Connect(_windowFocusChangedEventCallback);
 349                 }
 350
 351                 _windowFocusChangedEventHandler += value;
 352             }
 353             remove
 354             {
 355                 _windowFocusChangedEventHandler -= value;
 356
 357                 if (_windowFocusChangedEventHandler == null && WindowFocusChangedSignal().Empty() == false && _windowFocusChangedEventCallback != null)
 358                 {
 359                     WindowFocusChangedSignal().Disconnect(_windowFocusChangedEventCallback);
 360                 }
 361             }
 362         }
 363
 364         private void OnWindowFocusedChanged(bool focusGained)
 365         {
 366             FocusChangedEventArgs e = new FocusChangedEventArgs();
 367
 368             e.FocusGained = focusGained;
 369
 370             if (_windowFocusChangedEventHandler != null)
 371             {
 372                 _windowFocusChangedEventHandler(this, e);
 373             }
 374         }
 375
 376         internal WindowFocusSignalType WindowFocusChangedSignal()
 377         {
 378             WindowFocusSignalType ret = new WindowFocusSignalType(NDalicPINVOKE.FocusChangedSignal(swigCPtr), false);
 379             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 380             return ret;
 381         }
 382
 383         internal Window(Rectangle windowPosition, string name, bool isTransparent) : this(NDalicPINVOKE.Window_New__SWIG_0(Rectangle.getCPtr(windowPosition), name, isTransparent), true)
 384         {
 385             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 386         }
 387
 388         internal Window(Rectangle windowPosition, string name) : this(NDalicPINVOKE.Window_New__SWIG_1(Rectangle.getCPtr(windowPosition), name), true)
 389         {
 390             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 391         }
 392
 393         internal Window(Rectangle windowPosition, string name, string className, bool isTransparent) : this(NDalicPINVOKE.Window_New__SWIG_2(Rectangle.getCPtr(windowPosition), name, className, isTransparent), true)
 394         {
 395             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 396         }
 397
 398         internal Window(Rectangle windowPosition, string name, string className) : this(NDalicPINVOKE.Window_New__SWIG_3(Rectangle.getCPtr(windowPosition), name, className), true)
 399         {
 400             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 401         }
 402
 403         internal void ShowIndicator(Window.IndicatorVisibleMode visibleMode)
 404         {
 405             NDalicPINVOKE.Window_ShowIndicator(swigCPtr, (int)visibleMode);
 406             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 407         }
 408
 409         internal void SetIndicatorBackgroundOpacity(Window.IndicatorBackgroundOpacity opacity)
 410         {
 411             NDalicPINVOKE.Window_SetIndicatorBgOpacity(swigCPtr, (int)opacity);
 412             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 413         }
 414
 415         internal void RotateIndicator(Window.WindowOrientation orientation)
 416         {
 417             NDalicPINVOKE.Window_RotateIndicator(swigCPtr, (int)orientation);
 418             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 419         }
 420
 421         internal void SetClass(string name, string klass)
 422         {
 423             NDalicPINVOKE.Window_SetClass(swigCPtr, name, klass);
 424             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 425         }
 426
 427         /// <summary>
 428         /// Raises window to the top of Window stack.
 429         /// </summary>
 430         public void Raise()
 431         {
 432             NDalicPINVOKE.Window_Raise(swigCPtr);
 433             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 434         }
 435
 436         /// <summary>
 437         /// Lowers window to the bottom of Window stack.
 438         /// </summary>
 439         public void Lower()
 440         {
 441             NDalicPINVOKE.Window_Lower(swigCPtr);
 442             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 443         }
 444
 445         /// <summary>
 446         /// Activates window to the top of Window stack even it is iconified.
 447         /// </summary>
 448         public void Activate()
 449         {
 450             NDalicPINVOKE.Window_Activate(swigCPtr);
 451             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 452         }
 453
 454         internal void AddAvailableOrientation(Window.WindowOrientation orientation)
 455         {
 456             NDalicPINVOKE.Window_AddAvailableOrientation(swigCPtr, (int)orientation);
 457             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 458         }
 459
 460         internal void RemoveAvailableOrientation(Window.WindowOrientation orientation)
 461         {
 462             NDalicPINVOKE.Window_RemoveAvailableOrientation(swigCPtr, (int)orientation);
 463             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 464         }
 465
 466         internal void SetPreferredOrientation(Window.WindowOrientation orientation)
 467         {
 468             NDalicPINVOKE.Window_SetPreferredOrientation(swigCPtr, (int)orientation);
 469             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 470         }
 471
 472         internal Window.WindowOrientation GetPreferredOrientation()
 473         {
 474             Window.WindowOrientation ret = (Window.WindowOrientation)NDalicPINVOKE.Window_GetPreferredOrientation(swigCPtr);
 475             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 476             return ret;
 477         }
 478
 479         internal DragAndDropDetector GetDragAndDropDetector()
 480         {
 481             DragAndDropDetector ret = new DragAndDropDetector(NDalicPINVOKE.Window_GetDragAndDropDetector(swigCPtr), true);
 482             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 483             return ret;
 484         }
 485
 486         internal Any GetNativeHandle()
 487         {
 488             Any ret = new Any(NDalicPINVOKE.Window_GetNativeHandle(swigCPtr), true);
 489             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 490             return ret;
 491         }
 492
 493         internal WindowFocusSignalType FocusChangedSignal()
 494         {
 495             WindowFocusSignalType ret = new WindowFocusSignalType(NDalicPINVOKE.FocusChangedSignal(swigCPtr), false);
 496             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 497             return ret;
 498         }
 499
 500         /// <summary>
 501         /// Get default ( root ) layer.
 502         /// </summary>
 503         /// <returns>The root layer</returns>
 504         public Layer GetDefaultLayer()
 505         {
 506             return this.GetRootLayer();
 507         }
 508
 509         internal void Add(Layer layer)
 510         {
 511             NDalicPINVOKE.Stage_Add(stageCPtr, Layer.getCPtr(layer));
 512             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 513         }
 514
 515         internal void Remove(Layer layer)
 516         {
 517             NDalicPINVOKE.Stage_Remove(stageCPtr, Layer.getCPtr(layer));
 518             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 519         }
 520
 521         public void Add(View view)
 522         {
 523             NDalicPINVOKE.Stage_Add(stageCPtr, View.getCPtr(view));
 524             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 525         }
 526
 527         public void Remove(View view)
 528         {
 529             NDalicPINVOKE.Stage_Remove(stageCPtr, View.getCPtr(view));
 530             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 531         }
 532
 533         internal Vector2 GetSize()
 534         {
 535             Vector2 ret = new Vector2(NDalicPINVOKE.Stage_GetSize(stageCPtr), true);
 536             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 537             return ret;
 538         }
 539
 540         internal RenderTaskList GetRenderTaskList()
 541         {
 542             RenderTaskList ret = new RenderTaskList(NDalicPINVOKE.Stage_GetRenderTaskList(stageCPtr), true);
 543             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 544             return ret;
 545         }
 546
 547         /// <summary>
 548         /// Queries the number of on-window layers.
 549         /// </summary>
 550         /// <returns>The number of layers.</returns>
 551         /// <remarks>Note that a default layer is always provided (count >= 1).</remarks>
 552         internal uint GetLayerCount()
 553         {
 554             uint ret = NDalicPINVOKE.Stage_GetLayerCount(stageCPtr);
 555             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 556             return ret;
 557         }
 558
 559         public Layer GetLayer(uint depth)
 560         {
 561             Layer ret = new Layer(NDalicPINVOKE.Stage_GetLayer(stageCPtr, depth), true);
 562             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 563             return ret;
 564         }
 565
 566         internal Layer GetRootLayer()
 567         {
 568             if (_rootLayer == null)
 569                 _rootLayer = new Layer(NDalicPINVOKE.Stage_GetRootLayer(stageCPtr), true);
 570
 571
 572             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 573             return _rootLayer;
 574         }
 575
 576         internal void SetBackgroundColor(Vector4 color)
 577         {
 578             NDalicPINVOKE.Stage_SetBackgroundColor(stageCPtr, Vector4.getCPtr(color));
 579             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 580         }
 581
 582         internal Vector4 GetBackgroundColor()
 583         {
 584             Vector4 ret = new Vector4(NDalicPINVOKE.Stage_GetBackgroundColor(stageCPtr), true);
 585             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 586             return ret;
 587         }
 588
 589         internal Vector2 GetDpi()
 590         {
 591             Vector2 ret = new Vector2(NDalicPINVOKE.Stage_GetDpi(stageCPtr), true);
 592             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 593             return ret;
 594         }
 595
 596         internal ObjectRegistry GetObjectRegistry()
 597         {
 598             ObjectRegistry ret = new ObjectRegistry(NDalicPINVOKE.Stage_GetObjectRegistry(stageCPtr), true);
 599             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 600             return ret;
 601         }
 602
 603         /// <summary>
 604         /// Keep rendering for at least the given amount of time.
 605         /// </summary>
 606         /// <param name="durationSeconds">Time to keep rendering, 0 means render at least one more frame</param>
 607         public void KeepRendering(float durationSeconds)
 608         {
 609             NDalicPINVOKE.Stage_KeepRendering(stageCPtr, durationSeconds);
 610             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 611         }
 612
 613         internal KeyEventSignal KeyEventSignal()
 614         {
 615             KeyEventSignal ret = new KeyEventSignal(NDalicPINVOKE.Stage_KeyEventSignal(stageCPtr), false);
 616             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 617             return ret;
 618         }
 619
 620         internal VoidSignal EventProcessingFinishedSignal()
 621         {
 622             VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_EventProcessingFinishedSignal(stageCPtr), false);
 623             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 624             return ret;
 625         }
 626
 627         internal TouchSignal TouchSignal()
 628         {
 629             TouchSignal ret = new TouchSignal(NDalicPINVOKE.Stage_TouchSignal(stageCPtr), false);
 630             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 631             return ret;
 632         }
 633
 634         private StageWheelSignal WheelEventSignal()
 635         {
 636             StageWheelSignal ret = new StageWheelSignal(NDalicPINVOKE.Stage_WheelEventSignal(stageCPtr), false);
 637             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 638             return ret;
 639         }
 640
 641         internal VoidSignal ContextLostSignal()
 642         {
 643             VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextLostSignal(stageCPtr), false);
 644             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 645             return ret;
 646         }
 647
 648         internal VoidSignal ContextRegainedSignal()
 649         {
 650             VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextRegainedSignal(stageCPtr), false);
 651             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 652             return ret;
 653         }
 654
 655         internal VoidSignal SceneCreatedSignal()
 656         {
 657             VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_SceneCreatedSignal(stageCPtr), false);
 658             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 659             return ret;
 660         }
 661
 662         internal ResizedSignal ResizedSignal()
 663         {
 664             ResizedSignal ret = new ResizedSignal(NDalicManualPINVOKE.Window_ResizedSignal(stageCPtr), false);
 665             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 666             return ret;
 667         }
 668
 669         internal static Vector4 DEFAULT_BACKGROUND_COLOR
 670         {
 671             get
 672             {
 673                 global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEFAULT_BACKGROUND_COLOR_get();
 674                 Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
 675                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 676                 return ret;
 677             }
 678         }
 679
 680         internal static Vector4 DEBUG_BACKGROUND_COLOR
 681         {
 682             get
 683             {
 684                 global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEBUG_BACKGROUND_COLOR_get();
 685                 Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
 686                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 687                 return ret;
 688             }
 689         }
 690
 691         private static readonly Window instance = Application.Instance.GetWindow();
 692
 693         /// <summary>
 694         /// Stage instance property (read-only).<br>
 695         /// Gets the current Window.<br>
 696         /// </summary>
 697         public static Window Instance
 698         {
 699             get
 700             {
 701                 return instance;
 702             }
 703         }
 704
 705         /// <summary>
 706         /// Grabs the key specified by a key for a window only when a window is the topmost window. <br>
 707         /// This function can be used for following example scenarios: <br>
 708         /// - Mobile - Using volume up/down as zoom up/down in camera apps. <br>
 709         /// </summary>
 710         /// <param name="DaliKey">The key code to grab</param>
 711         /// <returns>true if the grab succeeds</returns>
 712         public bool GrabKeyTopmost(int DaliKey)
 713         {
 714             bool ret = NDalicManualPINVOKE.GrabKeyTopmost(HandleRef.ToIntPtr(this.swigCPtr), DaliKey);
 715             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 716             return ret;
 717         }
 718
 719         /// <summary>
 720         /// Ungrabs the key specified by a key for a window. <br>
 721         /// 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>
 722         /// </summary>
 723         /// <param name="DaliKey">The key code to ungrab</param>
 724         /// <returns>true if the ungrab succeeds</returns>
 725         public bool UngrabKeyTopmost(int DaliKey)
 726         {
 727             bool ret = NDalicManualPINVOKE.UngrabKeyTopmost(HandleRef.ToIntPtr(this.swigCPtr), DaliKey);
 728             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 729             return ret;
 730         }
 731
 732         /// <summary>
 733         ///  Grabs the key specified by a key for a window in a GrabMode. <br>
 734         ///  Details: This function can be used for following example scenarios: <br>
 735         ///  - TV - A user might want to change the volume or channel of the background TV contents while focusing on the foregrund app. <br>
 736         ///  - Mobile - When a user presses Home key, the homescreen appears regardless of current foreground app. <br>
 737         ///  - Mobile - Using volume up/down as zoom up/down in camera apps. <br>
 738         /// </summary>
 739         /// <param name="DaliKey">The key code to grab</param>
 740         /// <param name="GrabMode">The grab mode for the key</param>
 741         /// <returns>true if the grab succeeds</returns>
 742         public bool GrabKey(int DaliKey, KeyGrabMode GrabMode)
 743         {
 744             bool ret = NDalicManualPINVOKE.GrabKey(HandleRef.ToIntPtr(this.swigCPtr), DaliKey, (int)GrabMode);
 745             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 746             return ret;
 747         }
 748
 749         /// <summary>
 750         /// Ungrabs the key specified by a key for a window.  <br>
 751         /// 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>
 752         /// </summary>
 753         /// <param name="DaliKey">The key code to ungrab</param>
 754         /// <returns>true if the ungrab succeeds</returns>
 755         public bool UngrabKey(int DaliKey)
 756         {
 757             bool ret = NDalicManualPINVOKE.UngrabKey(HandleRef.ToIntPtr(this.swigCPtr), DaliKey);
 758             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 759             return ret;
 760         }
 761
 762         internal System.IntPtr GetNativeWindowHandler()
 763         {
 764             System.IntPtr ret = NDalicManualPINVOKE.GetNativeWindowHandler(HandleRef.ToIntPtr(this.swigCPtr));
 765             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 766             return ret;
 767         }
 768
 769         /// <summary>
 770         /// Enumeration for orientation of the window is the way in which a rectangular page is oriented for normal viewing.
 771         /// </summary>
 772         public enum WindowOrientation
 773         {
 774             Portrait = 0,
 775             Landscape = 90,
 776             PortraitInverse = 180,
 777             LandscapeInverse = 270
 778         }
 779
 780         /// <summary>
 781         /// Enumeration for key grab mode for platform-level APIs.
 782         /// </summary>
 783         public enum KeyGrabMode
 784         {
 785             /// <summary>
 786             /// Grab a key only when on the top of the grabbing-window stack mode.
 787             /// </summary>
 788             Topmost = 0,
 789             /// <summary>
 790             /// Grab a key together with the other client window(s) mode.
 791             /// </summary>
 792             Shared,
 793             /// <summary>
 794             /// Grab 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.
 795             /// </summary>
 796             OverrideExclusive,
 797             /// <summary>
 798             /// Grab a key exclusively regardless of the grabbing-window's position on the window stack mode.
 799             /// </summary>
 800             Exclusive
 801         };
 802
 803         /// <summary>
 804         /// Enumeration for opacity of the indicator.
 805         /// </summary>
 806         internal enum IndicatorBackgroundOpacity
 807         {
 808             Opaque = 100,
 809             Translucent = 50,
 810             Transparent = 0
 811         }
 812
 813         /// <summary>
 814         /// Enumeration for visible mode of the indicator.
 815         /// </summary>
 816         internal enum IndicatorVisibleMode
 817         {
 818             Invisible = 0,
 819             Visible = 1,
 820             Auto = 2
 821         }
 822
 823         /// <summary>
 824         /// Touch event argument.
 825         /// </summary>
 826         public class TouchEventArgs : EventArgs
 827         {
 828             private Touch _touch;
 829
 830             /// <summary>
 831             /// Touch.
 832             /// </summary>
 833             public Touch Touch
 834             {
 835                 get
 836                 {
 837                     return _touch;
 838                 }
 839                 set
 840                 {
 841                     _touch = value;
 842                 }
 843             }
 844         }
 845
 846         private event EventHandler<TouchEventArgs> _stageTouchHandler;
 847         private EventCallbackDelegateType1 _stageTouchCallbackDelegate;
 848
 849         /// <summary>
 850         /// This is emitted when the screen is touched and when the touch ends.<br>
 851         /// If there are multiple touch points, then this will be emitted when the first touch occurs and
 852         /// then when the last finger is lifted.<br>
 853         /// An interrupted event will also be emitted (if it occurs).<br>
 854         /// </summary>
 855         public event EventHandler<TouchEventArgs> TouchEvent
 856         {
 857             add
 858             {
 859                 lock (this)
 860                 {
 861                     _stageTouchHandler += value;
 862                     _stageTouchCallbackDelegate = OnStageTouch;
 863                     this.TouchSignal().Connect(_stageTouchCallbackDelegate);
 864                 }
 865             }
 866             remove
 867             {
 868                 lock (this)
 869                 {
 870                     if (_stageTouchHandler != null)
 871                     {
 872                         this.TouchSignal().Disconnect(_stageTouchCallbackDelegate);
 873                     }
 874                     _stageTouchHandler -= value;
 875                 }
 876             }
 877         }
 878
 879         private void OnStageTouch(IntPtr data)
 880         {
 881             TouchEventArgs e = new TouchEventArgs();
 882
 883             if (data != null)
 884             {
 885                 e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(data);
 886             }
 887
 888             if (_stageTouchHandler != null)
 889             {
 890                 _stageTouchHandler(this, e);
 891             }
 892         }
 893
 894         /// <summary>
 895         /// Wheel event arguments.
 896         /// </summary>
 897         public class WheelEventArgs : EventArgs
 898         {
 899             private Wheel _wheel;
 900
 901             /// <summary>
 902             /// Wheel.
 903             /// </summary>
 904             public Wheel Wheel
 905             {
 906                 get
 907                 {
 908                     return _wheel;
 909                 }
 910                 set
 911                 {
 912                     _wheel = value;
 913                 }
 914             }
 915         }
 916
 917         private event EventHandler<WheelEventArgs> _stageWheelHandler;
 918         private EventCallbackDelegateType1 _stageWheelCallbackDelegate;
 919
 920         /// <summary>
 921         /// Event emitted when wheel event is received.
 922         /// </summary>
 923         public event EventHandler<WheelEventArgs> WheelEvent
 924         {
 925             add
 926             {
 927                 if (_stageWheelHandler == null)
 928                 {
 929                     _stageWheelCallbackDelegate = OnStageWheel;
 930                     WheelEventSignal().Connect(_stageWheelCallbackDelegate);
 931                 }
 932                 _stageWheelHandler += value;
 933             }
 934             remove
 935             {
 936                 _stageWheelHandler -= value;
 937                 if (_stageWheelHandler == null && WheelEventSignal().Empty() == false)
 938                 {
 939                     WheelEventSignal().Disconnect(_stageWheelCallbackDelegate);
 940                 }
 941             }
 942         }
 943
 944         private void OnStageWheel(IntPtr data)
 945         {
 946             WheelEventArgs e = new WheelEventArgs();
 947
 948             if (data != null)
 949             {
 950                 e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(data);
 951             }
 952
 953             if (_stageWheelHandler != null)
 954             {
 955                 _stageWheelHandler(this, e);
 956             }
 957         }
 958
 959         /// <summary>
 960         /// Key event arguments.
 961         /// </summary>
 962         public class KeyEventArgs : EventArgs
 963         {
 964             private Key _key;
 965
 966             /// <summary>
 967             /// Key
 968             /// </summary>
 969             public Key Key
 970             {
 971                 get
 972                 {
 973                     return _key;
 974                 }
 975                 set
 976                 {
 977                     _key = value;
 978                 }
 979             }
 980         }
 981
 982         private event EventHandler<KeyEventArgs> _stageKeyHandler;
 983         private EventCallbackDelegateType1 _stageKeyCallbackDelegate;
 984
 985         /// <summary>
 986         /// Event emitted when key event is received.
 987         /// </summary>
 988         public event EventHandler<KeyEventArgs> KeyEvent
 989         {
 990             add
 991             {
 992                 if (_stageKeyHandler == null)
 993                 {
 994                     _stageKeyCallbackDelegate = OnStageKey;
 995                     KeyEventSignal().Connect(_stageKeyCallbackDelegate);
 996                 }
 997                 _stageKeyHandler += value;
 998             }
 999             remove
1000             {
1001                 _stageKeyHandler -= value;
1002                 if (_stageKeyHandler == null && KeyEventSignal().Empty() == false)
1003                 {
1004                     KeyEventSignal().Disconnect(_stageKeyCallbackDelegate);
1005                 }
1006             }
1007         }
1008
1009         // Callback for Stage KeyEventsignal
1010         private void OnStageKey(IntPtr data)
1011         {
1012             KeyEventArgs e = new KeyEventArgs();
1013
1014             if (data != null)
1015             {
1016                 e.Key = Tizen.NUI.Key.GetKeyFromPtr(data);
1017             }
1018
1019             if (_stageKeyHandler != null)
1020             {
1021                 //here we send all data to user event handlers
1022                 _stageKeyHandler(this, e);
1023             }
1024         }
1025
1026
1027         private event EventHandler _stageEventProcessingFinishedEventHandler;
1028         private EventCallbackDelegateType0 _stageEventProcessingFinishedEventCallbackDelegate;
1029
1030         internal event EventHandler EventProcessingFinished
1031         {
1032             add
1033             {
1034                 if (_stageEventProcessingFinishedEventHandler == null)
1035                 {
1036                     _stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished;
1037                     EventProcessingFinishedSignal().Connect(_stageEventProcessingFinishedEventCallbackDelegate);
1038                 }
1039                 _stageEventProcessingFinishedEventHandler += value;
1040
1041             }
1042             remove
1043             {
1044                 _stageEventProcessingFinishedEventHandler -= value;
1045                 if (_stageEventProcessingFinishedEventHandler == null && EventProcessingFinishedSignal().Empty() == false)
1046                 {
1047                     EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate);
1048                 }
1049             }
1050         }
1051
1052         // Callback for Stage EventProcessingFinishedSignal
1053         private void OnEventProcessingFinished()
1054         {
1055             if (_stageEventProcessingFinishedEventHandler != null)
1056             {
1057                 _stageEventProcessingFinishedEventHandler(this, null);
1058             }
1059         }
1060
1061
1062         private EventHandler _stageContextLostEventHandler;
1063         private EventCallbackDelegateType0 _stageContextLostEventCallbackDelegate;
1064
1065         internal event EventHandler ContextLost
1066         {
1067             add
1068             {
1069                 if (_stageContextLostEventHandler == null)
1070                 {
1071                     _stageContextLostEventCallbackDelegate = OnContextLost;
1072                     ContextLostSignal().Connect(_stageContextLostEventCallbackDelegate);
1073                 }
1074                 _stageContextLostEventHandler += value;
1075             }
1076             remove
1077             {
1078                 _stageContextLostEventHandler -= value;
1079                 if (_stageContextLostEventHandler == null && ContextLostSignal().Empty() == false)
1080                 {
1081                     ContextLostSignal().Disconnect(_stageContextLostEventCallbackDelegate);
1082                 }
1083             }
1084         }
1085
1086         // Callback for Stage ContextLostSignal
1087         private void OnContextLost()
1088         {
1089             if (_stageContextLostEventHandler != null)
1090             {
1091                 _stageContextLostEventHandler(this, null);
1092             }
1093         }
1094
1095
1096         private EventHandler _stageContextRegainedEventHandler;
1097         private EventCallbackDelegateType0 _stageContextRegainedEventCallbackDelegate;
1098
1099         internal event EventHandler ContextRegained
1100         {
1101             add
1102             {
1103                 if (_stageContextRegainedEventHandler == null)
1104                 {
1105                     _stageContextRegainedEventCallbackDelegate = OnContextRegained;
1106                     ContextRegainedSignal().Connect(_stageContextRegainedEventCallbackDelegate);
1107                 }
1108                 _stageContextRegainedEventHandler += value;
1109             }
1110             remove
1111             {
1112                 _stageContextRegainedEventHandler -= value;
1113                 if (_stageContextRegainedEventHandler == null && ContextRegainedSignal().Empty() == false)
1114                 {
1115                     this.ContextRegainedSignal().Disconnect(_stageContextRegainedEventCallbackDelegate);
1116                 }
1117             }
1118         }
1119
1120         // Callback for Stage ContextRegainedSignal
1121         private void OnContextRegained()
1122         {
1123             if (_stageContextRegainedEventHandler != null)
1124             {
1125                 _stageContextRegainedEventHandler(this, null);
1126             }
1127         }
1128
1129
1130         private EventHandler _stageSceneCreatedEventHandler;
1131         private EventCallbackDelegateType0 _stageSceneCreatedEventCallbackDelegate;
1132
1133         internal event EventHandler SceneCreated
1134         {
1135             add
1136             {
1137                 if (_stageSceneCreatedEventHandler == null)
1138                 {
1139                     _stageSceneCreatedEventCallbackDelegate = OnSceneCreated;
1140                     SceneCreatedSignal().Connect(_stageSceneCreatedEventCallbackDelegate);
1141                 }
1142                 _stageSceneCreatedEventHandler += value;
1143             }
1144             remove
1145             {
1146                 _stageSceneCreatedEventHandler -= value;
1147                 if (_stageSceneCreatedEventHandler == null && SceneCreatedSignal().Empty() == false)
1148                 {
1149                     SceneCreatedSignal().Disconnect(_stageSceneCreatedEventCallbackDelegate);
1150                 }
1151             }
1152         }
1153
1154         // Callback for Stage SceneCreatedSignal
1155         private void OnSceneCreated()
1156         {
1157             if (_stageSceneCreatedEventHandler != null)
1158             {
1159                 _stageSceneCreatedEventHandler(this, null);
1160             }
1161         }
1162
1163         public class ResizedEventArgs : EventArgs
1164         {
1165             Uint16Pair _windowSize;
1166
1167             public Uint16Pair WindowSize
1168             {
1169                 get
1170                 {
1171                     return _windowSize;
1172                 }
1173                 set
1174                 {
1175                     _windowSize = value;
1176                 }
1177             }
1178         }
1179
1180         private WindowResizedEventCallbackType _windowResizedEventCallback;
1181         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1182         private delegate void WindowResizedEventCallbackType(Uint16Pair windowSize);
1183         private event EventHandler<ResizedEventArgs> _windowResizedEventHandler;
1184
1185         public event EventHandler<ResizedEventArgs> Resized
1186         {
1187             add
1188             {
1189                 if (_windowResizedEventHandler == null)
1190                 {
1191                     _windowResizedEventCallback = OnResized;
1192                     ResizedSignal().Connect(_windowResizedEventCallback);
1193                 }
1194
1195                 _windowResizedEventHandler += value;
1196             }
1197             remove
1198             {
1199                 _windowResizedEventHandler -= value;
1200
1201                 if (_windowResizedEventHandler == null && ResizedSignal().Empty() == false && _windowResizedEventCallback != null)
1202                 {
1203                     ResizedSignal().Disconnect(_windowResizedEventCallback);
1204                 }
1205             }
1206         }
1207
1208         private void OnResized(Uint16Pair windowSize)
1209         {
1210             ResizedEventArgs e = new ResizedEventArgs();
1211             e.WindowSize = windowSize;
1212
1213             if (_windowResizedEventHandler != null)
1214             {
1215                 _windowResizedEventHandler(this, e);
1216             }
1217         }
1218
1219         internal void SetWindowSize(Uint16Pair size)
1220         {
1221             NDalicManualPINVOKE.SetSize(swigCPtr, Uint16Pair.getCPtr(size));
1222             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1223         }
1224
1225         internal Uint16Pair GetWindowSize()
1226         {
1227             Uint16Pair ret = new Uint16Pair(NDalicManualPINVOKE.GetSize(swigCPtr), true);
1228             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1229             return ret;
1230         }
1231
1232         internal void SetPosition(Uint16Pair position)
1233         {
1234             NDalicManualPINVOKE.SetPosition(swigCPtr, Uint16Pair.getCPtr(position));
1235             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1236         }
1237
1238         internal Uint16Pair GetPosition()
1239         {
1240             Uint16Pair ret = new Uint16Pair(NDalicManualPINVOKE.GetPosition(swigCPtr), true);
1241             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1242             return ret;
1243         }
1244
1245         /// <summary>
1246         /// Window size property (read-only).
1247         /// </summary>
1248         public Size2D Size
1249         {
1250             get
1251             {
1252                 Size2D ret = GetSize();
1253                 return ret;
1254             }
1255         }
1256
1257         /// <summary>
1258         /// Background color property.
1259         /// </summary>
1260         public Color BackgroundColor
1261         {
1262             set
1263             {
1264                 SetBackgroundColor(value);
1265             }
1266             get
1267             {
1268                 Color ret = GetBackgroundColor();
1269                 return ret;
1270             }
1271         }
1272
1273         /// <summary>
1274         /// Dpi property (read-only).<br>
1275         /// Retrieves the DPI of the display device to which the Window is connected.<br>
1276         /// </summary>
1277         public Vector2 Dpi
1278         {
1279             get
1280             {
1281                 return GetDpi();
1282             }
1283         }
1284
1285         /// <summary>
1286         /// Layer count property (read-only).<br>
1287         /// Queries the number of on-Window layers.<br>
1288         /// </summary>
1289         public uint LayerCount
1290         {
1291             get
1292             {
1293                 return GetLayerCount();
1294             }
1295         }
1296
1297
1298         /// <summary>
1299         /// Add layer to the Stage.
1300         /// </summary>
1301         /// <param name="layer">Layer to add</param>
1302         public void AddLayer(Layer layer)
1303         {
1304             NDalicPINVOKE.Stage_Add(stageCPtr, Layer.getCPtr(layer));
1305             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1306         }
1307
1308         /// <summary>
1309         /// Remove layer from the Stage.
1310         /// </summary>
1311         /// <param name="layer">Layer to remove</param>
1312         public void RemoveLayer(Layer layer)
1313         {
1314             NDalicPINVOKE.Stage_Remove(stageCPtr, Layer.getCPtr(layer));
1315             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1316         }
1317
1318         [Obsolete("Please do not use! this will be deprecated")]
1319         public class WindowFocusChangedEventArgs : EventArgs
1320         {
1321             public bool FocusGained
1322             {
1323                 get;
1324                 set;
1325             }
1326         }
1327
1328         private WindowFocusChangedEventCallbackType _windowFocusChangedEventCallback2;
1329         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1330         private delegate void WindowFocusChangedEventCallbackType2(bool focusGained);
1331         private event EventHandler<WindowFocusChangedEventArgs> _windowFocusChangedEventHandler2;
1332
1333         [Obsolete("Please do not use! this will be deprecated")]
1334         public event EventHandler<WindowFocusChangedEventArgs> WindowFocusChanged
1335         {
1336             add
1337             {
1338                 if (_windowFocusChangedEventHandler2 == null)
1339                 {
1340                     _windowFocusChangedEventCallback2 = OnWindowFocusedChanged2;
1341                     WindowFocusChangedSignal().Connect(_windowFocusChangedEventCallback2);
1342                 }
1343
1344                 _windowFocusChangedEventHandler2 += value;
1345             }
1346             remove
1347             {
1348                 _windowFocusChangedEventHandler2 -= value;
1349
1350                 if (_windowFocusChangedEventHandler2 == null && WindowFocusChangedSignal().Empty() == false && _windowFocusChangedEventCallback2 != null)
1351                 {
1352                     WindowFocusChangedSignal().Disconnect(_windowFocusChangedEventCallback2);
1353                 }
1354             }
1355         }
1356
1357         private void OnWindowFocusedChanged2(bool focusGained)
1358         {
1359             WindowFocusChangedEventArgs e = new WindowFocusChangedEventArgs();
1360
1361             e.FocusGained = focusGained;
1362
1363             if (_windowFocusChangedEventHandler2 != null)
1364             {
1365                 _windowFocusChangedEventHandler2(this, e);
1366             }
1367         }
1368
1369         /// <summary>
1370         /// Gets/Sets a size of the window.
1371         /// </summary>
1372         public Uint16Pair WindowSize
1373         {
1374             get
1375             {
1376                 return GetWindowSize();
1377             }
1378             set
1379             {
1380                 SetWindowSize(value);
1381             }
1382         }
1383
1384         /// <summary>
1385         /// Gets/Sets a position of the window.
1386         /// </summary>
1387         public Uint16Pair WindowPosition
1388         {
1389             get
1390             {
1391                 return GetPosition();
1392             }
1393             set
1394             {
1395                 SetPosition(value);
1396             }
1397         }
1398
1399
1400     }
1401 }