src/Tizen.NUI/src/public/BaseComponents/View.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.BaseComponents
  18 {
  19
  20     using System;
  21     using System.Runtime.InteropServices;
  22
  23     /// <summary>
  24     /// View is the base class for all views.
  25     /// </summary>
  26     public class View : Container
  27     {
  28         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  29
  30         internal View(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.View_SWIGUpcast(cPtr), cMemoryOwn)
  31         {
  32             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  33             PositionUsesPivotPoint = false;
  34         }
  35
  36         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(View obj)
  37         {
  38             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  39         }
  40
  41         // From Container Base class
  42
  43         /// <summary>
  44         /// Adds a child view to this View.
  45         /// </summary>
  46         /// <seealso cref="Container::Add()">
  47         /// </seealso>
  48         public override void Add(View child)
  49         {
  50             NDalicPINVOKE.Actor_Add(swigCPtr, View.getCPtr(child));
  51             if (NDalicPINVOKE.SWIGPendingException.Pending)
  52                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  53         }
  54
  55         /// <summary>
  56         /// Removes a child View from this View. If the view was not a child of this view, this is a no-op.
  57         /// </summary>
  58         /// <seealso cref="Container::Remove()">
  59         /// </seealso>
  60         public override void Remove(View child)
  61         {
  62             NDalicPINVOKE.Actor_Remove(swigCPtr, View.getCPtr(child));
  63             if (NDalicPINVOKE.SWIGPendingException.Pending)
  64                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  65         }
  66
  67         /// <summary>
  68         /// Retrieves child view by index.
  69         /// </summary>
  70         /// <seealso cref="Container::GetChildAt()">
  71         /// </seealso>
  72         public override View GetChildAt(uint index)
  73         {
  74             IntPtr cPtr = NDalicPINVOKE.Actor_GetChildAt(swigCPtr, index);
  75
  76             View ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as View;
  77
  78             if (NDalicPINVOKE.SWIGPendingException.Pending)
  79                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  80             return ret ?? null;
  81         }
  82
  83         /// <summary>
  84         /// Retrieves the number of children held by the view.
  85         /// </summary>
  86         /// <seealso cref="Container::GetChildCount()">
  87         /// </seealso>
  88         protected override uint GetChildCount()
  89         {
  90             uint ret = NDalicPINVOKE.Actor_GetChildCount(swigCPtr);
  91             if (NDalicPINVOKE.SWIGPendingException.Pending)
  92                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  93             return ret;
  94         }
  95
  96         /// <summary>
  97         /// Get the Views parent
  98         /// </summary>
  99         /// <seealso cref="Container::GetParent()">
 100
 101         protected override Container GetParent()
 102         {
 103             Container ret;
 104             IntPtr cPtr = NDalicPINVOKE.Actor_GetParent(swigCPtr);
 105
 106             BaseHandle basehandle = Registry.GetManagedBaseHandleFromNativePtr(cPtr);
 107
 108             if(basehandle is Layer)
 109             {
 110                 ret = basehandle as Layer;
 111             }
 112             else
 113             {
 114                 ret = basehandle as View;
 115             }
 116
 117             if (NDalicPINVOKE.SWIGPendingException.Pending)
 118                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 119             return ret;
 120         }
 121
 122         ///
 123
 124         // you can override it to clean-up your own resources.
 125         protected override void Dispose(DisposeTypes type)
 126         {
 127             if(disposed)
 128             {
 129                 return;
 130             }
 131
 132             if(type == DisposeTypes.Explicit)
 133             {
 134                 //Called by User
 135                 //Release your own managed resources here.
 136                 //You should release all of your own disposable objects here.
 137             }
 138
 139             //Release your own unmanaged resources here.
 140             //You should not access any managed member here except static instance.
 141             //because the execution order of Finalizes is non-deterministic.
 142
 143             if (_onRelayoutEventCallback != null)
 144             {
 145                 this.OnRelayoutSignal().Disconnect(_onRelayoutEventCallback);
 146             }
 147
 148             if (_offWindowEventCallback != null)
 149             {
 150                 this.OffWindowSignal().Disconnect(_offWindowEventCallback);
 151             }
 152
 153             if (_onWindowEventCallback != null)
 154             {
 155                 this.OnWindowSignal().Disconnect(_onWindowEventCallback);
 156             }
 157
 158             if (_wheelEventCallback != null)
 159             {
 160                 this.WheelEventSignal().Disconnect(_wheelEventCallback);
 161             }
 162
 163             if (_hoverEventCallback != null)
 164             {
 165                 this.HoveredSignal().Disconnect(_hoverEventCallback);
 166             }
 167
 168             if (_touchDataCallback != null)
 169             {
 170                 this.TouchSignal().Disconnect(_touchDataCallback);
 171             }
 172
 173             if (_ResourcesLoadedCallback != null)
 174             {
 175                 this.ResourcesLoadedSignal().Disconnect(_ResourcesLoadedCallback);
 176             }
 177
 178             if (_offWindowEventCallback != null)
 179             {
 180                 this.OffWindowSignal().Disconnect(_offWindowEventCallback);
 181             }
 182
 183             if (_onWindowEventCallback != null)
 184             {
 185                 this.OnWindowSignal().Disconnect(_onWindowEventCallback);
 186             }
 187
 188             if (_wheelEventCallback != null)
 189             {
 190                 this.WheelEventSignal().Disconnect(_wheelEventCallback);
 191             }
 192
 193             if (_hoverEventCallback != null)
 194             {
 195                 this.HoveredSignal().Disconnect(_hoverEventCallback);
 196             }
 197
 198             if (_touchDataCallback != null)
 199             {
 200                 this.TouchSignal().Disconnect(_touchDataCallback);
 201             }
 202
 203             if (_onRelayoutEventCallback != null)
 204             {
 205                 this.OnRelayoutSignal().Disconnect(_onRelayoutEventCallback);
 206             }
 207
 208             if (_keyCallback != null)
 209             {
 210                 this.KeyEventSignal().Disconnect(_keyCallback);
 211             }
 212
 213             if (_keyInputFocusLostCallback != null)
 214             {
 215                 this.KeyInputFocusLostSignal().Disconnect(_keyInputFocusLostCallback);
 216             }
 217
 218             if (_keyInputFocusGainedCallback != null)
 219             {
 220                 this.KeyInputFocusGainedSignal().Disconnect(_keyInputFocusGainedCallback);
 221             }
 222
 223             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 224             {
 225                 if (swigCMemOwn)
 226                 {
 227                     swigCMemOwn = false;
 228                     NDalicPINVOKE.delete_View(swigCPtr);
 229                 }
 230                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 231             }
 232
 233             base.Dispose(type);
 234         }
 235
 236         private EventHandler _keyInputFocusGainedEventHandler;
 237         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 238         private delegate void KeyInputFocusGainedCallbackType(IntPtr control);
 239         private KeyInputFocusGainedCallbackType _keyInputFocusGainedCallback;
 240
 241         /// <summary>
 242         /// Event for KeyInputFocusGained signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
 243         /// KeyInputFocusGained signal is emitted when the control gets Key Input Focus.<br>
 244         /// </summary>
 245         public event EventHandler FocusGained
 246         {
 247             add
 248             {
 249                 if (_keyInputFocusGainedEventHandler == null)
 250                 {
 251                     _keyInputFocusGainedCallback = OnKeyInputFocusGained;
 252                     this.KeyInputFocusGainedSignal().Connect(_keyInputFocusGainedCallback);
 253                 }
 254
 255                 _keyInputFocusGainedEventHandler += value;
 256             }
 257
 258             remove
 259             {
 260                 _keyInputFocusGainedEventHandler -= value;
 261
 262                 if (_keyInputFocusGainedEventHandler == null && KeyInputFocusGainedSignal().Empty() == false)
 263                 {
 264                     this.KeyInputFocusGainedSignal().Disconnect(_keyInputFocusGainedCallback);
 265                 }
 266             }
 267         }
 268
 269         private void OnKeyInputFocusGained(IntPtr view)
 270         {
 271             if (_keyInputFocusGainedEventHandler != null)
 272             {
 273                 _keyInputFocusGainedEventHandler(this, null);
 274             }
 275         }
 276
 277
 278         private EventHandler _keyInputFocusLostEventHandler;
 279         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 280         private delegate void KeyInputFocusLostCallbackType(IntPtr control);
 281         private KeyInputFocusLostCallbackType _keyInputFocusLostCallback;
 282
 283         /// <summary>
 284         /// Event for KeyInputFocusLost signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
 285         /// KeyInputFocusLost signal is emitted when the control loses Key Input Focus.<br>
 286         /// </summary>
 287         public event EventHandler FocusLost
 288         {
 289             add
 290             {
 291                 if (_keyInputFocusLostEventHandler == null)
 292                 {
 293                     _keyInputFocusLostCallback = OnKeyInputFocusLost;
 294                     this.KeyInputFocusLostSignal().Connect(_keyInputFocusLostCallback);
 295                 }
 296
 297                 _keyInputFocusLostEventHandler += value;
 298             }
 299
 300             remove
 301             {
 302                 _keyInputFocusLostEventHandler -= value;
 303
 304                 if (_keyInputFocusLostEventHandler == null && KeyInputFocusLostSignal().Empty() == false)
 305                 {
 306                     this.KeyInputFocusLostSignal().Disconnect(_keyInputFocusLostCallback);
 307                 }
 308             }
 309         }
 310
 311         private void OnKeyInputFocusLost(IntPtr view)
 312         {
 313             if (_keyInputFocusLostEventHandler != null)
 314             {
 315                 _keyInputFocusLostEventHandler(this, null);
 316             }
 317         }
 318
 319         /// <summary>
 320         /// Event arguments that passed via KeyEvent signal.
 321         /// </summary>
 322         public class KeyEventArgs : EventArgs
 323         {
 324             private Key _key;
 325
 326             /// <summary>
 327             /// Key - is the key sent to the View.
 328             /// </summary>
 329             public Key Key
 330             {
 331                 get
 332                 {
 333                     return _key;
 334                 }
 335                 set
 336                 {
 337                     _key = value;
 338                 }
 339             }
 340         }
 341
 342         private EventHandlerWithReturnType<object, KeyEventArgs, bool> _keyEventHandler;
 343         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 344         private delegate bool KeyCallbackType(IntPtr control, IntPtr keyEvent);
 345         private KeyCallbackType _keyCallback;
 346
 347         /// <summary>
 348         /// Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
 349         /// KeyPressed signal is emitted when key event is received.<br>
 350         /// </summary>
 351         public event EventHandlerWithReturnType<object, KeyEventArgs, bool> KeyEvent
 352         {
 353             add
 354             {
 355                 if (_keyEventHandler == null)
 356                 {
 357                     _keyCallback = OnKeyEvent;
 358                     this.KeyEventSignal().Connect(_keyCallback);
 359                 }
 360
 361                 _keyEventHandler += value;
 362             }
 363
 364             remove
 365             {
 366                 _keyEventHandler -= value;
 367
 368                 if (_keyEventHandler == null && KeyEventSignal().Empty() == false)
 369                 {
 370                     this.KeyEventSignal().Disconnect(_keyCallback);
 371                 }
 372             }
 373         }
 374
 375         private bool OnKeyEvent(IntPtr view, IntPtr keyEvent)
 376         {
 377             KeyEventArgs e = new KeyEventArgs();
 378
 379             bool result = false;
 380
 381             e.Key = Tizen.NUI.Key.GetKeyFromPtr(keyEvent);
 382
 383             if (_keyEventHandler != null)
 384             {
 385                 Delegate[] delegateList = _keyEventHandler.GetInvocationList();
 386
 387                 // Oring the result of each callback.
 388                 foreach ( EventHandlerWithReturnType<object, KeyEventArgs, bool> del in delegateList )
 389                 {
 390                     result |= del( this, e );
 391                 }
 392             }
 393
 394             return result;
 395         }
 396
 397         private EventHandler _onRelayoutEventHandler;
 398         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 399         private delegate void OnRelayoutEventCallbackType(IntPtr control);
 400         private OnRelayoutEventCallbackType _onRelayoutEventCallback;
 401
 402         /// <summary>
 403         /// Event for OnRelayout signal which can be used to subscribe/unsubscribe the event handler.<br>
 404         /// OnRelayout signal is emitted after the size has been set on the view during relayout.<br>
 405         /// </summary>
 406         public event EventHandler Relayout
 407         {
 408             add
 409             {
 410                 if (_onRelayoutEventHandler == null)
 411                 {
 412                     _onRelayoutEventCallback = OnRelayout;
 413                     this.OnRelayoutSignal().Connect(_onRelayoutEventCallback);
 414                 }
 415
 416                 _onRelayoutEventHandler += value;
 417             }
 418
 419             remove
 420             {
 421                 _onRelayoutEventHandler -= value;
 422
 423                 if (_onRelayoutEventHandler == null && OnRelayoutSignal().Empty() == false)
 424                 {
 425                     this.OnRelayoutSignal().Disconnect(_onRelayoutEventCallback);
 426                 }
 427
 428             }
 429         }
 430
 431         // Callback for View OnRelayout signal
 432         private void OnRelayout(IntPtr data)
 433         {
 434             if (_onRelayoutEventHandler != null)
 435             {
 436                 _onRelayoutEventHandler(this, null);
 437             }
 438         }
 439
 440         /// <summary>
 441         /// Event arguments that passed via Touch signal.
 442         /// </summary>
 443         public class TouchEventArgs : EventArgs
 444         {
 445             private Touch _touch;
 446
 447             /// <summary>
 448             /// Touch - contains the information of touch points
 449             /// </summary>
 450             public Touch Touch
 451             {
 452                 get
 453                 {
 454                     return _touch;
 455                 }
 456                 set
 457                 {
 458                     _touch = value;
 459                 }
 460             }
 461         }
 462
 463         private EventHandlerWithReturnType<object, TouchEventArgs, bool> _touchDataEventHandler;
 464         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 465         private delegate bool TouchDataCallbackType(IntPtr view, IntPtr touchData);
 466         private TouchDataCallbackType _touchDataCallback;
 467
 468         /// <summary>
 469         /// Event for Touched signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
 470         /// Touched signal is emitted when touch input is received.<br>
 471         /// </summary>
 472         public event EventHandlerWithReturnType<object, TouchEventArgs, bool> TouchEvent
 473         {
 474             add
 475             {
 476                 if (_touchDataEventHandler == null)
 477                 {
 478                     _touchDataCallback = OnTouch;
 479                     this.TouchSignal().Connect(_touchDataCallback);
 480                 }
 481
 482                 _touchDataEventHandler += value;
 483             }
 484
 485             remove
 486             {
 487                 _touchDataEventHandler -= value;
 488
 489                 if (_touchDataEventHandler == null && TouchSignal().Empty() == false)
 490                 {
 491                     this.TouchSignal().Disconnect(_touchDataCallback);
 492                 }
 493
 494             }
 495         }
 496
 497         // Callback for View TouchSignal
 498         private bool OnTouch(IntPtr view, IntPtr touchData)
 499         {
 500             TouchEventArgs e = new TouchEventArgs();
 501
 502             e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
 503
 504             if (_touchDataEventHandler != null)
 505             {
 506                 return _touchDataEventHandler(this, e);
 507             }
 508             return false;
 509         }
 510
 511
 512         /// <summary>
 513         /// Event arguments that passed via Hover signal.
 514         /// </summary>
 515         public class HoverEventArgs : EventArgs
 516         {
 517             private Hover _hover;
 518
 519             /// <summary>
 520             /// Hover - contains touch points that represent the points that are currently being hovered or the points where a hover has stopped.
 521             /// </summary>
 522             public Hover Hover
 523             {
 524                 get
 525                 {
 526                     return _hover;
 527                 }
 528                 set
 529                 {
 530                     _hover = value;
 531                 }
 532             }
 533         }
 534
 535         private EventHandlerWithReturnType<object, HoverEventArgs, bool> _hoverEventHandler;
 536         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 537         private delegate bool HoverEventCallbackType(IntPtr view, IntPtr hoverEvent);
 538         private HoverEventCallbackType _hoverEventCallback;
 539
 540         /// <summary>
 541         /// Event for Hovered signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
 542         /// Hovered signal is emitted when hover input is received.<br>
 543         /// </summary>
 544         public event EventHandlerWithReturnType<object, HoverEventArgs, bool> HoverEvent
 545         {
 546             add
 547             {
 548                 if (_hoverEventHandler == null)
 549                 {
 550                     _hoverEventCallback = OnHoverEvent;
 551                     this.HoveredSignal().Connect(_hoverEventCallback);
 552                 }
 553
 554                 _hoverEventHandler += value;
 555             }
 556
 557             remove
 558             {
 559                 _hoverEventHandler -= value;
 560
 561                 if (_hoverEventHandler == null && HoveredSignal().Empty() == false)
 562                 {
 563                     this.HoveredSignal().Disconnect(_hoverEventCallback);
 564                 }
 565
 566             }
 567         }
 568
 569         // Callback for View Hover signal
 570         private bool OnHoverEvent(IntPtr view, IntPtr hoverEvent)
 571         {
 572             HoverEventArgs e = new HoverEventArgs();
 573
 574             e.Hover = Tizen.NUI.Hover.GetHoverFromPtr(hoverEvent);
 575
 576             if (_hoverEventHandler != null)
 577             {
 578                 return _hoverEventHandler(this, e);
 579             }
 580             return false;
 581         }
 582
 583
 584         /// <summary>
 585         /// Event arguments that passed via Wheel signal.
 586         /// </summary>
 587         public class WheelEventArgs : EventArgs
 588         {
 589             private Wheel _wheel;
 590
 591             /// <summary>
 592             /// WheelEvent - store a wheel rolling type : MOUSE_WHEEL or CUSTOM_WHEEL
 593             /// </summary>
 594             public Wheel Wheel
 595             {
 596                 get
 597                 {
 598                     return _wheel;
 599                 }
 600                 set
 601                 {
 602                     _wheel = value;
 603                 }
 604             }
 605         }
 606
 607         private EventHandlerWithReturnType<object, WheelEventArgs, bool> _wheelEventHandler;
 608         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 609         private delegate bool WheelEventCallbackType(IntPtr view, IntPtr wheelEvent);
 610         private WheelEventCallbackType _wheelEventCallback;
 611
 612         /// <summary>
 613         /// Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
 614         /// WheelMoved signal is emitted when wheel event is received.<br>
 615         /// </summary>
 616         public event EventHandlerWithReturnType<object, WheelEventArgs, bool> WheelEvent
 617         {
 618             add
 619             {
 620                 if (_wheelEventHandler == null)
 621                 {
 622                     _wheelEventCallback = OnWheelEvent;
 623                     this.WheelEventSignal().Connect(_wheelEventCallback);
 624                 }
 625
 626                 _wheelEventHandler += value;
 627             }
 628
 629             remove
 630             {
 631                 _wheelEventHandler -= value;
 632
 633                 if (_wheelEventHandler == null && WheelEventSignal().Empty() == false)
 634                 {
 635                     this.WheelEventSignal().Disconnect(_wheelEventCallback);
 636                 }
 637
 638             }
 639         }
 640
 641         // Callback for View Wheel signal
 642         private bool OnWheelEvent(IntPtr view, IntPtr wheelEvent)
 643         {
 644             WheelEventArgs e = new WheelEventArgs();
 645
 646             e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
 647
 648             if (_wheelEventHandler != null)
 649             {
 650                 return _wheelEventHandler(this, e);
 651             }
 652             return false;
 653         }
 654
 655
 656         private EventHandler _onWindowEventHandler;
 657         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 658         private delegate void OnWindowEventCallbackType(IntPtr control);
 659         private OnWindowEventCallbackType _onWindowEventCallback;
 660
 661         /// <summary>
 662         /// Event for OnWindow signal which can be used to subscribe/unsubscribe the event handler.<br>
 663         /// OnWindow signal is emitted after the view has been connected to the Window.<br>
 664         /// </summary>
 665         public event EventHandler AddedToWindow
 666         {
 667             add
 668             {
 669                 if (_onWindowEventHandler == null)
 670                 {
 671                     _onWindowEventCallback = OnWindow;
 672                     this.OnWindowSignal().Connect(_onWindowEventCallback);
 673                 }
 674
 675                 _onWindowEventHandler += value;
 676             }
 677
 678             remove
 679             {
 680                 _onWindowEventHandler -= value;
 681
 682                 if (_onWindowEventHandler == null && OnWindowSignal().Empty() == false)
 683                 {
 684                     this.OnWindowSignal().Disconnect(_onWindowEventCallback);
 685                 }
 686             }
 687         }
 688
 689         // Callback for View OnWindow signal
 690         private void OnWindow(IntPtr data)
 691         {
 692             if (_onWindowEventHandler != null)
 693             {
 694                 _onWindowEventHandler(this, null);
 695             }
 696         }
 697
 698
 699         private EventHandler _offWindowEventHandler;
 700         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 701         private delegate void OffWindowEventCallbackType(IntPtr control);
 702         private OffWindowEventCallbackType _offWindowEventCallback;
 703
 704         /// <summary>
 705         /// Event for OffWindow signal which can be used to subscribe/unsubscribe the event handler.<br>
 706         /// OffWindow signal is emitted after the view has been disconnected from the Window.<br>
 707         /// </summary>
 708         public event EventHandler RemovedFromWindow
 709         {
 710             add
 711             {
 712                 if (_offWindowEventHandler == null)
 713                 {
 714                     _offWindowEventCallback = OffWindow;
 715                     this.OffWindowSignal().Connect(_offWindowEventCallback);
 716                 }
 717
 718                 _offWindowEventHandler += value;
 719             }
 720
 721             remove
 722             {
 723                 _offWindowEventHandler -= value;
 724
 725                 if (_offWindowEventHandler == null && OffWindowSignal().Empty() == false)
 726                 {
 727                     this.OffWindowSignal().Disconnect(_offWindowEventCallback);
 728                 }
 729             }
 730         }
 731
 732         // Callback for View OffWindow signal
 733         private void OffWindow(IntPtr data)
 734         {
 735             if (_offWindowEventHandler != null)
 736             {
 737                 _offWindowEventHandler(this, null);
 738             }
 739         }
 740
 741         /// <summary>
 742         /// Event arguments of visibility changed.
 743         /// </summary>
 744         public class VisibilityChangedEventArgs : EventArgs
 745         {
 746             private View _view;
 747             private bool _visibility;
 748             private VisibilityChangeType _type;
 749
 750             /// <summary>
 751             /// The view, or child of view, whose visibility has changed.
 752             /// </summary>
 753             public View View
 754             {
 755                 get
 756                 {
 757                     return _view;
 758                 }
 759                 set
 760                 {
 761                     _view = value;
 762                 }
 763             }
 764
 765             /// <summary>
 766             /// Whether the view is now visible or not.
 767             /// </summary>
 768             public bool Visibility
 769             {
 770                 get
 771                 {
 772                     return _visibility;
 773                 }
 774                 set
 775                 {
 776                     _visibility = value;
 777                 }
 778             }
 779
 780             /// <summary>
 781             /// Whether the view's visible property has changed or a parent's.
 782             /// </summary>
 783             public VisibilityChangeType Type
 784             {
 785                 get
 786                 {
 787                     return _type;
 788                 }
 789                 set
 790                 {
 791                     _type = value;
 792                 }
 793             }
 794         }
 795
 796         private EventHandler<VisibilityChangedEventArgs> _visibilityChangedEventHandler;
 797         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 798         private delegate void VisibilityChangedEventCallbackType(IntPtr data, bool visibility, VisibilityChangeType type);
 799         private VisibilityChangedEventCallbackType _visibilityChangedEventCallback;
 800
 801         /// <summary>
 802         /// Event for visibility change which can be used to subscribe/unsubscribe the event handler.<br>
 803         /// This signal is emitted when the visible property of this or a parent view is changed.<br>
 804         /// </summary>
 805         public event EventHandler<VisibilityChangedEventArgs> VisibilityChanged
 806         {
 807             add
 808             {
 809                 if (_visibilityChangedEventHandler == null)
 810                 {
 811                     _visibilityChangedEventCallback = OnVisibilityChanged;
 812                     VisibilityChangedSignal(this).Connect(_visibilityChangedEventCallback);
 813                 }
 814
 815                 _visibilityChangedEventHandler += value;
 816             }
 817
 818             remove
 819             {
 820                 _visibilityChangedEventHandler -= value;
 821
 822                 if (_visibilityChangedEventHandler == null && VisibilityChangedSignal(this).Empty() == false)
 823                 {
 824                     VisibilityChangedSignal(this).Disconnect(_visibilityChangedEventCallback);
 825                 }
 826             }
 827         }
 828
 829         // Callback for View visibility change signal
 830         private void OnVisibilityChanged(IntPtr data, bool visibility, VisibilityChangeType type)
 831         {
 832             VisibilityChangedEventArgs e = new VisibilityChangedEventArgs();
 833             if (data != null)
 834             {
 835                 e.View = Registry.GetManagedBaseHandleFromNativePtr(data) as View;
 836             }
 837             e.Visibility = visibility;
 838             e.Type = type;
 839
 840             if (_visibilityChangedEventHandler != null)
 841             {
 842                 _visibilityChangedEventHandler(this, e);
 843             }
 844         }
 845
 846         // Resource Ready Signal
 847
 848         private EventHandler _resourcesLoadedEventHandler;
 849         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 850         private delegate void ResourcesLoadedCallbackType(IntPtr control);
 851         private ResourcesLoadedCallbackType _ResourcesLoadedCallback;
 852
 853         /// <summary>
 854         /// Event for ResourcesLoadedSignal signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
 855         /// This signal is emitted after all resources required by a View are loaded and ready.<br>
 856         /// </summary>
 857         public event EventHandler ResourcesLoaded
 858         {
 859             add
 860             {
 861                 if (_resourcesLoadedEventHandler == null)
 862                 {
 863                     _ResourcesLoadedCallback = OnResourcesLoaded;
 864                     this.ResourcesLoadedSignal().Connect(_ResourcesLoadedCallback);
 865                 }
 866
 867                 _resourcesLoadedEventHandler += value;
 868             }
 869
 870             remove
 871             {
 872                 _resourcesLoadedEventHandler -= value;
 873
 874                 if (_resourcesLoadedEventHandler == null && ResourcesLoadedSignal().Empty() == false)
 875                 {
 876                     this.ResourcesLoadedSignal().Disconnect(_ResourcesLoadedCallback);
 877                 }
 878             }
 879         }
 880
 881         private void OnResourcesLoaded(IntPtr view)
 882         {
 883             if (_resourcesLoadedEventHandler != null)
 884             {
 885                 _resourcesLoadedEventHandler(this, null);
 886             }
 887         }
 888
 889         internal IntPtr GetPtrfromView()
 890         {
 891             return (IntPtr)swigCPtr;
 892         }
 893
 894         internal class Property
 895         {
 896             internal static readonly int TOOLTIP = NDalicManualPINVOKE.View_Property_TOOLTIP_get();
 897             internal static readonly int STATE = NDalicManualPINVOKE.View_Property_STATE_get();
 898             internal static readonly int SUB_STATE = NDalicManualPINVOKE.View_Property_SUB_STATE_get();
 899             internal static readonly int LEFT_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_LEFT_FOCUSABLE_ACTOR_ID_get();
 900             internal static readonly int RIGHT_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_RIGHT_FOCUSABLE_ACTOR_ID_get();
 901             internal static readonly int UP_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_UP_FOCUSABLE_ACTOR_ID_get();
 902             internal static readonly int DOWN_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_DOWN_FOCUSABLE_ACTOR_ID_get();
 903             internal static readonly int STYLE_NAME = NDalicPINVOKE.View_Property_STYLE_NAME_get();
 904             internal static readonly int BACKGROUND = NDalicPINVOKE.View_Property_BACKGROUND_get();
 905             internal static readonly int SIBLING_ORDER = NDalicManualPINVOKE.Actor_Property_SIBLING_ORDER_get();
 906             internal static readonly int OPACITY = NDalicManualPINVOKE.Actor_Property_OPACITY_get();
 907             internal static readonly int SCREEN_POSITION = NDalicManualPINVOKE.Actor_Property_SCREEN_POSITION_get();
 908             internal static readonly int POSITION_USES_ANCHOR_POINT = NDalicManualPINVOKE.Actor_Property_POSITION_USES_ANCHOR_POINT_get();
 909             internal static readonly int PARENT_ORIGIN = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_get();
 910             internal static readonly int PARENT_ORIGIN_X = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_X_get();
 911             internal static readonly int PARENT_ORIGIN_Y = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Y_get();
 912             internal static readonly int PARENT_ORIGIN_Z = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Z_get();
 913             internal static readonly int ANCHOR_POINT = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_get();
 914             internal static readonly int ANCHOR_POINT_X = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_X_get();
 915             internal static readonly int ANCHOR_POINT_Y = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Y_get();
 916             internal static readonly int ANCHOR_POINT_Z = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Z_get();
 917             internal static readonly int SIZE = NDalicPINVOKE.Actor_Property_SIZE_get();
 918             internal static readonly int SIZE_WIDTH = NDalicPINVOKE.Actor_Property_SIZE_WIDTH_get();
 919             internal static readonly int SIZE_HEIGHT = NDalicPINVOKE.Actor_Property_SIZE_HEIGHT_get();
 920             internal static readonly int SIZE_DEPTH = NDalicPINVOKE.Actor_Property_SIZE_DEPTH_get();
 921             internal static readonly int POSITION = NDalicPINVOKE.Actor_Property_POSITION_get();
 922             internal static readonly int POSITION_X = NDalicPINVOKE.Actor_Property_POSITION_X_get();
 923             internal static readonly int POSITION_Y = NDalicPINVOKE.Actor_Property_POSITION_Y_get();
 924             internal static readonly int POSITION_Z = NDalicPINVOKE.Actor_Property_POSITION_Z_get();
 925             internal static readonly int WORLD_POSITION = NDalicPINVOKE.Actor_Property_WORLD_POSITION_get();
 926             internal static readonly int WORLD_POSITION_X = NDalicPINVOKE.Actor_Property_WORLD_POSITION_X_get();
 927             internal static readonly int WORLD_POSITION_Y = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Y_get();
 928             internal static readonly int WORLD_POSITION_Z = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Z_get();
 929             internal static readonly int ORIENTATION = NDalicPINVOKE.Actor_Property_ORIENTATION_get();
 930             internal static readonly int WORLD_ORIENTATION = NDalicPINVOKE.Actor_Property_WORLD_ORIENTATION_get();
 931             internal static readonly int SCALE = NDalicPINVOKE.Actor_Property_SCALE_get();
 932             internal static readonly int SCALE_X = NDalicPINVOKE.Actor_Property_SCALE_X_get();
 933             internal static readonly int SCALE_Y = NDalicPINVOKE.Actor_Property_SCALE_Y_get();
 934             internal static readonly int SCALE_Z = NDalicPINVOKE.Actor_Property_SCALE_Z_get();
 935             internal static readonly int WORLD_SCALE = NDalicPINVOKE.Actor_Property_WORLD_SCALE_get();
 936             internal static readonly int VISIBLE = NDalicPINVOKE.Actor_Property_VISIBLE_get();
 937             internal static readonly int WORLD_COLOR = NDalicPINVOKE.Actor_Property_WORLD_COLOR_get();
 938             internal static readonly int WORLD_MATRIX = NDalicPINVOKE.Actor_Property_WORLD_MATRIX_get();
 939             internal static readonly int NAME = NDalicPINVOKE.Actor_Property_NAME_get();
 940             internal static readonly int SENSITIVE = NDalicPINVOKE.Actor_Property_SENSITIVE_get();
 941             internal static readonly int LEAVE_REQUIRED = NDalicPINVOKE.Actor_Property_LEAVE_REQUIRED_get();
 942             internal static readonly int INHERIT_ORIENTATION = NDalicPINVOKE.Actor_Property_INHERIT_ORIENTATION_get();
 943             internal static readonly int INHERIT_SCALE = NDalicPINVOKE.Actor_Property_INHERIT_SCALE_get();
 944             internal static readonly int DRAW_MODE = NDalicPINVOKE.Actor_Property_DRAW_MODE_get();
 945             internal static readonly int SIZE_MODE_FACTOR = NDalicPINVOKE.Actor_Property_SIZE_MODE_FACTOR_get();
 946             internal static readonly int WIDTH_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_WIDTH_RESIZE_POLICY_get();
 947             internal static readonly int HEIGHT_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_HEIGHT_RESIZE_POLICY_get();
 948             internal static readonly int SIZE_SCALE_POLICY = NDalicPINVOKE.Actor_Property_SIZE_SCALE_POLICY_get();
 949             internal static readonly int WIDTH_FOR_HEIGHT = NDalicPINVOKE.Actor_Property_WIDTH_FOR_HEIGHT_get();
 950             internal static readonly int HEIGHT_FOR_WIDTH = NDalicPINVOKE.Actor_Property_HEIGHT_FOR_WIDTH_get();
 951             internal static readonly int PADDING = NDalicPINVOKE.Actor_Property_PADDING_get();
 952             internal static readonly int MINIMUM_SIZE = NDalicPINVOKE.Actor_Property_MINIMUM_SIZE_get();
 953             internal static readonly int MAXIMUM_SIZE = NDalicPINVOKE.Actor_Property_MAXIMUM_SIZE_get();
 954             internal static readonly int INHERIT_POSITION = NDalicPINVOKE.Actor_Property_INHERIT_POSITION_get();
 955             internal static readonly int CLIPPING_MODE = NDalicPINVOKE.Actor_Property_CLIPPING_MODE_get();
 956         }
 957
 958         /// <summary>
 959         /// Describes the direction to move the focus towards.
 960         /// </summary>
 961         public enum FocusDirection
 962         {
 963             Left,
 964             Right,
 965             Up,
 966             Down,
 967             PageUp,
 968             PageDown
 969         }
 970
 971         /// <summary>
 972         /// Creates a new instance of a View.
 973         /// </summary>
 974         public View() : this(NDalicPINVOKE.View_New(), true)
 975         {
 976             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 977
 978         }
 979         internal View(View uiControl) : this(NDalicPINVOKE.new_View__SWIG_1(View.getCPtr(uiControl)), true)
 980         {
 981             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 982         }
 983
 984         /// <summary>
 985         /// Downcasts a handle to View handle.<br>
 986         /// If handle points to a View, the downcast produces valid handle.<br>
 987         /// If not, the returned handle is left uninitialized.<br>
 988         /// </summary>
 989         /// <param name="handle">Handle to an object</param>
 990         /// <returns>A handle to a View or an uninitialized handle</returns>
 991         [Obsolete("Please do not use! this will be deprecated, instead please use as keyword.")]
 992         public new static View DownCast(BaseHandle handle)
 993         {
 994             View ret =  Registry.GetManagedBaseHandleFromNativePtr(handle) as View;
 995             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 996             return ret;
 997         }
 998
 999         [Obsolete("Please do not use! this will be deprecated, instead please use as keyword.")]
1000         public static T DownCast<T>(View view) where T : View
1001         {
1002             T ret = Registry.GetManagedBaseHandleFromNativePtr(view) as T;
1003             if (ret != null)
1004             {
1005                 return ret;
1006             }
1007             return null;
1008         }
1009
1010         private View ConvertIdToView(uint id)
1011         {
1012             View view = null;
1013
1014             if (Parent is View)
1015             {
1016                 View parentView = Parent as View;
1017                 view = parentView.FindChildById(id);
1018             }
1019
1020             if (!view)
1021             {
1022                 view = Window.Instance.GetRootLayer().FindChildById(id);
1023             }
1024
1025             return view;
1026         }
1027
1028         internal void SetKeyInputFocus()
1029         {
1030             NDalicPINVOKE.View_SetKeyInputFocus(swigCPtr);
1031             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1032         }
1033
1034         /// <summary>
1035         /// Quries whether the view has focus.
1036         /// </summary>
1037         /// <returns>true if this view has focus</returns>
1038         public bool HasFocus()
1039         {
1040             bool ret = NDalicPINVOKE.View_HasKeyInputFocus(swigCPtr);
1041             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1042             return ret;
1043         }
1044
1045         internal void ClearKeyInputFocus()
1046         {
1047             NDalicPINVOKE.View_ClearKeyInputFocus(swigCPtr);
1048             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1049         }
1050
1051         internal PinchGestureDetector GetPinchGestureDetector()
1052         {
1053             PinchGestureDetector ret = new PinchGestureDetector(NDalicPINVOKE.View_GetPinchGestureDetector(swigCPtr), true);
1054             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1055             return ret;
1056         }
1057
1058         internal PanGestureDetector GetPanGestureDetector()
1059         {
1060             PanGestureDetector ret = new PanGestureDetector(NDalicPINVOKE.View_GetPanGestureDetector(swigCPtr), true);
1061             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1062             return ret;
1063         }
1064
1065         internal TapGestureDetector GetTapGestureDetector()
1066         {
1067             TapGestureDetector ret = new TapGestureDetector(NDalicPINVOKE.View_GetTapGestureDetector(swigCPtr), true);
1068             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1069             return ret;
1070         }
1071
1072         internal LongPressGestureDetector GetLongPressGestureDetector()
1073         {
1074             LongPressGestureDetector ret = new LongPressGestureDetector(NDalicPINVOKE.View_GetLongPressGestureDetector(swigCPtr), true);
1075             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1076             return ret;
1077         }
1078
1079         /// <summary>
1080         /// Sets the name of the style to be applied to the view.
1081         /// </summary>
1082         /// <param name="styleName">A string matching a style described in a stylesheet</param>
1083         public void SetStyleName(string styleName)
1084         {
1085             NDalicPINVOKE.View_SetStyleName(swigCPtr, styleName);
1086             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1087         }
1088
1089         /// <summary>
1090         /// Retrieves the name of the style to be applied to the view (if any).
1091         /// </summary>
1092         /// <returns>A string matching a style, or an empty string</returns>
1093         public string GetStyleName()
1094         {
1095             string ret = NDalicPINVOKE.View_GetStyleName(swigCPtr);
1096             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1097             return ret;
1098         }
1099
1100         internal void SetBackgroundColor(Vector4 color)
1101         {
1102             NDalicPINVOKE.View_SetBackgroundColor(swigCPtr, Vector4.getCPtr(color));
1103             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1104         }
1105
1106         internal Vector4 GetBackgroundColor()
1107         {
1108             Vector4 ret = new Vector4(NDalicPINVOKE.View_GetBackgroundColor(swigCPtr), true);
1109             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1110             return ret;
1111         }
1112
1113         internal void SetBackgroundImage(Image image)
1114         {
1115             NDalicPINVOKE.View_SetBackgroundImage(swigCPtr, Image.getCPtr(image));
1116             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1117         }
1118
1119         /// <summary>
1120         /// Clears the background.
1121         /// </summary>
1122         public void ClearBackground()
1123         {
1124             NDalicPINVOKE.View_ClearBackground(swigCPtr);
1125             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1126         }
1127
1128         internal ControlKeySignal KeyEventSignal()
1129         {
1130             ControlKeySignal ret = new ControlKeySignal(NDalicPINVOKE.View_KeyEventSignal(swigCPtr), false);
1131             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1132             return ret;
1133         }
1134
1135         internal KeyInputFocusSignal KeyInputFocusGainedSignal()
1136         {
1137             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusGainedSignal(swigCPtr), false);
1138             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1139             return ret;
1140         }
1141
1142         internal KeyInputFocusSignal KeyInputFocusLostSignal()
1143         {
1144             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusLostSignal(swigCPtr), false);
1145             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1146             return ret;
1147         }
1148
1149         internal View(ViewImpl implementation) : this(NDalicPINVOKE.new_View__SWIG_2(ViewImpl.getCPtr(implementation)), true)
1150         {
1151             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1152         }
1153
1154         internal enum PropertyRange
1155         {
1156             PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX,
1157             CONTROL_PROPERTY_START_INDEX = PROPERTY_START_INDEX,
1158             CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX + 1000
1159         }
1160
1161         /// <summary>
1162         /// styleName, type string.
1163         /// </summary>
1164         public string StyleName
1165         {
1166             get
1167             {
1168                 string temp;
1169                 GetProperty(View.Property.STYLE_NAME).Get(out temp);
1170                 return temp;
1171             }
1172             set
1173             {
1174                 SetProperty(View.Property.STYLE_NAME, new Tizen.NUI.PropertyValue(value));
1175             }
1176         }
1177
1178         /// <summary>
1179         /// mutually exclusive with BACKGROUND_IMAGE & BACKGROUND,  type Vector4.
1180         /// </summary>
1181         public Color BackgroundColor
1182         {
1183             get
1184             {
1185                 Color backgroundColor = new Color(0.0f, 0.0f, 0.0f, 0.0f);
1186
1187                 Tizen.NUI.PropertyMap background = Background;
1188                 int visualType = 0;
1189                 background.Find(Visual.Property.Type)?.Get(out visualType);
1190                 if (visualType == (int)Visual.Type.Color)
1191                 {
1192                     background.Find(ColorVisualProperty.MixColor)?.Get(backgroundColor);
1193                 }
1194
1195                 return backgroundColor;
1196             }
1197             set
1198             {
1199                 SetProperty(View.Property.BACKGROUND, new Tizen.NUI.PropertyValue(value));
1200             }
1201         }
1202
1203         /// <summary>
1204         /// Create an Animation to animate the background color visual. If there is no
1205         /// background visual, creates one with transparent black as it's mixColor.
1206         /// </summary>
1207         public Animation AnimateBackgroundColor( object destinationValue,
1208                                                  int startTime,
1209                                                  int endTime,
1210                                                  AlphaFunction.BuiltinFunctions? alphaFunction = null,
1211                                                  object initialValue = null)
1212         {
1213             Tizen.NUI.PropertyMap background = Background;
1214
1215             if( background.Empty() )
1216             {
1217                 // If there is no background yet, ensure there is a transparent
1218                 // color visual
1219                 BackgroundColor = new Color(0.0f, 0.0f, 0.0f, 0.0f);
1220                 background = Background;
1221             }
1222             return AnimateColor( "background", destinationValue, startTime, endTime, alphaFunction, initialValue );
1223         }
1224
1225         /// <summary>
1226         /// Create an Animation to animate the mixColor of the named visual.
1227         /// </summary>
1228         public Animation AnimateColor( string targetVisual, object destinationColor, int startTime, int endTime, AlphaFunction.BuiltinFunctions? alphaFunction = null, object initialColor = null )
1229         {
1230             Animation animation = null;
1231             {
1232                 PropertyMap _animator = new PropertyMap();
1233                 if( alphaFunction != null )
1234                 {
1235                     _animator.Add("alphaFunction", new PropertyValue( AlphaFunction.BuiltinToPropertyKey(alphaFunction) ) );
1236                 }
1237
1238                 PropertyMap _timePeriod = new PropertyMap();
1239                 _timePeriod.Add( "duration", new PropertyValue((endTime-startTime)/1000.0f) );
1240                 _timePeriod.Add( "delay", new PropertyValue( startTime/1000.0f ) );
1241                 _animator.Add( "timePeriod", new PropertyValue( _timePeriod ) );
1242
1243                 PropertyMap _transition = new PropertyMap();
1244                 _transition.Add( "animator", new PropertyValue( _animator ) );
1245                 _transition.Add( "target", new PropertyValue( targetVisual ) );
1246                 _transition.Add( "property", new PropertyValue( "mixColor" ) );
1247
1248                 if( initialColor != null )
1249                 {
1250                     PropertyValue initValue = PropertyValue.CreateFromObject( initialColor );
1251                     _transition.Add( "initialValue", initValue );
1252                 }
1253
1254                 PropertyValue destValue = PropertyValue.CreateFromObject( destinationColor );
1255                 _transition.Add( "targetValue", destValue );
1256                 TransitionData _transitionData = new TransitionData( _transition );
1257
1258                 animation = new Animation( NDalicManualPINVOKE.View_CreateTransition(swigCPtr, TransitionData.getCPtr(_transitionData)), true );
1259                 if (NDalicPINVOKE.SWIGPendingException.Pending)
1260                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1261             }
1262             return animation;
1263         }
1264
1265         /// <summary>
1266         /// mutually exclusive with BACKGROUND_COLOR & BACKGROUND,  type Map.
1267         /// </summary>
1268         public string BackgroundImage
1269         {
1270             get
1271             {
1272                 string backgroundImage = "";
1273
1274                 Tizen.NUI.PropertyMap background = Background;
1275                 int visualType = 0;
1276                 background.Find(Visual.Property.Type)?.Get(out visualType);
1277                 if (visualType == (int)Visual.Type.Image)
1278                 {
1279                     background.Find(ImageVisualProperty.URL)?.Get(out backgroundImage);
1280                 }
1281
1282                 return backgroundImage;
1283             }
1284             set
1285             {
1286                 SetProperty(View.Property.BACKGROUND, new Tizen.NUI.PropertyValue(value));
1287             }
1288         }
1289
1290         public Tizen.NUI.PropertyMap Background
1291         {
1292             get
1293             {
1294                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
1295                 GetProperty( View.Property.BACKGROUND ).Get(temp);
1296                 return temp;
1297             }
1298             set
1299             {
1300                 SetProperty(View.Property.BACKGROUND, new Tizen.NUI.PropertyValue(value));
1301             }
1302         }
1303
1304
1305         /// <summary>
1306         /// The current state of the view.
1307         /// </summary>
1308         public States State
1309         {
1310             get
1311             {
1312                 int temp = 0;
1313                 if (GetProperty(View.Property.STATE).Get(out temp) == false)
1314                 {
1315                     NUILog.Error("State get error!");
1316                 }
1317                 switch (temp)
1318                 {
1319                     case 0:
1320                     {
1321                         return States.Normal;
1322                     }
1323                     case 1:
1324                     {
1325                         return States.Focused;
1326                     }
1327                     case 2:
1328                     {
1329                         return States.Disabled;
1330                     }
1331                     default:
1332                     {
1333                         return States.Normal;
1334                     }
1335                 }
1336             }
1337             set
1338             {
1339                 SetProperty(View.Property.STATE, new Tizen.NUI.PropertyValue((int)value));
1340             }
1341         }
1342
1343         /// <summary>
1344         /// The current sub state of the view.
1345         /// </summary>
1346         public States SubState
1347         {
1348             get
1349             {
1350                 string temp;
1351                 if (GetProperty(View.Property.SUB_STATE).Get(out temp) == false)
1352                 {
1353                     NUILog.Error("subState get error!");
1354                 }
1355                 switch (temp)
1356                 {
1357                     case "NORMAL":
1358                         return States.Normal;
1359                     case "FOCUSED":
1360                         return States.Focused;
1361                     case "DISABLED":
1362                         return States.Disabled;
1363                     default:
1364                         return States.Normal;
1365                 }
1366             }
1367             set
1368             {
1369                 string valueToString = "";
1370                 switch (value)
1371                 {
1372                     case States.Normal:
1373                     {
1374                         valueToString = "NORMAL";
1375                         break;
1376                     }
1377                     case States.Focused:
1378                     {
1379                         valueToString = "FOCUSED";
1380                         break;
1381                     }
1382                     case States.Disabled:
1383                     {
1384                         valueToString = "DISABLED";
1385                         break;
1386                     }
1387                     default:
1388                     {
1389                         valueToString = "NORMAL";
1390                         break;
1391                     }
1392                 }
1393                 SetProperty(View.Property.SUB_STATE, new Tizen.NUI.PropertyValue(valueToString));
1394             }
1395         }
1396
1397         /// <summary>
1398         /// Displays a tooltip
1399         /// </summary>
1400         public Tizen.NUI.PropertyMap Tooltip
1401         {
1402             get
1403             {
1404                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
1405                 GetProperty(View.Property.TOOLTIP).Get(temp);
1406                 return temp;
1407             }
1408             set
1409             {
1410                 SetProperty(View.Property.TOOLTIP, new Tizen.NUI.PropertyValue(value));
1411             }
1412         }
1413
1414         /// <summary>
1415         /// Displays a tooltip as Text
1416         /// </summary>
1417         public string TooltipText
1418         {
1419             set
1420             {
1421                 SetProperty(View.Property.TOOLTIP, new Tizen.NUI.PropertyValue(value));
1422             }
1423         }
1424
1425         private int LeftFocusableViewId
1426         {
1427             get
1428             {
1429                 int temp = 0;
1430                 GetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID).Get(out temp);
1431                 return temp;
1432             }
1433             set
1434             {
1435                 SetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
1436             }
1437         }
1438
1439         private int RightFocusableViewId
1440         {
1441             get
1442             {
1443                 int temp = 0;
1444                 GetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID).Get(out temp);
1445                 return temp;
1446             }
1447             set
1448             {
1449                 SetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
1450             }
1451         }
1452
1453         private int UpFocusableViewId
1454         {
1455             get
1456             {
1457                 int temp = 0;
1458                 GetProperty(View.Property.UP_FOCUSABLE_VIEW_ID).Get(out temp);
1459                 return temp;
1460             }
1461             set
1462             {
1463                 SetProperty(View.Property.UP_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
1464             }
1465         }
1466
1467         private int DownFocusableViewId
1468         {
1469             get
1470             {
1471                 int temp = 0;
1472                 GetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID).Get(out temp);
1473                 return temp;
1474             }
1475             set
1476             {
1477                 SetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
1478             }
1479         }
1480
1481         /// <summary>
1482         /// Child Property of FlexContainer.<br>
1483         /// The proportion of the free space in the container the flex item will receive.<br>
1484         /// If all items in the container set this property, their sizes will be proportional to the specified flex factor.<br>
1485         /// </summary>
1486         public float Flex
1487         {
1488             get
1489             {
1490                 float temp = 0.0f;
1491                 GetProperty(FlexContainer.ChildProperty.FLEX).Get(out temp);
1492                 return temp;
1493             }
1494             set
1495             {
1496                 SetProperty(FlexContainer.ChildProperty.FLEX, new Tizen.NUI.PropertyValue(value));
1497             }
1498         }
1499
1500         /// <summary>
1501         /// Child Property of FlexContainer.<br>
1502         /// The alignment of the flex item along the cross axis, which, if set, overides the default alignment for all items in the container.<br>
1503         /// </summary>
1504         public int AlignSelf
1505         {
1506             get
1507             {
1508                 int temp = 0;
1509                 GetProperty(FlexContainer.ChildProperty.ALIGN_SELF).Get(out temp);
1510                 return temp;
1511             }
1512             set
1513             {
1514                 SetProperty(FlexContainer.ChildProperty.ALIGN_SELF, new Tizen.NUI.PropertyValue(value));
1515             }
1516         }
1517
1518         /// <summary>
1519         /// Child Property of FlexContainer.<br>
1520         /// The space around the flex item.<br>
1521         /// </summary>
1522         public Vector4 FlexMargin
1523         {
1524             get
1525             {
1526                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
1527                 GetProperty(FlexContainer.ChildProperty.FLEX_MARGIN).Get(temp);
1528                 return temp;
1529             }
1530             set
1531             {
1532                 SetProperty(FlexContainer.ChildProperty.FLEX_MARGIN, new Tizen.NUI.PropertyValue(value));
1533             }
1534         }
1535
1536         /// <summary>
1537         /// The top-left cell this child occupies, if not set, the first available cell is used
1538         /// </summary>
1539         public Vector2 CellIndex
1540         {
1541             get
1542             {
1543                 Vector2 temp = new Vector2(0.0f, 0.0f);
1544                 GetProperty(TableView.ChildProperty.CELL_INDEX).Get(temp);
1545                 return temp;
1546             }
1547             set
1548             {
1549                 SetProperty(TableView.ChildProperty.CELL_INDEX, new Tizen.NUI.PropertyValue(value));
1550             }
1551         }
1552
1553         /// <summary>
1554         /// The number of rows this child occupies, if not set, default value is 1
1555         /// </summary>
1556         public float RowSpan
1557         {
1558             get
1559             {
1560                 float temp = 0.0f;
1561                 GetProperty(TableView.ChildProperty.ROW_SPAN).Get(out temp);
1562                 return temp;
1563             }
1564             set
1565             {
1566                 SetProperty(TableView.ChildProperty.ROW_SPAN, new Tizen.NUI.PropertyValue(value));
1567             }
1568         }
1569
1570         /// <summary>
1571         /// The number of columns this child occupies, if not set, default value is 1
1572         /// </summary>
1573         public float ColumnSpan
1574         {
1575             get
1576             {
1577                 float temp = 0.0f;
1578                 GetProperty(TableView.ChildProperty.COLUMN_SPAN).Get(out temp);
1579                 return temp;
1580             }
1581             set
1582             {
1583                 SetProperty(TableView.ChildProperty.COLUMN_SPAN, new Tizen.NUI.PropertyValue(value));
1584             }
1585         }
1586
1587         /// <summary>
1588         /// The horizontal alignment of this child inside the cells, if not set, default value is 'left'
1589         /// </summary>
1590         public Tizen.NUI.HorizontalAlignmentType CellHorizontalAlignment
1591         {
1592             get
1593             {
1594                 string temp;
1595                 if (GetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT).Get(out temp) == false)
1596                 {
1597                     NUILog.Error("CellHorizontalAlignment get error!");
1598                 }
1599
1600                 switch (temp)
1601                 {
1602                     case "left":
1603                         return Tizen.NUI.HorizontalAlignmentType.Left;
1604                     case "center":
1605                         return Tizen.NUI.HorizontalAlignmentType.Center;
1606                     case "right":
1607                         return Tizen.NUI.HorizontalAlignmentType.Right;
1608                     default:
1609                         return Tizen.NUI.HorizontalAlignmentType.Left;
1610                 }
1611             }
1612             set
1613             {
1614                 string valueToString = "";
1615                 switch (value)
1616                 {
1617                     case Tizen.NUI.HorizontalAlignmentType.Left:
1618                     {
1619                         valueToString = "left";
1620                         break;
1621                     }
1622                     case Tizen.NUI.HorizontalAlignmentType.Center:
1623                     {
1624                         valueToString = "center";
1625                         break;
1626                     }
1627                     case Tizen.NUI.HorizontalAlignmentType.Right:
1628                     {
1629                         valueToString = "right";
1630                         break;
1631                     }
1632                     default:
1633                     {
1634                         valueToString = "left";
1635                         break;
1636                     }
1637                 }
1638                 SetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT, new Tizen.NUI.PropertyValue(valueToString));
1639             }
1640         }
1641
1642         /// <summary>
1643         /// The vertical alignment of this child inside the cells, if not set, default value is 'top'
1644         /// </summary>
1645         public Tizen.NUI.VerticalAlignmentType CellVerticalAlignment
1646         {
1647             get
1648             {
1649                 string temp;
1650                 GetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT).Get(out temp);
1651                 {
1652                     NUILog.Error("CellVerticalAlignment get error!");
1653                 }
1654
1655                 switch (temp)
1656                 {
1657                     case "top":
1658                         return Tizen.NUI.VerticalAlignmentType.Top;
1659                     case "center":
1660                         return Tizen.NUI.VerticalAlignmentType.Center;
1661                     case "bottom":
1662                         return Tizen.NUI.VerticalAlignmentType.Bottom;
1663                     default:
1664                         return Tizen.NUI.VerticalAlignmentType.Top;
1665                 }
1666             }
1667             set
1668             {
1669                 string valueToString = "";
1670                 switch (value)
1671                 {
1672                     case Tizen.NUI.VerticalAlignmentType.Top:
1673                     {
1674                         valueToString = "top";
1675                         break;
1676                     }
1677                     case Tizen.NUI.VerticalAlignmentType.Center:
1678                     {
1679                         valueToString = "center";
1680                         break;
1681                     }
1682                     case Tizen.NUI.VerticalAlignmentType.Bottom:
1683                     {
1684                         valueToString = "bottom";
1685                         break;
1686                     }
1687                     default:
1688                     {
1689                         valueToString = "top";
1690                         break;
1691                     }
1692                 }
1693                 SetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT, new Tizen.NUI.PropertyValue(valueToString));
1694             }
1695         }
1696
1697         /// <summary>
1698         /// The left focusable view.<br>
1699         /// This will return NULL if not set.<br>
1700         /// This will also return NULL if the specified left focusable view is not on Window.<br>
1701         /// </summary>
1702         public View LeftFocusableView
1703         {
1704             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1705             get
1706             {
1707                 if (LeftFocusableViewId >= 0)
1708                 {
1709                     return ConvertIdToView((uint)LeftFocusableViewId);
1710                 }
1711                 return null;
1712             }
1713             set
1714             {
1715                 LeftFocusableViewId = (int)value.GetId();
1716             }
1717         }
1718
1719         /// <summary>
1720         /// The right focusable view.<br>
1721         /// This will return NULL if not set.<br>
1722         /// This will also return NULL if the specified right focusable view is not on Window.<br>
1723         /// </summary>
1724         public View RightFocusableView
1725         {
1726             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1727             get
1728             {
1729                 if (RightFocusableViewId >= 0)
1730                 {
1731                     return ConvertIdToView((uint)RightFocusableViewId);
1732                 }
1733                 return null;
1734             }
1735             set
1736             {
1737                 RightFocusableViewId = (int)value.GetId();
1738             }
1739         }
1740
1741         /// <summary>
1742         /// The up focusable view.<br>
1743         /// This will return NULL if not set.<br>
1744         /// This will also return NULL if the specified up focusable view is not on Window.<br>
1745         /// </summary>
1746         public View UpFocusableView
1747         {
1748             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1749             get
1750             {
1751                 if (UpFocusableViewId >= 0)
1752                 {
1753                     return ConvertIdToView((uint)UpFocusableViewId);
1754                 }
1755                 return null;
1756             }
1757             set
1758             {
1759                 UpFocusableViewId = (int)value.GetId();
1760             }
1761         }
1762
1763         /// <summary>
1764         /// The down focusable view.<br>
1765         /// This will return NULL if not set.<br>
1766         /// This will also return NULL if the specified down focusable view is not on Window.<br>
1767         /// </summary>
1768         public View DownFocusableView
1769         {
1770             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1771             get
1772             {
1773                 if (DownFocusableViewId >= 0)
1774                 {
1775                     return ConvertIdToView((uint)DownFocusableViewId);
1776                 }
1777                 return null;
1778             }
1779             set
1780             {
1781                 DownFocusableViewId = (int)value.GetId();
1782             }
1783         }
1784
1785         /// <summary>
1786         /// whether the view should be focusable by keyboard navigation.
1787         /// </summary>
1788         public bool Focusable
1789         {
1790             set
1791             {
1792                 SetKeyboardFocusable(value);
1793             }
1794             get
1795             {
1796                 return IsKeyboardFocusable();
1797             }
1798         }
1799
1800         /// <summary>
1801         /// Enumeration for describing the states of view.
1802         /// </summary>
1803         public enum States
1804         {
1805             /// <summary>
1806             /// Normal state
1807             /// </summary>
1808             Normal,
1809             /// <summary>
1810             /// Focused state
1811             /// </summary>
1812             Focused,
1813             /// <summary>
1814             /// Disabled state
1815             /// </summary>
1816             Disabled
1817         }
1818
1819         /// <summary>
1820         ///  Retrieves the position of the View.<br>
1821         ///  The coordinates are relative to the View's parent.<br>
1822         /// </summary>
1823         public Position CurrentPosition
1824         {
1825             get
1826             {
1827                 return GetCurrentPosition();
1828             }
1829         }
1830
1831         /// <summary>
1832         /// Sets the size of an view for width and height.<br>
1833         /// Geometry can be scaled to fit within this area.<br>
1834         /// This does not interfere with the views scale factor.<br>
1835         /// The views default depth is the minimum of width & height.<br>
1836         /// </summary>
1837         public Size2D Size2D
1838         {
1839             get
1840             {
1841                 Size temp = new Size(0.0f, 0.0f, 0.0f);
1842                 GetProperty(View.Property.SIZE).Get(temp);
1843                 Size2D size = new Size2D((int)temp.Width, (int)temp.Height);
1844                 return size;
1845             }
1846             set
1847             {
1848                 SetProperty(View.Property.SIZE, new Tizen.NUI.PropertyValue(new Size(value)));
1849             }
1850         }
1851
1852         /// <summary>
1853         ///  Retrieves the size of the View.<br>
1854         ///  The coordinates are relative to the View's parent.<br>
1855         /// </summary>
1856         public Size2D CurrentSize
1857         {
1858             get
1859             {
1860                 return GetCurrentSize();
1861             }
1862         }
1863
1864         public bool Visibility
1865         {
1866             get
1867             {
1868                 return IsVisible();
1869             }
1870         }
1871
1872         /// <summary>
1873         /// Retrieves and sets the view's opacity.<br>
1874         /// </summary>
1875         public float Opacity
1876         {
1877             get
1878             {
1879                 float temp = 0.0f;
1880                 GetProperty(View.Property.OPACITY).Get(out temp);
1881                 return temp;
1882             }
1883             set
1884             {
1885                 SetProperty(View.Property.OPACITY, new Tizen.NUI.PropertyValue(value));
1886             }
1887         }
1888
1889         /// <summary>
1890         /// Sets the position of the View for X and Y.<br>
1891         /// By default, sets the position vector between the parent origin and pivot point(default).<br>
1892         /// If Position inheritance if disabled, sets the world position.<br>
1893         /// </summary>
1894         public Position2D Position2D
1895         {
1896             get
1897             {
1898                 Position temp = new Position(0.0f, 0.0f, 0.0f);
1899                 GetProperty(View.Property.POSITION).Get(temp);
1900                 return new Position2D(temp);
1901             }
1902             set
1903             {
1904                 SetProperty(View.Property.POSITION, new Tizen.NUI.PropertyValue(new Position(value)));
1905             }
1906         }
1907
1908         /// <summary>
1909         /// Retrieves screen postion of view's.<br>
1910         /// </summary>
1911         public Vector2 ScreenPosition
1912         {
1913             get
1914             {
1915                 Vector2 temp = new Vector2(0.0f, 0.0f);
1916                 GetProperty(View.Property.SCREEN_POSITION).Get(temp);
1917                 return temp;
1918             }
1919         }
1920
1921         /// <summary>
1922         /// Determines whether the pivot point should be used to determine the position of the view.
1923         /// This is true by default.
1924         /// </summary>
1925         /// <remarks>If false, then the top-left of the view is used for the position.
1926         /// Setting this to false will allow scaling or rotation around the anchor-point without affecting the view's position.
1927         /// </remarks>
1928         public bool PositionUsesPivotPoint
1929         {
1930             get
1931             {
1932                 bool temp = false;
1933                 GetProperty(View.Property.POSITION_USES_ANCHOR_POINT).Get(out temp);
1934                 return temp;
1935             }
1936             set
1937             {
1938                 SetProperty(View.Property.POSITION_USES_ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
1939             }
1940         }
1941
1942         [Obsolete("Please do not use! this will be deprecated")]
1943         public bool PositionUsesAnchorPoint
1944         {
1945             get
1946             {
1947                 bool temp = false;
1948                 GetProperty(View.Property.POSITION_USES_ANCHOR_POINT).Get(out temp);
1949                 return temp;
1950             }
1951             set
1952             {
1953                 SetProperty(View.Property.POSITION_USES_ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
1954             }
1955         }
1956
1957         internal bool FocusState
1958         {
1959             get
1960             {
1961                 return IsKeyboardFocusable();
1962             }
1963             set
1964             {
1965                 SetKeyboardFocusable(value);
1966             }
1967         }
1968
1969         /// <summary>
1970         /// Queries whether the view is connected to the Stage.<br>
1971         /// When an view is connected, it will be directly or indirectly parented to the root View.<br>
1972         /// </summary>
1973         public bool IsOnWindow
1974         {
1975             get
1976             {
1977                 return OnWindow();
1978             }
1979         }
1980
1981         /// <summary>
1982         /// Gets depth in the hierarchy for the view.
1983         /// </summary>
1984         public int HierarchyDepth
1985         {
1986             get
1987             {
1988                 return GetHierarchyDepth();
1989             }
1990         }
1991
1992         /// <summary>
1993         /// Sets the sibling order of the view so depth position can be defined within the same parent.
1994         /// </summary>
1995         /// <remarks>
1996         /// Note The initial value is 0.
1997         /// Raise, Lower, RaiseToTop, LowerToBottom, RaiseAbove and LowerBelow will override the sibling order.
1998         /// The values set by this Property will likely change.
1999         /// </remarks>
2000         public int SiblingOrder
2001         {
2002             get
2003             {
2004                 int temp = 0;
2005                 GetProperty(View.Property.SIBLING_ORDER).Get(out temp);
2006                 return temp;
2007             }
2008             set
2009             {
2010                 SetProperty(View.Property.SIBLING_ORDER, new Tizen.NUI.PropertyValue(value));
2011             }
2012         }
2013
2014         /// <summary>
2015         /// Returns the natural size of the view.
2016         /// </summary>
2017         /// <remarks>
2018         /// Deriving classes stipulate the natural size and by default a view has a ZERO natural size.
2019         /// </remarks>
2020         [Obsolete("Please do not use! this will be deprecated, please use NaturalSize2D instead")]
2021         public Vector3 NaturalSize
2022         {
2023             get
2024             {
2025                 Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
2026                 if (NDalicPINVOKE.SWIGPendingException.Pending)
2027                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2028                 return ret;
2029             }
2030         }
2031
2032         /// <summary>
2033         /// Returns the natural size (Size2D) of the view.
2034         /// </summary>
2035         /// <remarks>
2036         /// Deriving classes stipulate the natural size and by default a view has a ZERO natural size.
2037         /// </remarks>
2038         public Size2D NaturalSize2D
2039         {
2040             get
2041             {
2042                 Vector3 temp = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
2043                 if (NDalicPINVOKE.SWIGPendingException.Pending)
2044                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2045
2046                 return new Size2D((int)temp.Width, (int)temp.Height);
2047             }
2048         }
2049
2050         /// <summary>
2051         /// Shows the View.
2052         /// </summary>
2053         /// <remarks>
2054         /// This is an asynchronous method.
2055         /// </remarks>
2056         public void Show()
2057         {
2058             SetVisible(true);
2059         }
2060
2061         /// <summary>
2062         /// Hides the View.
2063         /// </summary>
2064         /// <remarks>
2065         /// This is an asynchronous method.
2066         /// If an view is hidden, then the view and its children will not be rendered.
2067         /// This is regardless of the individual visibility of the children i.e.an view will only be rendered if all of its parents are shown.
2068         /// </remarks>
2069         public void Hide()
2070         {
2071             SetVisible(false);
2072         }
2073
2074         internal void Raise()
2075         {
2076             NDalicPINVOKE.Raise(swigCPtr);
2077             if (NDalicPINVOKE.SWIGPendingException.Pending)
2078                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2079         }
2080
2081         internal void Lower()
2082         {
2083             NDalicPINVOKE.Lower(swigCPtr);
2084             if (NDalicPINVOKE.SWIGPendingException.Pending)
2085                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2086         }
2087
2088         /// <summary>
2089         /// Raise view above all other views.
2090         /// </summary>
2091         /// <remarks>
2092         /// Sibling order of views within the parent will be updated automatically.
2093         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
2094         /// </remarks>
2095         public void RaiseToTop()
2096         {
2097             NDalicPINVOKE.RaiseToTop(swigCPtr);
2098             if (NDalicPINVOKE.SWIGPendingException.Pending)
2099                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2100         }
2101
2102         /// <summary>
2103         /// Lower view to the bottom of all views.
2104         /// </summary>
2105         /// <remarks>
2106         /// Sibling order of views within the parent will be updated automatically.
2107         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
2108         /// </remarks>
2109         public void LowerToBottom()
2110         {
2111             NDalicPINVOKE.LowerToBottom(swigCPtr);
2112             if (NDalicPINVOKE.SWIGPendingException.Pending)
2113                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2114         }
2115
2116         /// <summary>
2117         /// Query if all resources required by a View are loaded and ready.
2118         /// </summary>
2119         /// <remarks>Most resources are only loaded when the control is placed on stage
2120         /// </remarks>
2121         public bool IsResourceReady()
2122         {
2123             bool ret = NDalicPINVOKE.IsResourceReady(swigCPtr);
2124             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2125             return ret;
2126         }
2127
2128         /// <summary>
2129         /// Raise the view to above the target view.
2130         /// </summary>
2131         /// <remarks>Sibling order of views within the parent will be updated automatically.
2132         /// Views on the level above the target view will still be shown above this view.
2133         /// Raising this view above views with the same sibling order as each other will raise this view above them.
2134         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
2135         /// </remarks>
2136         /// <param name="target">Will be raised above this view</param>
2137         internal void RaiseAbove(View target)
2138         {
2139             NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
2140             if (NDalicPINVOKE.SWIGPendingException.Pending)
2141                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2142         }
2143
2144         /// <summary>
2145         /// Lower the view to below the target view.
2146         /// </summary>
2147         /// <remarks>Sibling order of views within the parent will be updated automatically.
2148         /// Lowering this view below views with the same sibling order as each other will lower this view above them.
2149         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
2150         /// </remarks>
2151         /// <param name="target">Will be lowered below this view</param>
2152         internal void LowerBelow(View target)
2153         {
2154             NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
2155             if (NDalicPINVOKE.SWIGPendingException.Pending)
2156                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2157         }
2158
2159         internal string GetName()
2160         {
2161             string ret = NDalicPINVOKE.Actor_GetName(swigCPtr);
2162             if (NDalicPINVOKE.SWIGPendingException.Pending)
2163                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2164             return ret;
2165         }
2166
2167         internal void SetName(string name)
2168         {
2169             NDalicPINVOKE.Actor_SetName(swigCPtr, name);
2170             if (NDalicPINVOKE.SWIGPendingException.Pending)
2171                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2172         }
2173
2174         internal uint GetId()
2175         {
2176             uint ret = NDalicPINVOKE.Actor_GetId(swigCPtr);
2177             if (NDalicPINVOKE.SWIGPendingException.Pending)
2178                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2179             return ret;
2180         }
2181
2182         internal bool IsRoot()
2183         {
2184             bool ret = NDalicPINVOKE.Actor_IsRoot(swigCPtr);
2185             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2186             return ret;
2187         }
2188
2189         internal bool OnWindow()
2190         {
2191             bool ret = NDalicPINVOKE.Actor_OnStage(swigCPtr);
2192             if (NDalicPINVOKE.SWIGPendingException.Pending)
2193                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2194             return ret;
2195         }
2196
2197         internal Layer GetLayer()
2198         {
2199             IntPtr cPtr = NDalicPINVOKE.Actor_GetLayer(swigCPtr);
2200             Layer ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as Layer;
2201
2202             if (NDalicPINVOKE.SWIGPendingException.Pending)
2203                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2204             return ret;
2205         }
2206
2207         /// <summary>
2208         /// Removes a View from its Parent View / Layer. If the View has no parent, this method does nothing.
2209         /// </summary>
2210         /// <pre>The (child) View has been initialized. </pre>
2211         public void Unparent()
2212         {
2213             NDalicPINVOKE.Actor_Unparent(swigCPtr);
2214             if (NDalicPINVOKE.SWIGPendingException.Pending)
2215                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2216         }
2217
2218         /// <summary>
2219         /// Search through this view's hierarchy for an view with the given name.
2220         /// The view itself is also considered in the search.
2221         /// </summary>
2222         /// <pre>The View has been initialized.</pre>
2223         /// <param name="viewName">The name of the view to find</param>
2224         /// <returns>A handle to the view if found, or an empty handle if not</returns>
2225         public View FindChildByName(string viewName)
2226         {
2227             IntPtr cPtr = NDalicPINVOKE.Actor_FindChildByName(swigCPtr, viewName);
2228
2229             View ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as View;
2230
2231             if (NDalicPINVOKE.SWIGPendingException.Pending)
2232                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2233             return ret;
2234         }
2235
2236         internal View FindChildById(uint id)
2237         {
2238             IntPtr cPtr = NDalicPINVOKE.Actor_FindChildById(swigCPtr, id);
2239
2240             View ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as View;
2241
2242             if (NDalicPINVOKE.SWIGPendingException.Pending)
2243                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2244             return ret;
2245         }
2246
2247         /*internal View GetParent()
2248         {
2249             View ret;
2250             IntPtr cPtr = NDalicPINVOKE.Actor_GetParent(swigCPtr);
2251
2252             BaseHandle basehandle = Registry.GetManagedBaseHandleFromNativePtr(cPtr);
2253
2254             if(basehandle is Layer)
2255             {
2256                 ret = new View(cPtr,false);
2257             }
2258             else
2259             {
2260                 ret = basehandle as View;
2261             }
2262
2263             if (NDalicPINVOKE.SWIGPendingException.Pending)
2264                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2265             return ret;
2266         }*/
2267
2268         internal View GetParent()
2269         {
2270             View ret;
2271             IntPtr cPtr = NDalicPINVOKE.Actor_GetParent(swigCPtr);
2272
2273             BaseHandle basehandle = Registry.GetManagedBaseHandleFromNativePtr(cPtr);
2274
2275             if(basehandle is Layer)
2276             {
2277                 View ret2 = new View(cPtr,false);
2278                 return ret2;
2279             }
2280
2281             ret = basehandle as View;
2282
2283             if (NDalicPINVOKE.SWIGPendingException.Pending)
2284                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2285             return ret;
2286         }
2287
2288         internal void SetParentOrigin(Vector3 origin)
2289         {
2290             NDalicPINVOKE.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));
2291             if (NDalicPINVOKE.SWIGPendingException.Pending)
2292                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2293         }
2294
2295         internal Vector3 GetCurrentParentOrigin()
2296         {
2297             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentParentOrigin(swigCPtr), true);
2298             if (NDalicPINVOKE.SWIGPendingException.Pending)
2299                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2300             return ret;
2301         }
2302
2303         internal void SetAnchorPoint(Vector3 anchorPoint)
2304         {
2305             NDalicPINVOKE.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
2306             if (NDalicPINVOKE.SWIGPendingException.Pending)
2307                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2308         }
2309
2310         internal Vector3 GetCurrentAnchorPoint()
2311         {
2312             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentAnchorPoint(swigCPtr), true);
2313             if (NDalicPINVOKE.SWIGPendingException.Pending)
2314                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2315             return ret;
2316         }
2317
2318         internal void SetSize(float width, float height)
2319         {
2320             NDalicPINVOKE.Actor_SetSize__SWIG_0(swigCPtr, width, height);
2321             if (NDalicPINVOKE.SWIGPendingException.Pending)
2322                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2323         }
2324
2325         internal void SetSize(float width, float height, float depth)
2326         {
2327             NDalicPINVOKE.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);
2328             if (NDalicPINVOKE.SWIGPendingException.Pending)
2329                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2330         }
2331
2332         internal void SetSize(Vector2 size)
2333         {
2334             NDalicPINVOKE.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));
2335             if (NDalicPINVOKE.SWIGPendingException.Pending)
2336                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2337         }
2338
2339         internal void SetSize(Vector3 size)
2340         {
2341             NDalicPINVOKE.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));
2342             if (NDalicPINVOKE.SWIGPendingException.Pending)
2343                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2344         }
2345
2346         internal Vector3 GetTargetSize()
2347         {
2348             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetTargetSize(swigCPtr), true);
2349             if (NDalicPINVOKE.SWIGPendingException.Pending)
2350                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2351             return ret;
2352         }
2353
2354         internal Size2D GetCurrentSize()
2355         {
2356             Size ret = new Size(NDalicPINVOKE.Actor_GetCurrentSize(swigCPtr), true);
2357             if (NDalicPINVOKE.SWIGPendingException.Pending)
2358                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2359             Size2D size = new Size2D((int)ret.Width, (int)ret.Height);
2360             return size;
2361         }
2362
2363         internal Vector3 GetNaturalSize()
2364         {
2365             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
2366             if (NDalicPINVOKE.SWIGPendingException.Pending)
2367                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2368             return ret;
2369         }
2370
2371         internal void SetPosition(float x, float y)
2372         {
2373             NDalicPINVOKE.Actor_SetPosition__SWIG_0(swigCPtr, x, y);
2374             if (NDalicPINVOKE.SWIGPendingException.Pending)
2375                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2376         }
2377
2378         internal void SetPosition(float x, float y, float z)
2379         {
2380             NDalicPINVOKE.Actor_SetPosition__SWIG_1(swigCPtr, x, y, z);
2381             if (NDalicPINVOKE.SWIGPendingException.Pending)
2382                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2383         }
2384
2385         internal void SetPosition(Vector3 position)
2386         {
2387             NDalicPINVOKE.Actor_SetPosition__SWIG_2(swigCPtr, Vector3.getCPtr(position));
2388             if (NDalicPINVOKE.SWIGPendingException.Pending)
2389                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2390         }
2391
2392         internal void SetX(float x)
2393         {
2394             NDalicPINVOKE.Actor_SetX(swigCPtr, x);
2395             if (NDalicPINVOKE.SWIGPendingException.Pending)
2396                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2397         }
2398
2399         internal void SetY(float y)
2400         {
2401             NDalicPINVOKE.Actor_SetY(swigCPtr, y);
2402             if (NDalicPINVOKE.SWIGPendingException.Pending)
2403                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2404         }
2405
2406         internal void SetZ(float z)
2407         {
2408             NDalicPINVOKE.Actor_SetZ(swigCPtr, z);
2409             if (NDalicPINVOKE.SWIGPendingException.Pending)
2410                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2411         }
2412
2413         internal void TranslateBy(Vector3 distance)
2414         {
2415             NDalicPINVOKE.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));
2416             if (NDalicPINVOKE.SWIGPendingException.Pending)
2417                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2418         }
2419
2420         internal Position GetCurrentPosition()
2421         {
2422             Position ret = new Position(NDalicPINVOKE.Actor_GetCurrentPosition(swigCPtr), true);
2423             if (NDalicPINVOKE.SWIGPendingException.Pending)
2424                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2425             return ret;
2426         }
2427
2428         internal Vector3 GetCurrentWorldPosition()
2429         {
2430             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldPosition(swigCPtr), true);
2431             if (NDalicPINVOKE.SWIGPendingException.Pending)
2432                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2433             return ret;
2434         }
2435
2436         internal void SetInheritPosition(bool inherit)
2437         {
2438             NDalicPINVOKE.Actor_SetInheritPosition(swigCPtr, inherit);
2439             if (NDalicPINVOKE.SWIGPendingException.Pending)
2440                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2441         }
2442
2443         internal bool IsPositionInherited()
2444         {
2445             bool ret = NDalicPINVOKE.Actor_IsPositionInherited(swigCPtr);
2446             if (NDalicPINVOKE.SWIGPendingException.Pending)
2447                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2448             return ret;
2449         }
2450
2451         internal void SetOrientation(Degree angle, Vector3 axis)
2452         {
2453             NDalicPINVOKE.Actor_SetOrientation__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
2454             if (NDalicPINVOKE.SWIGPendingException.Pending)
2455                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2456         }
2457
2458         internal void SetOrientation(Radian angle, Vector3 axis)
2459         {
2460             NDalicPINVOKE.Actor_SetOrientation__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
2461             if (NDalicPINVOKE.SWIGPendingException.Pending)
2462                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2463         }
2464
2465         internal void SetOrientation(Rotation orientation)
2466         {
2467             NDalicPINVOKE.Actor_SetOrientation__SWIG_2(swigCPtr, Rotation.getCPtr(orientation));
2468             if (NDalicPINVOKE.SWIGPendingException.Pending)
2469                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2470         }
2471
2472         internal void RotateBy(Degree angle, Vector3 axis)
2473         {
2474             NDalicPINVOKE.Actor_RotateBy__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
2475             if (NDalicPINVOKE.SWIGPendingException.Pending)
2476                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2477         }
2478
2479         internal void RotateBy(Radian angle, Vector3 axis)
2480         {
2481             NDalicPINVOKE.Actor_RotateBy__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
2482             if (NDalicPINVOKE.SWIGPendingException.Pending)
2483                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2484         }
2485
2486         internal void RotateBy(Rotation relativeRotation)
2487         {
2488             NDalicPINVOKE.Actor_RotateBy__SWIG_2(swigCPtr, Rotation.getCPtr(relativeRotation));
2489             if (NDalicPINVOKE.SWIGPendingException.Pending)
2490                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2491         }
2492
2493         internal Rotation GetCurrentOrientation()
2494         {
2495             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentOrientation(swigCPtr), true);
2496             if (NDalicPINVOKE.SWIGPendingException.Pending)
2497                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2498             return ret;
2499         }
2500
2501         internal void SetInheritOrientation(bool inherit)
2502         {
2503             NDalicPINVOKE.Actor_SetInheritOrientation(swigCPtr, inherit);
2504             if (NDalicPINVOKE.SWIGPendingException.Pending)
2505                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2506         }
2507
2508         internal bool IsOrientationInherited()
2509         {
2510             bool ret = NDalicPINVOKE.Actor_IsOrientationInherited(swigCPtr);
2511             if (NDalicPINVOKE.SWIGPendingException.Pending)
2512                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2513             return ret;
2514         }
2515
2516         internal Rotation GetCurrentWorldOrientation()
2517         {
2518             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentWorldOrientation(swigCPtr), true);
2519             if (NDalicPINVOKE.SWIGPendingException.Pending)
2520                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2521             return ret;
2522         }
2523
2524         internal void SetScale(float scale)
2525         {
2526             NDalicPINVOKE.Actor_SetScale__SWIG_0(swigCPtr, scale);
2527             if (NDalicPINVOKE.SWIGPendingException.Pending)
2528                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2529         }
2530
2531         internal void SetScale(float scaleX, float scaleY, float scaleZ)
2532         {
2533             NDalicPINVOKE.Actor_SetScale__SWIG_1(swigCPtr, scaleX, scaleY, scaleZ);
2534             if (NDalicPINVOKE.SWIGPendingException.Pending)
2535                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2536         }
2537
2538         internal void SetScale(Vector3 scale)
2539         {
2540             NDalicPINVOKE.Actor_SetScale__SWIG_2(swigCPtr, Vector3.getCPtr(scale));
2541             if (NDalicPINVOKE.SWIGPendingException.Pending)
2542                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2543         }
2544
2545         internal void ScaleBy(Vector3 relativeScale)
2546         {
2547             NDalicPINVOKE.Actor_ScaleBy(swigCPtr, Vector3.getCPtr(relativeScale));
2548             if (NDalicPINVOKE.SWIGPendingException.Pending)
2549                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2550         }
2551
2552         internal Vector3 GetCurrentScale()
2553         {
2554             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentScale(swigCPtr), true);
2555             if (NDalicPINVOKE.SWIGPendingException.Pending)
2556                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2557             return ret;
2558         }
2559
2560         internal Vector3 GetCurrentWorldScale()
2561         {
2562             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldScale(swigCPtr), true);
2563             if (NDalicPINVOKE.SWIGPendingException.Pending)
2564                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2565             return ret;
2566         }
2567
2568         internal void SetInheritScale(bool inherit)
2569         {
2570             NDalicPINVOKE.Actor_SetInheritScale(swigCPtr, inherit);
2571             if (NDalicPINVOKE.SWIGPendingException.Pending)
2572                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2573         }
2574
2575         internal bool IsScaleInherited()
2576         {
2577             bool ret = NDalicPINVOKE.Actor_IsScaleInherited(swigCPtr);
2578             if (NDalicPINVOKE.SWIGPendingException.Pending)
2579                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2580             return ret;
2581         }
2582
2583         internal Matrix GetCurrentWorldMatrix()
2584         {
2585             Matrix ret = new Matrix(NDalicPINVOKE.Actor_GetCurrentWorldMatrix(swigCPtr), true);
2586             if (NDalicPINVOKE.SWIGPendingException.Pending)
2587                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2588             return ret;
2589         }
2590
2591         internal void SetVisible(bool visible)
2592         {
2593             NDalicPINVOKE.Actor_SetVisible(swigCPtr, visible);
2594             if (NDalicPINVOKE.SWIGPendingException.Pending)
2595                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2596         }
2597
2598         internal bool IsVisible()
2599         {
2600             bool ret = NDalicPINVOKE.Actor_IsVisible(swigCPtr);
2601             if (NDalicPINVOKE.SWIGPendingException.Pending)
2602                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2603             return ret;
2604         }
2605
2606         internal void SetOpacity(float opacity)
2607         {
2608             NDalicPINVOKE.Actor_SetOpacity(swigCPtr, opacity);
2609             if (NDalicPINVOKE.SWIGPendingException.Pending)
2610                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2611         }
2612
2613         internal float GetCurrentOpacity()
2614         {
2615             float ret = NDalicPINVOKE.Actor_GetCurrentOpacity(swigCPtr);
2616             if (NDalicPINVOKE.SWIGPendingException.Pending)
2617                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2618             return ret;
2619         }
2620
2621         internal void SetColor(Vector4 color)
2622         {
2623             NDalicPINVOKE.Actor_SetColor(swigCPtr, Vector4.getCPtr(color));
2624             if (NDalicPINVOKE.SWIGPendingException.Pending)
2625                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2626         }
2627
2628         internal Vector4 GetCurrentColor()
2629         {
2630             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentColor(swigCPtr), true);
2631             if (NDalicPINVOKE.SWIGPendingException.Pending)
2632                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2633             return ret;
2634         }
2635
2636         internal void SetColorMode(ColorMode colorMode)
2637         {
2638             NDalicPINVOKE.Actor_SetColorMode(swigCPtr, (int)colorMode);
2639             if (NDalicPINVOKE.SWIGPendingException.Pending)
2640                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2641         }
2642
2643         internal ColorMode GetColorMode()
2644         {
2645             ColorMode ret = (ColorMode)NDalicPINVOKE.Actor_GetColorMode(swigCPtr);
2646             if (NDalicPINVOKE.SWIGPendingException.Pending)
2647                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2648             return ret;
2649         }
2650
2651         internal Vector4 GetCurrentWorldColor()
2652         {
2653             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentWorldColor(swigCPtr), true);
2654             if (NDalicPINVOKE.SWIGPendingException.Pending)
2655                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2656             return ret;
2657         }
2658
2659         internal void SetDrawMode(DrawModeType drawMode)
2660         {
2661             NDalicPINVOKE.Actor_SetDrawMode(swigCPtr, (int)drawMode);
2662             if (NDalicPINVOKE.SWIGPendingException.Pending)
2663                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2664         }
2665
2666         internal DrawModeType GetDrawMode()
2667         {
2668             DrawModeType ret = (DrawModeType)NDalicPINVOKE.Actor_GetDrawMode(swigCPtr);
2669             if (NDalicPINVOKE.SWIGPendingException.Pending)
2670                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2671             return ret;
2672         }
2673
2674         /// <summary>
2675         /// Converts screen coordinates into the view's coordinate system using the default camera.
2676         /// </summary>
2677         /// <pre>The View has been initialized.</pre>
2678         /// <remarks>The view coordinates are relative to the top-left(0.0, 0.0, 0.5)</remarks>
2679         /// <param name="localX">On return, the X-coordinate relative to the view</param>
2680         /// <param name="localY">On return, the Y-coordinate relative to the view</param>
2681         /// <param name="screenX">The screen X-coordinate</param>
2682         /// <param name="screenY">The screen Y-coordinate</param>
2683         /// <returns>True if the conversion succeeded</returns>
2684         public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY)
2685         {
2686             bool ret = NDalicPINVOKE.Actor_ScreenToLocal(swigCPtr, out localX, out localY, screenX, screenY);
2687             if (NDalicPINVOKE.SWIGPendingException.Pending)
2688                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2689             return ret;
2690         }
2691
2692         internal void SetKeyboardFocusable(bool focusable)
2693         {
2694             NDalicPINVOKE.Actor_SetKeyboardFocusable(swigCPtr, focusable);
2695             if (NDalicPINVOKE.SWIGPendingException.Pending)
2696                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2697         }
2698
2699         internal bool IsKeyboardFocusable()
2700         {
2701             bool ret = NDalicPINVOKE.Actor_IsKeyboardFocusable(swigCPtr);
2702             if (NDalicPINVOKE.SWIGPendingException.Pending)
2703                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2704             return ret;
2705         }
2706
2707         internal void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)
2708         {
2709             NDalicPINVOKE.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
2710             if (NDalicPINVOKE.SWIGPendingException.Pending)
2711                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2712         }
2713
2714         internal ResizePolicyType GetResizePolicy(DimensionType dimension)
2715         {
2716             ResizePolicyType ret = (ResizePolicyType)NDalicPINVOKE.Actor_GetResizePolicy(swigCPtr, (int)dimension);
2717             if (NDalicPINVOKE.SWIGPendingException.Pending)
2718                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2719             return ret;
2720         }
2721
2722         /// <summary>
2723         /// Sets the relative to parent size factor of the view.<br>
2724         /// This factor is only used when ResizePolicy is set to either:
2725         /// ResizePolicy::SIZE_RELATIVE_TO_PARENT or ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT.<br>
2726         /// This view's size is set to the view's size multiplied by or added to this factor, depending on ResizePolicy.<br>
2727         /// </summary>
2728         /// <pre>The View has been initialized.</pre>
2729         /// <param name="factor">A Vector3 representing the relative factor to be applied to each axis</param>
2730         public void SetSizeModeFactor(Vector3 factor)
2731         {
2732             NDalicPINVOKE.Actor_SetSizeModeFactor(swigCPtr, Vector3.getCPtr(factor));
2733             if (NDalicPINVOKE.SWIGPendingException.Pending)
2734                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2735         }
2736
2737         internal Vector3 GetSizeModeFactor()
2738         {
2739             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetSizeModeFactor(swigCPtr), true);
2740             if (NDalicPINVOKE.SWIGPendingException.Pending)
2741                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2742             return ret;
2743         }
2744
2745         /// <summary>
2746         /// Calculates the height of the view given a width.<br>
2747         /// The natural size is used for default calculation. <br>
2748         /// size 0 is treated as aspect ratio 1:1.<br>
2749         /// </summary>
2750         /// <param name="width">Width to use</param>
2751         /// <returns>The height based on the width</returns>
2752         public float GetHeightForWidth(float width)
2753         {
2754             float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);
2755             if (NDalicPINVOKE.SWIGPendingException.Pending)
2756                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2757             return ret;
2758         }
2759
2760         /// <summary>
2761         /// Calculates the width of the view given a height.<br>
2762         /// The natural size is used for default calculation.<br>
2763         /// size 0 is treated as aspect ratio 1:1.<br>
2764         /// </summary>
2765         /// <param name="height">Height to use</param>
2766         /// <returns>The width based on the height</returns>
2767         public float GetWidthForHeight(float height)
2768         {
2769             float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);
2770             if (NDalicPINVOKE.SWIGPendingException.Pending)
2771                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2772             return ret;
2773         }
2774
2775         public float GetRelayoutSize(DimensionType dimension)
2776         {
2777             float ret = NDalicPINVOKE.Actor_GetRelayoutSize(swigCPtr, (int)dimension);
2778             if (NDalicPINVOKE.SWIGPendingException.Pending)
2779                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2780             return ret;
2781         }
2782
2783         public void SetPadding(PaddingType padding)
2784         {
2785             NDalicPINVOKE.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));
2786             if (NDalicPINVOKE.SWIGPendingException.Pending)
2787                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2788         }
2789
2790         public void GetPadding(PaddingType paddingOut)
2791         {
2792             NDalicPINVOKE.Actor_GetPadding(swigCPtr, PaddingType.getCPtr(paddingOut));
2793             if (NDalicPINVOKE.SWIGPendingException.Pending)
2794                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2795         }
2796
2797         internal void SetMinimumSize(Vector2 size)
2798         {
2799             NDalicPINVOKE.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));
2800             if (NDalicPINVOKE.SWIGPendingException.Pending)
2801                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2802         }
2803
2804         internal Vector2 GetMinimumSize()
2805         {
2806             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMinimumSize(swigCPtr), true);
2807             if (NDalicPINVOKE.SWIGPendingException.Pending)
2808                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2809             return ret;
2810         }
2811
2812         internal void SetMaximumSize(Vector2 size)
2813         {
2814             NDalicPINVOKE.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));
2815             if (NDalicPINVOKE.SWIGPendingException.Pending)
2816                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2817         }
2818
2819         internal Vector2 GetMaximumSize()
2820         {
2821             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMaximumSize(swigCPtr), true);
2822             if (NDalicPINVOKE.SWIGPendingException.Pending)
2823                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2824             return ret;
2825         }
2826
2827         internal int GetHierarchyDepth()
2828         {
2829             int ret = NDalicPINVOKE.Actor_GetHierarchyDepth(swigCPtr);
2830             if (NDalicPINVOKE.SWIGPendingException.Pending)
2831                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2832             return ret;
2833         }
2834
2835         public uint AddRenderer(Renderer renderer)
2836         {
2837             uint ret = NDalicPINVOKE.Actor_AddRenderer(swigCPtr, Renderer.getCPtr(renderer));
2838             if (NDalicPINVOKE.SWIGPendingException.Pending)
2839                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2840             return ret;
2841         }
2842
2843         internal uint GetRendererCount()
2844         {
2845             uint ret = NDalicPINVOKE.Actor_GetRendererCount(swigCPtr);
2846             if (NDalicPINVOKE.SWIGPendingException.Pending)
2847                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2848             return ret;
2849         }
2850
2851         public Renderer GetRendererAt(uint index)
2852         {
2853             IntPtr cPtr = NDalicPINVOKE.Actor_GetRendererAt(swigCPtr, index);
2854             Renderer ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as Renderer;
2855
2856             if (NDalicPINVOKE.SWIGPendingException.Pending)
2857                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2858             return ret;
2859         }
2860
2861         public void RemoveRenderer(Renderer renderer)
2862         {
2863             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_0(swigCPtr, Renderer.getCPtr(renderer));
2864             if (NDalicPINVOKE.SWIGPendingException.Pending)
2865                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2866         }
2867
2868         public void RemoveRenderer(uint index)
2869         {
2870             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_1(swigCPtr, index);
2871             if (NDalicPINVOKE.SWIGPendingException.Pending)
2872                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2873         }
2874
2875         internal TouchDataSignal TouchSignal()
2876         {
2877             TouchDataSignal ret = new TouchDataSignal(NDalicPINVOKE.Actor_TouchSignal(swigCPtr), false);
2878             if (NDalicPINVOKE.SWIGPendingException.Pending)
2879                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2880             return ret;
2881         }
2882
2883         internal HoverSignal HoveredSignal()
2884         {
2885             HoverSignal ret = new HoverSignal(NDalicPINVOKE.Actor_HoveredSignal(swigCPtr), false);
2886             if (NDalicPINVOKE.SWIGPendingException.Pending)
2887                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2888             return ret;
2889         }
2890
2891         internal WheelSignal WheelEventSignal()
2892         {
2893             WheelSignal ret = new WheelSignal(NDalicPINVOKE.Actor_WheelEventSignal(swigCPtr), false);
2894             if (NDalicPINVOKE.SWIGPendingException.Pending)
2895                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2896             return ret;
2897         }
2898
2899         internal ViewSignal OnWindowSignal()
2900         {
2901             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnStageSignal(swigCPtr), false);
2902             if (NDalicPINVOKE.SWIGPendingException.Pending)
2903                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2904             return ret;
2905         }
2906
2907         internal ViewSignal OffWindowSignal()
2908         {
2909             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OffStageSignal(swigCPtr), false);
2910             if (NDalicPINVOKE.SWIGPendingException.Pending)
2911                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2912             return ret;
2913         }
2914
2915         internal ViewSignal OnRelayoutSignal()
2916         {
2917             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnRelayoutSignal(swigCPtr), false);
2918             if (NDalicPINVOKE.SWIGPendingException.Pending)
2919                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2920             return ret;
2921         }
2922
2923         internal ViewVisibilityChangedSignal VisibilityChangedSignal(View view) {
2924             ViewVisibilityChangedSignal ret = new ViewVisibilityChangedSignal(NDalicPINVOKE.VisibilityChangedSignal(View.getCPtr(view)), false);
2925             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2926             return ret;
2927         }
2928
2929         internal ViewSignal ResourcesLoadedSignal()
2930         {
2931             ViewSignal ret = new ViewSignal(NDalicPINVOKE.ResourceReadySignal(swigCPtr), false);
2932             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2933             return ret;
2934         }
2935
2936         /// <summary>
2937         /// Gets/Sets the origin of an view, within its parent's area.<br>
2938         /// This is expressed in unit coordinates, such that (0.0, 0.0, 0.5) is the top-left corner of the parent, and(1.0, 1.0, 0.5) is the bottom-right corner.<br>
2939         /// The default parent-origin is ParentOrigin.TopLeft (0.0, 0.0, 0.5).<br>
2940         /// An view's position is the distance between this origin, and the view's anchor-point.<br>
2941         /// </summary>
2942         /// <pre>The View has been initialized.</pre>
2943         public Position ParentOrigin
2944         {
2945             get
2946             {
2947                 Position temp = new Position(0.0f, 0.0f, 0.0f);
2948                 GetProperty(View.Property.PARENT_ORIGIN).Get(temp);
2949                 return temp;
2950             }
2951             set
2952             {
2953                 SetProperty(View.Property.PARENT_ORIGIN, new Tizen.NUI.PropertyValue(value));
2954             }
2955         }
2956
2957         internal float ParentOriginX
2958         {
2959             get
2960             {
2961                 float temp = 0.0f;
2962                 GetProperty(View.Property.PARENT_ORIGIN_X).Get(out temp);
2963                 return temp;
2964             }
2965             set
2966             {
2967                 SetProperty(View.Property.PARENT_ORIGIN_X, new Tizen.NUI.PropertyValue(value));
2968             }
2969         }
2970
2971         internal float ParentOriginY
2972         {
2973             get
2974             {
2975                 float temp = 0.0f;
2976                 GetProperty(View.Property.PARENT_ORIGIN_Y).Get(out temp);
2977                 return temp;
2978             }
2979             set
2980             {
2981                 SetProperty(View.Property.PARENT_ORIGIN_Y, new Tizen.NUI.PropertyValue(value));
2982             }
2983         }
2984
2985         internal float ParentOriginZ
2986         {
2987             get
2988             {
2989                 float temp = 0.0f;
2990                 GetProperty(View.Property.PARENT_ORIGIN_Z).Get(out temp);
2991                 return temp;
2992             }
2993             set
2994             {
2995                 SetProperty(View.Property.PARENT_ORIGIN_Z, new Tizen.NUI.PropertyValue(value));
2996             }
2997         }
2998
2999         /// <summary>
3000         /// Gets/Sets the anchor-point of an view.<br>
3001         /// This is expressed in unit coordinates, such that (0.0, 0.0, 0.5) is the top-left corner of the view, and (1.0, 1.0, 0.5) is the bottom-right corner.<br>
3002         /// The default pivot point is PivotPoint.Center (0.5, 0.5, 0.5).<br>
3003         /// An view position is the distance between its parent-origin and this anchor-point.<br>
3004         /// An view's orientation is the rotation from its default orientation, the rotation is centered around its anchor-point.<br>
3005         /// <pre>The View has been initialized.</pre>
3006         /// </summary>
3007         public Position PivotPoint
3008         {
3009             get
3010             {
3011                 Position temp = new Position(0.0f, 0.0f, 0.0f);
3012                 GetProperty(View.Property.ANCHOR_POINT).Get(temp);
3013                 return temp;
3014             }
3015             set
3016             {
3017                 SetProperty(View.Property.ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
3018             }
3019         }
3020
3021         internal float PivotPointX
3022         {
3023             get
3024             {
3025                 float temp = 0.0f;
3026                 GetProperty(View.Property.ANCHOR_POINT_X).Get(out temp);
3027                 return temp;
3028             }
3029             set
3030             {
3031                 SetProperty(View.Property.ANCHOR_POINT_X, new Tizen.NUI.PropertyValue(value));
3032             }
3033         }
3034
3035         internal float PivotPointY
3036         {
3037             get
3038             {
3039                 float temp = 0.0f;
3040                 GetProperty(View.Property.ANCHOR_POINT_Y).Get(out temp);
3041                 return temp;
3042             }
3043             set
3044             {
3045                 SetProperty(View.Property.ANCHOR_POINT_Y, new Tizen.NUI.PropertyValue(value));
3046             }
3047         }
3048
3049         internal float PivotPointZ
3050         {
3051             get
3052             {
3053                 float temp = 0.0f;
3054                 GetProperty(View.Property.ANCHOR_POINT_Z).Get(out temp);
3055                 return temp;
3056             }
3057             set
3058             {
3059                 SetProperty(View.Property.ANCHOR_POINT_Z, new Tizen.NUI.PropertyValue(value));
3060             }
3061         }
3062
3063         /// <summary>
3064         /// Gets/Sets the size width of an view.
3065         /// </summary>
3066         public float SizeWidth
3067         {
3068             get
3069             {
3070                 float temp = 0.0f;
3071                 GetProperty(View.Property.SIZE_WIDTH).Get(out temp);
3072                 return temp;
3073             }
3074             set
3075             {
3076                 SetProperty(View.Property.SIZE_WIDTH, new Tizen.NUI.PropertyValue(value));
3077             }
3078         }
3079
3080         /// <summary>
3081         /// Gets/Sets the size height of an view.
3082         /// </summary>
3083         public float SizeHeight
3084         {
3085             get
3086             {
3087                 float temp = 0.0f;
3088                 GetProperty(View.Property.SIZE_HEIGHT).Get(out temp);
3089                 return temp;
3090             }
3091             set
3092             {
3093                 SetProperty(View.Property.SIZE_HEIGHT, new Tizen.NUI.PropertyValue(value));
3094             }
3095         }
3096
3097         /// <summary>
3098         /// Gets/Sets the position of the View.<br>
3099         /// By default, sets the position vector between the parent origin and pivot point(default).<br>
3100         /// If Position inheritance if disabled, sets the world position.<br>
3101         /// </summary>
3102         public Position Position
3103         {
3104             get
3105             {
3106                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3107                 GetProperty(View.Property.POSITION).Get(temp);
3108                 return temp;
3109             }
3110             set
3111             {
3112                 SetProperty(View.Property.POSITION, new Tizen.NUI.PropertyValue(value));
3113             }
3114         }
3115
3116         /// <summary>
3117         /// Gets/Sets the position x of the View.
3118         /// </summary>
3119         public float PositionX
3120         {
3121             get
3122             {
3123                 float temp = 0.0f;
3124                 GetProperty(View.Property.POSITION_X).Get(out temp);
3125                 return temp;
3126             }
3127             set
3128             {
3129                 SetProperty(View.Property.POSITION_X, new Tizen.NUI.PropertyValue(value));
3130             }
3131         }
3132
3133         /// <summary>
3134         /// Gets/Sets the position y of the View.
3135         /// </summary>
3136         public float PositionY
3137         {
3138             get
3139             {
3140                 float temp = 0.0f;
3141                 GetProperty(View.Property.POSITION_Y).Get(out temp);
3142                 return temp;
3143             }
3144             set
3145             {
3146                 SetProperty(View.Property.POSITION_Y, new Tizen.NUI.PropertyValue(value));
3147             }
3148         }
3149
3150         /// <summary>
3151         /// Gets/Sets the position z of the View.
3152         /// </summary>
3153         public float PositionZ
3154         {
3155             get
3156             {
3157                 float temp = 0.0f;
3158                 GetProperty(View.Property.POSITION_Z).Get(out temp);
3159                 return temp;
3160             }
3161             set
3162             {
3163                 SetProperty(View.Property.POSITION_Z, new Tizen.NUI.PropertyValue(value));
3164             }
3165         }
3166
3167         /// <summary>
3168         /// Gets/Sets the world position of the View.
3169         /// </summary>
3170         public Vector3 WorldPosition
3171         {
3172             get
3173             {
3174                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3175                 GetProperty(View.Property.WORLD_POSITION).Get(temp);
3176                 return temp;
3177             }
3178         }
3179
3180         internal float WorldPositionX
3181         {
3182             get
3183             {
3184                 float temp = 0.0f;
3185                 GetProperty(View.Property.WORLD_POSITION_X).Get(out temp);
3186                 return temp;
3187             }
3188         }
3189
3190         internal float WorldPositionY
3191         {
3192             get
3193             {
3194                 float temp = 0.0f;
3195                 GetProperty(View.Property.WORLD_POSITION_Y).Get(out temp);
3196                 return temp;
3197             }
3198         }
3199
3200         internal float WorldPositionZ
3201         {
3202             get
3203             {
3204                 float temp = 0.0f;
3205                 GetProperty(View.Property.WORLD_POSITION_Z).Get(out temp);
3206                 return temp;
3207             }
3208         }
3209
3210         /// <summary>
3211         /// Gets/Sets the orientation of the View.<br>
3212         /// An view's orientation is the rotation from its default orientation, and the rotation is centered around its anchor-point.<br>
3213         /// </summary>
3214         /// <remarks>This is an asynchronous method.</remarks>
3215         public Rotation Orientation
3216         {
3217             get
3218             {
3219                 Rotation temp = new Rotation();
3220                 GetProperty(View.Property.ORIENTATION).Get(temp);
3221                 return temp;
3222             }
3223             set
3224             {
3225                 SetProperty(View.Property.ORIENTATION, new Tizen.NUI.PropertyValue(value));
3226             }
3227         }
3228
3229         /// <summary>
3230         /// Gets/Sets the world orientation of the View.<br>
3231         /// </summary>
3232         public Rotation WorldOrientation
3233         {
3234             get
3235             {
3236                 Rotation temp = new Rotation();
3237                 GetProperty(View.Property.WORLD_ORIENTATION).Get(temp);
3238                 return temp;
3239             }
3240         }
3241
3242         /// <summary>
3243         /// Gets/Sets the scale factor applied to an view.<br>
3244         /// </summary>
3245         public Vector3 Scale
3246         {
3247             get
3248             {
3249                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3250                 GetProperty(View.Property.SCALE).Get(temp);
3251                 return temp;
3252             }
3253             set
3254             {
3255                 SetProperty(View.Property.SCALE, new Tizen.NUI.PropertyValue(value));
3256             }
3257         }
3258
3259         /// <summary>
3260         /// Gets/Sets the scale x factor applied to an view.
3261         /// </summary>
3262         public float ScaleX
3263         {
3264             get
3265             {
3266                 float temp = 0.0f;
3267                 GetProperty(View.Property.SCALE_X).Get(out temp);
3268                 return temp;
3269             }
3270             set
3271             {
3272                 SetProperty(View.Property.SCALE_X, new Tizen.NUI.PropertyValue(value));
3273             }
3274         }
3275
3276         /// <summary>
3277         /// Gets/Sets the scale y factor applied to an view.
3278         /// </summary>
3279         public float ScaleY
3280         {
3281             get
3282             {
3283                 float temp = 0.0f;
3284                 GetProperty(View.Property.SCALE_Y).Get(out temp);
3285                 return temp;
3286             }
3287             set
3288             {
3289                 SetProperty(View.Property.SCALE_Y, new Tizen.NUI.PropertyValue(value));
3290             }
3291         }
3292
3293         /// <summary>
3294         /// Gets/Sets the scale z factor applied to an view.
3295         /// </summary>
3296         public float ScaleZ
3297         {
3298             get
3299             {
3300                 float temp = 0.0f;
3301                 GetProperty(View.Property.SCALE_Z).Get(out temp);
3302                 return temp;
3303             }
3304             set
3305             {
3306                 SetProperty(View.Property.SCALE_Z, new Tizen.NUI.PropertyValue(value));
3307             }
3308         }
3309
3310         /// <summary>
3311         /// Gets the world scale of View.
3312         /// </summary>
3313         public Vector3 WorldScale
3314         {
3315             get
3316             {
3317                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3318                 GetProperty(View.Property.WORLD_SCALE).Get(temp);
3319                 return temp;
3320             }
3321         }
3322
3323         /// <summary>
3324         /// Retrieves the visibility flag of an view.
3325         /// </summary>
3326         /// <remarks>
3327         /// If an view is not visible, then the view and its children will not be rendered.
3328         /// This is regardless of the individual visibility values of the children i.e.an view will only be rendered if all of its parents have visibility set to true.
3329         /// </remarks>
3330         public bool Visible
3331         {
3332             get
3333             {
3334                 bool temp = false;
3335                 GetProperty(View.Property.VISIBLE).Get(out temp);
3336                 return temp;
3337             }/* only get is required : removed
3338             set
3339             {
3340                 SetProperty(View.Property.VISIBLE, new Tizen.NUI.PropertyValue(value));
3341             }*/
3342         }
3343
3344         /// <summary>
3345         /// Gets the view's world color.
3346         /// </summary>
3347         public Vector4 WorldColor
3348         {
3349             get
3350             {
3351                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
3352                 GetProperty(View.Property.WORLD_COLOR).Get(temp);
3353                 return temp;
3354             }
3355         }
3356
3357         internal Matrix WorldMatrix
3358         {
3359             get
3360             {
3361                 Matrix temp = new Matrix();
3362                 GetProperty(View.Property.WORLD_MATRIX).Get(temp);
3363                 return temp;
3364             }
3365         }
3366
3367         /// <summary>
3368         /// Gets/Sets the View's name.
3369         /// </summary>
3370         public string Name
3371         {
3372             get
3373             {
3374                 string temp;
3375                 GetProperty(View.Property.NAME).Get(out temp);
3376                 return temp;
3377             }
3378             set
3379             {
3380                 SetProperty(View.Property.NAME, new Tizen.NUI.PropertyValue(value));
3381             }
3382         }
3383
3384         /// <summary>
3385         /// Gets the View's ID.
3386         /// Readonly
3387         /// </summary>
3388         public uint ID
3389         {
3390             get
3391             {
3392                 return GetId();
3393             }
3394         }
3395
3396         /// <summary>
3397         /// Gets/Sets the status of whether an view should emit touch or hover signals.
3398         /// </summary>
3399         public bool Sensitive
3400         {
3401             get
3402             {
3403                 bool temp = false;
3404                 GetProperty(View.Property.SENSITIVE).Get(out temp);
3405                 return temp;
3406             }
3407             set
3408             {
3409                 SetProperty(View.Property.SENSITIVE, new Tizen.NUI.PropertyValue(value));
3410             }
3411         }
3412
3413         /// <summary>
3414         /// Gets/Sets the status of whether the view should receive a notification when touch or hover motion events leave the boundary of the view.
3415         /// </summary>
3416         public bool LeaveRequired
3417         {
3418             get
3419             {
3420                 bool temp = false;
3421                 GetProperty(View.Property.LEAVE_REQUIRED).Get(out temp);
3422                 return temp;
3423             }
3424             set
3425             {
3426                 SetProperty(View.Property.LEAVE_REQUIRED, new Tizen.NUI.PropertyValue(value));
3427             }
3428         }
3429
3430         /// <summary>
3431         /// Gets/Sets the status of whether a child view inherits it's parent's orientation.
3432         /// </summary>
3433         public bool InheritOrientation
3434         {
3435             get
3436             {
3437                 bool temp = false;
3438                 GetProperty(View.Property.INHERIT_ORIENTATION).Get(out temp);
3439                 return temp;
3440             }
3441             set
3442             {
3443                 SetProperty(View.Property.INHERIT_ORIENTATION, new Tizen.NUI.PropertyValue(value));
3444             }
3445         }
3446
3447         /// <summary>
3448         /// Gets/Sets the status of whether a child view inherits it's parent's scale.
3449         /// </summary>
3450         public bool InheritScale
3451         {
3452             get
3453             {
3454                 bool temp = false;
3455                 GetProperty(View.Property.INHERIT_SCALE).Get(out temp);
3456                 return temp;
3457             }
3458             set
3459             {
3460                 SetProperty(View.Property.INHERIT_SCALE, new Tizen.NUI.PropertyValue(value));
3461             }
3462         }
3463
3464         /// <summary>
3465         /// Gets/Sets the status of how the view and its children should be drawn.<br>
3466         /// Not all views are renderable, but DrawMode can be inherited from any view.<br>
3467         /// If an object is in a 3D layer, it will be depth-tested against other objects in the world i.e. it may be obscured if other objects are in front.<br>
3468         /// If DrawMode.Overlay2D is used, the view and its children will be drawn as a 2D overlay.<br>
3469         /// Overlay views are drawn in a separate pass, after all non-overlay views within the Layer.<br>
3470         /// For overlay views, the drawing order is with respect to tree levels of Views, and depth-testing will not be used.<br>
3471         /// </summary>
3472         public DrawModeType DrawMode
3473         {
3474             get
3475             {
3476                 string temp;
3477                 if (GetProperty(View.Property.DRAW_MODE).Get(out temp) == false)
3478                 {
3479                     NUILog.Error("DrawMode get error!");
3480                 }
3481                 switch (temp)
3482                 {
3483                     case "NORMAL":
3484                     return DrawModeType.Normal;
3485                     case "OVERLAY_2D":
3486                     return DrawModeType.Overlay2D;
3487                     case "STENCIL":
3488                     return DrawModeType.Stencil;
3489                     default:
3490                     return DrawModeType.Normal;
3491                 }
3492             }
3493             set
3494             {
3495                 SetProperty(View.Property.DRAW_MODE, new Tizen.NUI.PropertyValue((int)value));
3496             }
3497         }
3498
3499         /// <summary>
3500         /// Gets/Sets the relative to parent size factor of the view.<br>
3501         /// This factor is only used when ResizePolicyType is set to either: ResizePolicyType.SizeRelativeToParent or ResizePolicyType.SizeFixedOffsetFromParent.<br>
3502         /// This view's size is set to the view's size multiplied by or added to this factor, depending on ResizePolicyType.<br>
3503         /// </summary>
3504         public Vector3 SizeModeFactor
3505         {
3506             get
3507             {
3508                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3509                 GetProperty(View.Property.SIZE_MODE_FACTOR).Get(temp);
3510                 return temp;
3511             }
3512             set
3513             {
3514                 SetProperty(View.Property.SIZE_MODE_FACTOR, new Tizen.NUI.PropertyValue(value));
3515             }
3516         }
3517
3518         /// <summary>
3519         /// Gets/Sets the width resize policy to be used.
3520         /// </summary>
3521         public ResizePolicyType WidthResizePolicy
3522         {
3523             get
3524             {
3525                 string temp;
3526                 if (GetProperty(View.Property.WIDTH_RESIZE_POLICY).Get(out temp) == false)
3527                 {
3528                     NUILog.Error("WidthResizePolicy get error!");
3529                 }
3530                 switch (temp)
3531                 {
3532                     case "FIXED":
3533                         return ResizePolicyType.Fixed;
3534                     case "USE_NATURAL_SIZE":
3535                         return ResizePolicyType.UseNaturalSize;
3536                     case "FILL_TO_PARENT":
3537                         return ResizePolicyType.FillToParent;
3538                     case "SIZE_RELATIVE_TO_PARENT":
3539                         return ResizePolicyType.SizeRelativeToParent;
3540                     case "SIZE_FIXED_OFFSET_FROM_PARENT":
3541                         return ResizePolicyType.SizeFixedOffsetFromParent;
3542                     case "FIT_TO_CHILDREN":
3543                         return ResizePolicyType.FitToChildren;
3544                     case "DIMENSION_DEPENDENCY":
3545                         return ResizePolicyType.DimensionDependency;
3546                     case "USE_ASSIGNED_SIZE":
3547                         return ResizePolicyType.UseAssignedSize;
3548                     default:
3549                         return ResizePolicyType.Fixed;
3550                 }
3551             }
3552             set
3553             {
3554                 SetProperty(View.Property.WIDTH_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));
3555             }
3556         }
3557
3558         /// <summary>
3559         /// Gets/Sets the height resize policy to be used.
3560         /// </summary>
3561         public ResizePolicyType HeightResizePolicy
3562         {
3563             get
3564             {
3565                 string temp;
3566                 if (GetProperty(View.Property.HEIGHT_RESIZE_POLICY).Get(out temp) == false)
3567                 {
3568                     NUILog.Error("HeightResizePolicy get error!");
3569                 }
3570                 switch (temp)
3571                 {
3572                     case "FIXED":
3573                         return ResizePolicyType.Fixed;
3574                     case "USE_NATURAL_SIZE":
3575                         return ResizePolicyType.UseNaturalSize;
3576                     case "FILL_TO_PARENT":
3577                         return ResizePolicyType.FillToParent;
3578                     case "SIZE_RELATIVE_TO_PARENT":
3579                         return ResizePolicyType.SizeRelativeToParent;
3580                     case "SIZE_FIXED_OFFSET_FROM_PARENT":
3581                         return ResizePolicyType.SizeFixedOffsetFromParent;
3582                     case "FIT_TO_CHILDREN":
3583                         return ResizePolicyType.FitToChildren;
3584                     case "DIMENSION_DEPENDENCY":
3585                         return ResizePolicyType.DimensionDependency;
3586                     case "USE_ASSIGNED_SIZE":
3587                         return ResizePolicyType.UseAssignedSize;
3588                     default:
3589                         return ResizePolicyType.Fixed;
3590                 }
3591             }
3592             set
3593             {
3594                 SetProperty(View.Property.HEIGHT_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));
3595             }
3596         }
3597
3598         /// <summary>
3599         /// Gets/Sets the policy to use when setting size with size negotiation.<br>
3600         /// Defaults to  SizeScalePolicyType.UseSizeSet.<br>
3601         /// </summary>
3602         public SizeScalePolicyType SizeScalePolicy
3603         {
3604             get
3605             {
3606                 string temp;
3607                 if (GetProperty(View.Property.SIZE_SCALE_POLICY).Get(out temp) == false)
3608                 {
3609                     NUILog.Error("SizeScalePolicy get error!");
3610                 }
3611                 switch (temp)
3612                 {
3613                     case "USE_SIZE_SET":
3614                         return SizeScalePolicyType.UseSizeSet;
3615                     case "FIT_WITH_ASPECT_RATIO":
3616                         return SizeScalePolicyType.FitWithAspectRatio;
3617                     case "FILL_WITH_ASPECT_RATIO":
3618                         return SizeScalePolicyType.FillWithAspectRatio;
3619                     default:
3620                         return SizeScalePolicyType.UseSizeSet;
3621                 }
3622             }
3623             set
3624             {
3625                 string valueToString = "";
3626                 switch (value)
3627                 {
3628                     case SizeScalePolicyType.UseSizeSet:
3629                         {
3630                             valueToString = "USE_SIZE_SET";
3631                             break;
3632                         }
3633                     case SizeScalePolicyType.FitWithAspectRatio:
3634                         {
3635                             valueToString = "FIT_WITH_ASPECT_RATIO";
3636                             break;
3637                         }
3638                     case SizeScalePolicyType.FillWithAspectRatio:
3639                         {
3640                             valueToString = "FILL_WITH_ASPECT_RATIO";
3641                             break;
3642                         }
3643                     default:
3644                         {
3645                             valueToString = "USE_SIZE_SET";
3646                             break;
3647                         }
3648                 }
3649                 SetProperty(View.Property.SIZE_SCALE_POLICY, new Tizen.NUI.PropertyValue(valueToString));
3650             }
3651         }
3652
3653         /// <summary>
3654         ///  Gets/Sets the status of whether the width size is dependent on height size.
3655         /// </summary>
3656         public bool WidthForHeight
3657         {
3658             get
3659             {
3660                 bool temp = false;
3661                 GetProperty(View.Property.WIDTH_FOR_HEIGHT).Get(out temp);
3662                 return temp;
3663             }
3664             set
3665             {
3666                 SetProperty(View.Property.WIDTH_FOR_HEIGHT, new Tizen.NUI.PropertyValue(value));
3667             }
3668         }
3669
3670         /// <summary>
3671         ///  Gets/Sets the status of whether the height size is dependent on width size.
3672         /// </summary>
3673         public bool HeightForWidth
3674         {
3675             get
3676             {
3677                 bool temp = false;
3678                 GetProperty(View.Property.HEIGHT_FOR_WIDTH).Get(out temp);
3679                 return temp;
3680             }
3681             set
3682             {
3683                 SetProperty(View.Property.HEIGHT_FOR_WIDTH, new Tizen.NUI.PropertyValue(value));
3684             }
3685         }
3686
3687         /// <summary>
3688         /// Gets/Sets the padding for use in layout.
3689         /// </summary>
3690         public Vector4 Padding
3691         {
3692             get
3693             {
3694                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
3695                 GetProperty(View.Property.PADDING).Get(temp);
3696                 return temp;
3697             }
3698             set
3699             {
3700                 SetProperty(View.Property.PADDING, new Tizen.NUI.PropertyValue(value));
3701             }
3702         }
3703
3704         /// <summary>
3705         /// Gets/Sets the minimum size an view can be assigned in size negotiation.
3706         /// </summary>
3707         public Size2D MinimumSize
3708         {
3709             get
3710             {
3711                 Size2D temp = new Size2D(0, 0);
3712                 GetProperty(View.Property.MINIMUM_SIZE).Get(temp);
3713                 return temp;
3714             }
3715             set
3716             {
3717                 SetProperty(View.Property.MINIMUM_SIZE, new Tizen.NUI.PropertyValue(value));
3718             }
3719         }
3720
3721         /// <summary>
3722         /// Gets/Sets the maximum size an view can be assigned in size negotiation.
3723         /// </summary>
3724         public Size2D MaximumSize
3725         {
3726             get
3727             {
3728                 Size2D temp = new Size2D(0, 0);
3729                 GetProperty(View.Property.MAXIMUM_SIZE).Get(temp);
3730                 return temp;
3731             }
3732             set
3733             {
3734                 SetProperty(View.Property.MAXIMUM_SIZE, new Tizen.NUI.PropertyValue(value));
3735             }
3736         }
3737
3738         /// <summary>
3739         /// Gets/Sets whether a child view inherits it's parent's position.<br>
3740         /// Default is to inherit.<br>
3741         /// Switching this off means that using Position sets the view's world position, i.e. translates from the world origin(0,0,0) to the pivot point of the view.<br>
3742         /// </summary>
3743         public bool InheritPosition
3744         {
3745             get
3746             {
3747                 bool temp = false;
3748                 GetProperty(View.Property.INHERIT_POSITION).Get(out temp);
3749                 return temp;
3750             }
3751             set
3752             {
3753                 SetProperty(View.Property.INHERIT_POSITION, new Tizen.NUI.PropertyValue(value));
3754             }
3755         }
3756
3757         /// <summary>
3758         /// Gets/Sets clipping behavior(mode) of it's children.
3759         /// </summary>
3760         public ClippingModeType ClippingMode
3761         {
3762             get
3763             {
3764                 string temp;
3765                 if (GetProperty(View.Property.CLIPPING_MODE).Get(out temp) == false)
3766                 {
3767                     NUILog.Error("ClippingMode get error!");
3768                 }
3769                 switch (temp)
3770                 {
3771                     case "DISABLED":
3772                     return ClippingModeType.Disabled;
3773                     case "CLIP_CHILDREN":
3774                     return ClippingModeType.ClipChildren;
3775                     default:
3776                     return ClippingModeType.Disabled;
3777                 }
3778             }
3779             set
3780             {
3781                 SetProperty(View.Property.CLIPPING_MODE, new Tizen.NUI.PropertyValue((int)value));
3782             }
3783         }
3784
3785         /// <summary>
3786         /// Get the number of renderers held by the view.
3787         /// </summary>
3788         public uint RendererCount
3789         {
3790             get
3791             {
3792                 return GetRendererCount();
3793             }
3794         }
3795
3796
3797
3798
3799         [Obsolete("Please do not use! this will be deprecated")]
3800         public event EventHandlerWithReturnType<object, TouchEventArgs, bool> Touched
3801         {
3802             add
3803             {
3804                 if (_touchDataEventHandler == null)
3805                 {
3806                     _touchDataCallback = OnTouch;
3807                     this.TouchSignal().Connect(_touchDataCallback);
3808                 }
3809
3810                 _touchDataEventHandler += value;
3811             }
3812
3813             remove
3814             {
3815                 _touchDataEventHandler -= value;
3816
3817                 if (_touchDataEventHandler == null && TouchSignal().Empty() == false)
3818                 {
3819                     this.TouchSignal().Disconnect(_touchDataCallback);
3820                 }
3821
3822             }
3823         }
3824
3825         [Obsolete("Please do not use! this will be deprecated")]
3826         public event EventHandlerWithReturnType<object, HoverEventArgs, bool> Hovered
3827         {
3828             add
3829             {
3830                 if (_hoverEventHandler == null)
3831                 {
3832                     _hoverEventCallback = OnHoverEvent;
3833                     this.HoveredSignal().Connect(_hoverEventCallback);
3834                 }
3835
3836                 _hoverEventHandler += value;
3837             }
3838
3839             remove
3840             {
3841                 _hoverEventHandler -= value;
3842
3843                 if (_hoverEventHandler == null && HoveredSignal().Empty() == false)
3844                 {
3845                     this.HoveredSignal().Disconnect(_hoverEventCallback);
3846                 }
3847
3848             }
3849         }
3850
3851         [Obsolete("Please do not use! this will be deprecated")]
3852         public event EventHandlerWithReturnType<object, WheelEventArgs, bool> WheelMoved
3853         {
3854             add
3855             {
3856                 if (_wheelEventHandler == null)
3857                 {
3858                     _wheelEventCallback = OnWheelEvent;
3859                     this.WheelEventSignal().Connect(_wheelEventCallback);
3860                 }
3861
3862                 _wheelEventHandler += value;
3863             }
3864
3865             remove
3866             {
3867                 _wheelEventHandler -= value;
3868
3869                 if (_wheelEventHandler == null && WheelEventSignal().Empty() == false)
3870                 {
3871                     this.WheelEventSignal().Disconnect(_wheelEventCallback);
3872                 }
3873
3874             }
3875         }
3876
3877         [Obsolete("Please do not use! this will be deprecated")]
3878         public Position AnchorPoint
3879         {
3880             get
3881             {
3882                 Position temp = new Position(0.0f, 0.0f, 0.0f);
3883                 GetProperty(View.Property.ANCHOR_POINT).Get(temp);
3884                 return temp;
3885             }
3886             set
3887             {
3888                 SetProperty(View.Property.ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
3889             }
3890         }
3891
3892         [Obsolete("Please do not use! this will be deprecated, please use Size2D instead")]
3893         public Size Size
3894         {
3895             get
3896             {
3897                 Size temp = new Size(0.0f, 0.0f, 0.0f);
3898                 GetProperty(View.Property.SIZE).Get(temp);
3899                 return temp;
3900             }
3901             set
3902             {
3903                 SetProperty(View.Property.SIZE, new Tizen.NUI.PropertyValue(value));
3904             }
3905         }
3906
3907         [Obsolete("Please do not use! this will be deprecated")]
3908         public event EventHandler OnWindowEvent
3909         {
3910             add
3911             {
3912                 if (_onWindowEventHandler == null)
3913                 {
3914                     _onWindowEventCallback = OnWindow;
3915                     this.OnWindowSignal().Connect(_onWindowEventCallback);
3916                 }
3917
3918                 _onWindowEventHandler += value;
3919             }
3920
3921             remove
3922             {
3923                 _onWindowEventHandler -= value;
3924
3925                 if (_onWindowEventHandler == null && OnWindowSignal().Empty() == false)
3926                 {
3927                     this.OnWindowSignal().Disconnect(_onWindowEventCallback);
3928                 }
3929             }
3930         }
3931
3932         [Obsolete("Please do not use! this will be deprecated")]
3933         public event EventHandler OffWindowEvent
3934         {
3935             add
3936             {
3937                 if (_offWindowEventHandler == null)
3938                 {
3939                     _offWindowEventCallback = OffWindow;
3940                     this.OffWindowSignal().Connect(_offWindowEventCallback);
3941                 }
3942
3943                 _offWindowEventHandler += value;
3944             }
3945
3946             remove
3947             {
3948                 _offWindowEventHandler -= value;
3949
3950                 if (_offWindowEventHandler == null && OffWindowSignal().Empty() == false)
3951                 {
3952                     this.OffWindowSignal().Disconnect(_offWindowEventCallback);
3953                 }
3954             }
3955         }
3956
3957         [Obsolete("Please do not use! this will be deprecated")]
3958         public event EventHandler OnRelayoutEvent
3959         {
3960             add
3961             {
3962                 if (_onRelayoutEventHandler == null)
3963                 {
3964                     _onRelayoutEventCallback = OnRelayout;
3965                     this.OnRelayoutSignal().Connect(_onRelayoutEventCallback);
3966                 }
3967
3968                 _onRelayoutEventHandler += value;
3969             }
3970
3971             remove
3972             {
3973                 _onRelayoutEventHandler -= value;
3974
3975                 if (_onRelayoutEventHandler == null && OnRelayoutSignal().Empty() == false)
3976                 {
3977                     this.OnRelayoutSignal().Disconnect(_onRelayoutEventCallback);
3978                 }
3979
3980             }
3981         }
3982
3983
3984
3985
3986     }
3987 }