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 us 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 us 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         [Obsolete("Please do not use! this will be internal property")]
2015         public Vector3 NaturalSize
2016         {
2017             get
2018             {
2019                 Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
2020                 if (NDalicPINVOKE.SWIGPendingException.Pending)
2021                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2022                 return ret;
2023             }
2024         }
2025
2026         /// <summary>
2027         /// Shows the View.
2028         /// </summary>
2029         /// <remarks>
2030         /// This is an asynchronous method.
2031         /// </remarks>
2032         public void Show()
2033         {
2034             SetVisible(true);
2035         }
2036
2037         /// <summary>
2038         /// Hides the View.
2039         /// </summary>
2040         /// <remarks>
2041         /// This is an asynchronous method.
2042         /// If an view is hidden, then the view and its children will not be rendered.
2043         /// 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.
2044         /// </remarks>
2045         public void Hide()
2046         {
2047             SetVisible(false);
2048         }
2049
2050         internal void Raise()
2051         {
2052             NDalicPINVOKE.Raise(swigCPtr);
2053             if (NDalicPINVOKE.SWIGPendingException.Pending)
2054                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2055         }
2056
2057         internal void Lower()
2058         {
2059             NDalicPINVOKE.Lower(swigCPtr);
2060             if (NDalicPINVOKE.SWIGPendingException.Pending)
2061                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2062         }
2063
2064         /// <summary>
2065         /// Raise view above all other views.
2066         /// </summary>
2067         /// <remarks>
2068         /// Sibling order of views within the parent will be updated automatically.
2069         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
2070         /// </remarks>
2071         public void RaiseToTop()
2072         {
2073             NDalicPINVOKE.RaiseToTop(swigCPtr);
2074             if (NDalicPINVOKE.SWIGPendingException.Pending)
2075                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2076         }
2077
2078         /// <summary>
2079         /// Lower view to the bottom of all views.
2080         /// </summary>
2081         /// <remarks>
2082         /// Sibling order of views within the parent will be updated automatically.
2083         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
2084         /// </remarks>
2085         public void LowerToBottom()
2086         {
2087             NDalicPINVOKE.LowerToBottom(swigCPtr);
2088             if (NDalicPINVOKE.SWIGPendingException.Pending)
2089                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2090         }
2091
2092         /// <summary>
2093         /// Query if all resources required by a View are loaded and ready.
2094         /// </summary>
2095         /// <remarks>Most resources are only loaded when the control is placed on stage
2096         /// </remarks>
2097         public bool IsResourceReady()
2098         {
2099             bool ret = NDalicPINVOKE.IsResourceReady(swigCPtr);
2100             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2101             return ret;
2102         }
2103
2104         /// <summary>
2105         /// Raise the view to above the target view.
2106         /// </summary>
2107         /// <remarks>Sibling order of views within the parent will be updated automatically.
2108         /// Views on the level above the target view will still be shown above this view.
2109         /// Raising this view above views with the same sibling order as each other will raise this view above them.
2110         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
2111         /// </remarks>
2112         /// <param name="target">Will be raised above this view</param>
2113         internal void RaiseAbove(View target)
2114         {
2115             NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
2116             if (NDalicPINVOKE.SWIGPendingException.Pending)
2117                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2118         }
2119
2120         /// <summary>
2121         /// Lower the view to below the target view.
2122         /// </summary>
2123         /// <remarks>Sibling order of views within the parent will be updated automatically.
2124         /// Lowering this view below views with the same sibling order as each other will lower this view above them.
2125         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
2126         /// </remarks>
2127         /// <param name="target">Will be lowered below this view</param>
2128         internal void LowerBelow(View target)
2129         {
2130             NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
2131             if (NDalicPINVOKE.SWIGPendingException.Pending)
2132                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2133         }
2134
2135         internal string GetName()
2136         {
2137             string ret = NDalicPINVOKE.Actor_GetName(swigCPtr);
2138             if (NDalicPINVOKE.SWIGPendingException.Pending)
2139                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2140             return ret;
2141         }
2142
2143         internal void SetName(string name)
2144         {
2145             NDalicPINVOKE.Actor_SetName(swigCPtr, name);
2146             if (NDalicPINVOKE.SWIGPendingException.Pending)
2147                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2148         }
2149
2150         internal uint GetId()
2151         {
2152             uint ret = NDalicPINVOKE.Actor_GetId(swigCPtr);
2153             if (NDalicPINVOKE.SWIGPendingException.Pending)
2154                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2155             return ret;
2156         }
2157
2158         internal bool IsRoot()
2159         {
2160             bool ret = NDalicPINVOKE.Actor_IsRoot(swigCPtr);
2161             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2162             return ret;
2163         }
2164
2165         internal bool OnWindow()
2166         {
2167             bool ret = NDalicPINVOKE.Actor_OnStage(swigCPtr);
2168             if (NDalicPINVOKE.SWIGPendingException.Pending)
2169                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2170             return ret;
2171         }
2172
2173         internal Layer GetLayer()
2174         {
2175             IntPtr cPtr = NDalicPINVOKE.Actor_GetLayer(swigCPtr);
2176             Layer ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as Layer;
2177
2178             if (NDalicPINVOKE.SWIGPendingException.Pending)
2179                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2180             return ret;
2181         }
2182
2183         /// <summary>
2184         /// Removes a View from its Parent View / Layer. If the View has no parent, this method does nothing.
2185         /// </summary>
2186         /// <pre>The (child) View has been initialized. </pre>
2187         public void Unparent()
2188         {
2189             NDalicPINVOKE.Actor_Unparent(swigCPtr);
2190             if (NDalicPINVOKE.SWIGPendingException.Pending)
2191                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2192         }
2193
2194         /// <summary>
2195         /// Search through this view's hierarchy for an view with the given name.
2196         /// The view itself is also considered in the search.
2197         /// </summary>
2198         /// <pre>The View has been initialized.</pre>
2199         /// <param name="viewName">The name of the view to find</param>
2200         /// <returns>A handle to the view if found, or an empty handle if not</returns>
2201         public View FindChildByName(string viewName)
2202         {
2203             IntPtr cPtr = NDalicPINVOKE.Actor_FindChildByName(swigCPtr, viewName);
2204
2205             View ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as View;
2206
2207             if (NDalicPINVOKE.SWIGPendingException.Pending)
2208                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2209             return ret;
2210         }
2211
2212         internal View FindChildById(uint id)
2213         {
2214             IntPtr cPtr = NDalicPINVOKE.Actor_FindChildById(swigCPtr, id);
2215
2216             View ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as View;
2217
2218             if (NDalicPINVOKE.SWIGPendingException.Pending)
2219                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2220             return ret;
2221         }
2222
2223         /*internal View GetParent()
2224         {
2225             View ret;
2226             IntPtr cPtr = NDalicPINVOKE.Actor_GetParent(swigCPtr);
2227
2228             BaseHandle basehandle = Registry.GetManagedBaseHandleFromNativePtr(cPtr);
2229
2230             if(basehandle is Layer)
2231             {
2232                 ret = new View(cPtr,false);
2233             }
2234             else
2235             {
2236                 ret = basehandle as View;
2237             }
2238
2239             if (NDalicPINVOKE.SWIGPendingException.Pending)
2240                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2241             return ret;
2242         }*/
2243
2244         internal View GetParent()
2245         {
2246             View ret;
2247             IntPtr cPtr = NDalicPINVOKE.Actor_GetParent(swigCPtr);
2248
2249             BaseHandle basehandle = Registry.GetManagedBaseHandleFromNativePtr(cPtr);
2250
2251             if(basehandle is Layer)
2252             {
2253                 View ret2 = new View(cPtr,false);
2254                 return ret2;
2255             }
2256
2257             ret = basehandle as View;
2258
2259             if (NDalicPINVOKE.SWIGPendingException.Pending)
2260                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2261             return ret;
2262         }
2263
2264         internal void SetParentOrigin(Vector3 origin)
2265         {
2266             NDalicPINVOKE.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));
2267             if (NDalicPINVOKE.SWIGPendingException.Pending)
2268                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2269         }
2270
2271         internal Vector3 GetCurrentParentOrigin()
2272         {
2273             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentParentOrigin(swigCPtr), true);
2274             if (NDalicPINVOKE.SWIGPendingException.Pending)
2275                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2276             return ret;
2277         }
2278
2279         internal void SetAnchorPoint(Vector3 anchorPoint)
2280         {
2281             NDalicPINVOKE.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
2282             if (NDalicPINVOKE.SWIGPendingException.Pending)
2283                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2284         }
2285
2286         internal Vector3 GetCurrentAnchorPoint()
2287         {
2288             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentAnchorPoint(swigCPtr), true);
2289             if (NDalicPINVOKE.SWIGPendingException.Pending)
2290                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2291             return ret;
2292         }
2293
2294         internal void SetSize(float width, float height)
2295         {
2296             NDalicPINVOKE.Actor_SetSize__SWIG_0(swigCPtr, width, height);
2297             if (NDalicPINVOKE.SWIGPendingException.Pending)
2298                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2299         }
2300
2301         internal void SetSize(float width, float height, float depth)
2302         {
2303             NDalicPINVOKE.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);
2304             if (NDalicPINVOKE.SWIGPendingException.Pending)
2305                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2306         }
2307
2308         internal void SetSize(Vector2 size)
2309         {
2310             NDalicPINVOKE.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));
2311             if (NDalicPINVOKE.SWIGPendingException.Pending)
2312                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2313         }
2314
2315         internal void SetSize(Vector3 size)
2316         {
2317             NDalicPINVOKE.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));
2318             if (NDalicPINVOKE.SWIGPendingException.Pending)
2319                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2320         }
2321
2322         internal Vector3 GetTargetSize()
2323         {
2324             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetTargetSize(swigCPtr), true);
2325             if (NDalicPINVOKE.SWIGPendingException.Pending)
2326                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2327             return ret;
2328         }
2329
2330         internal Size2D GetCurrentSize()
2331         {
2332             Size ret = new Size(NDalicPINVOKE.Actor_GetCurrentSize(swigCPtr), true);
2333             if (NDalicPINVOKE.SWIGPendingException.Pending)
2334                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2335             Size2D size = new Size2D((int)ret.Width, (int)ret.Height);
2336             return size;
2337         }
2338
2339         internal Vector3 GetNaturalSize()
2340         {
2341             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
2342             if (NDalicPINVOKE.SWIGPendingException.Pending)
2343                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2344             return ret;
2345         }
2346
2347         internal void SetPosition(float x, float y)
2348         {
2349             NDalicPINVOKE.Actor_SetPosition__SWIG_0(swigCPtr, x, y);
2350             if (NDalicPINVOKE.SWIGPendingException.Pending)
2351                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2352         }
2353
2354         internal void SetPosition(float x, float y, float z)
2355         {
2356             NDalicPINVOKE.Actor_SetPosition__SWIG_1(swigCPtr, x, y, z);
2357             if (NDalicPINVOKE.SWIGPendingException.Pending)
2358                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2359         }
2360
2361         internal void SetPosition(Vector3 position)
2362         {
2363             NDalicPINVOKE.Actor_SetPosition__SWIG_2(swigCPtr, Vector3.getCPtr(position));
2364             if (NDalicPINVOKE.SWIGPendingException.Pending)
2365                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2366         }
2367
2368         internal void SetX(float x)
2369         {
2370             NDalicPINVOKE.Actor_SetX(swigCPtr, x);
2371             if (NDalicPINVOKE.SWIGPendingException.Pending)
2372                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2373         }
2374
2375         internal void SetY(float y)
2376         {
2377             NDalicPINVOKE.Actor_SetY(swigCPtr, y);
2378             if (NDalicPINVOKE.SWIGPendingException.Pending)
2379                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2380         }
2381
2382         internal void SetZ(float z)
2383         {
2384             NDalicPINVOKE.Actor_SetZ(swigCPtr, z);
2385             if (NDalicPINVOKE.SWIGPendingException.Pending)
2386                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2387         }
2388
2389         internal void TranslateBy(Vector3 distance)
2390         {
2391             NDalicPINVOKE.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));
2392             if (NDalicPINVOKE.SWIGPendingException.Pending)
2393                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2394         }
2395
2396         internal Position GetCurrentPosition()
2397         {
2398             Position ret = new Position(NDalicPINVOKE.Actor_GetCurrentPosition(swigCPtr), true);
2399             if (NDalicPINVOKE.SWIGPendingException.Pending)
2400                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2401             return ret;
2402         }
2403
2404         internal Vector3 GetCurrentWorldPosition()
2405         {
2406             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldPosition(swigCPtr), true);
2407             if (NDalicPINVOKE.SWIGPendingException.Pending)
2408                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2409             return ret;
2410         }
2411
2412         internal void SetInheritPosition(bool inherit)
2413         {
2414             NDalicPINVOKE.Actor_SetInheritPosition(swigCPtr, inherit);
2415             if (NDalicPINVOKE.SWIGPendingException.Pending)
2416                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2417         }
2418
2419         internal bool IsPositionInherited()
2420         {
2421             bool ret = NDalicPINVOKE.Actor_IsPositionInherited(swigCPtr);
2422             if (NDalicPINVOKE.SWIGPendingException.Pending)
2423                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2424             return ret;
2425         }
2426
2427         internal void SetOrientation(Degree angle, Vector3 axis)
2428         {
2429             NDalicPINVOKE.Actor_SetOrientation__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
2430             if (NDalicPINVOKE.SWIGPendingException.Pending)
2431                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2432         }
2433
2434         internal void SetOrientation(Radian angle, Vector3 axis)
2435         {
2436             NDalicPINVOKE.Actor_SetOrientation__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
2437             if (NDalicPINVOKE.SWIGPendingException.Pending)
2438                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2439         }
2440
2441         internal void SetOrientation(Rotation orientation)
2442         {
2443             NDalicPINVOKE.Actor_SetOrientation__SWIG_2(swigCPtr, Rotation.getCPtr(orientation));
2444             if (NDalicPINVOKE.SWIGPendingException.Pending)
2445                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2446         }
2447
2448         internal void RotateBy(Degree angle, Vector3 axis)
2449         {
2450             NDalicPINVOKE.Actor_RotateBy__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
2451             if (NDalicPINVOKE.SWIGPendingException.Pending)
2452                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2453         }
2454
2455         internal void RotateBy(Radian angle, Vector3 axis)
2456         {
2457             NDalicPINVOKE.Actor_RotateBy__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
2458             if (NDalicPINVOKE.SWIGPendingException.Pending)
2459                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2460         }
2461
2462         internal void RotateBy(Rotation relativeRotation)
2463         {
2464             NDalicPINVOKE.Actor_RotateBy__SWIG_2(swigCPtr, Rotation.getCPtr(relativeRotation));
2465             if (NDalicPINVOKE.SWIGPendingException.Pending)
2466                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2467         }
2468
2469         internal Rotation GetCurrentOrientation()
2470         {
2471             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentOrientation(swigCPtr), true);
2472             if (NDalicPINVOKE.SWIGPendingException.Pending)
2473                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2474             return ret;
2475         }
2476
2477         internal void SetInheritOrientation(bool inherit)
2478         {
2479             NDalicPINVOKE.Actor_SetInheritOrientation(swigCPtr, inherit);
2480             if (NDalicPINVOKE.SWIGPendingException.Pending)
2481                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2482         }
2483
2484         internal bool IsOrientationInherited()
2485         {
2486             bool ret = NDalicPINVOKE.Actor_IsOrientationInherited(swigCPtr);
2487             if (NDalicPINVOKE.SWIGPendingException.Pending)
2488                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2489             return ret;
2490         }
2491
2492         internal Rotation GetCurrentWorldOrientation()
2493         {
2494             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentWorldOrientation(swigCPtr), true);
2495             if (NDalicPINVOKE.SWIGPendingException.Pending)
2496                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2497             return ret;
2498         }
2499
2500         internal void SetScale(float scale)
2501         {
2502             NDalicPINVOKE.Actor_SetScale__SWIG_0(swigCPtr, scale);
2503             if (NDalicPINVOKE.SWIGPendingException.Pending)
2504                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2505         }
2506
2507         internal void SetScale(float scaleX, float scaleY, float scaleZ)
2508         {
2509             NDalicPINVOKE.Actor_SetScale__SWIG_1(swigCPtr, scaleX, scaleY, scaleZ);
2510             if (NDalicPINVOKE.SWIGPendingException.Pending)
2511                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2512         }
2513
2514         internal void SetScale(Vector3 scale)
2515         {
2516             NDalicPINVOKE.Actor_SetScale__SWIG_2(swigCPtr, Vector3.getCPtr(scale));
2517             if (NDalicPINVOKE.SWIGPendingException.Pending)
2518                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2519         }
2520
2521         internal void ScaleBy(Vector3 relativeScale)
2522         {
2523             NDalicPINVOKE.Actor_ScaleBy(swigCPtr, Vector3.getCPtr(relativeScale));
2524             if (NDalicPINVOKE.SWIGPendingException.Pending)
2525                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2526         }
2527
2528         internal Vector3 GetCurrentScale()
2529         {
2530             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentScale(swigCPtr), true);
2531             if (NDalicPINVOKE.SWIGPendingException.Pending)
2532                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2533             return ret;
2534         }
2535
2536         internal Vector3 GetCurrentWorldScale()
2537         {
2538             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldScale(swigCPtr), true);
2539             if (NDalicPINVOKE.SWIGPendingException.Pending)
2540                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2541             return ret;
2542         }
2543
2544         internal void SetInheritScale(bool inherit)
2545         {
2546             NDalicPINVOKE.Actor_SetInheritScale(swigCPtr, inherit);
2547             if (NDalicPINVOKE.SWIGPendingException.Pending)
2548                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2549         }
2550
2551         internal bool IsScaleInherited()
2552         {
2553             bool ret = NDalicPINVOKE.Actor_IsScaleInherited(swigCPtr);
2554             if (NDalicPINVOKE.SWIGPendingException.Pending)
2555                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2556             return ret;
2557         }
2558
2559         internal Matrix GetCurrentWorldMatrix()
2560         {
2561             Matrix ret = new Matrix(NDalicPINVOKE.Actor_GetCurrentWorldMatrix(swigCPtr), true);
2562             if (NDalicPINVOKE.SWIGPendingException.Pending)
2563                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2564             return ret;
2565         }
2566
2567         internal void SetVisible(bool visible)
2568         {
2569             NDalicPINVOKE.Actor_SetVisible(swigCPtr, visible);
2570             if (NDalicPINVOKE.SWIGPendingException.Pending)
2571                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2572         }
2573
2574         internal bool IsVisible()
2575         {
2576             bool ret = NDalicPINVOKE.Actor_IsVisible(swigCPtr);
2577             if (NDalicPINVOKE.SWIGPendingException.Pending)
2578                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2579             return ret;
2580         }
2581
2582         internal void SetOpacity(float opacity)
2583         {
2584             NDalicPINVOKE.Actor_SetOpacity(swigCPtr, opacity);
2585             if (NDalicPINVOKE.SWIGPendingException.Pending)
2586                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2587         }
2588
2589         internal float GetCurrentOpacity()
2590         {
2591             float ret = NDalicPINVOKE.Actor_GetCurrentOpacity(swigCPtr);
2592             if (NDalicPINVOKE.SWIGPendingException.Pending)
2593                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2594             return ret;
2595         }
2596
2597         internal void SetColor(Vector4 color)
2598         {
2599             NDalicPINVOKE.Actor_SetColor(swigCPtr, Vector4.getCPtr(color));
2600             if (NDalicPINVOKE.SWIGPendingException.Pending)
2601                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2602         }
2603
2604         internal Vector4 GetCurrentColor()
2605         {
2606             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentColor(swigCPtr), true);
2607             if (NDalicPINVOKE.SWIGPendingException.Pending)
2608                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2609             return ret;
2610         }
2611
2612         internal void SetColorMode(ColorMode colorMode)
2613         {
2614             NDalicPINVOKE.Actor_SetColorMode(swigCPtr, (int)colorMode);
2615             if (NDalicPINVOKE.SWIGPendingException.Pending)
2616                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2617         }
2618
2619         internal ColorMode GetColorMode()
2620         {
2621             ColorMode ret = (ColorMode)NDalicPINVOKE.Actor_GetColorMode(swigCPtr);
2622             if (NDalicPINVOKE.SWIGPendingException.Pending)
2623                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2624             return ret;
2625         }
2626
2627         internal Vector4 GetCurrentWorldColor()
2628         {
2629             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentWorldColor(swigCPtr), true);
2630             if (NDalicPINVOKE.SWIGPendingException.Pending)
2631                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2632             return ret;
2633         }
2634
2635         internal void SetDrawMode(DrawModeType drawMode)
2636         {
2637             NDalicPINVOKE.Actor_SetDrawMode(swigCPtr, (int)drawMode);
2638             if (NDalicPINVOKE.SWIGPendingException.Pending)
2639                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2640         }
2641
2642         internal DrawModeType GetDrawMode()
2643         {
2644             DrawModeType ret = (DrawModeType)NDalicPINVOKE.Actor_GetDrawMode(swigCPtr);
2645             if (NDalicPINVOKE.SWIGPendingException.Pending)
2646                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2647             return ret;
2648         }
2649
2650         /// <summary>
2651         /// Converts screen coordinates into the view's coordinate system using the default camera.
2652         /// </summary>
2653         /// <pre>The View has been initialized.</pre>
2654         /// <remarks>The view coordinates are relative to the top-left(0.0, 0.0, 0.5)</remarks>
2655         /// <param name="localX">On return, the X-coordinate relative to the view</param>
2656         /// <param name="localY">On return, the Y-coordinate relative to the view</param>
2657         /// <param name="screenX">The screen X-coordinate</param>
2658         /// <param name="screenY">The screen Y-coordinate</param>
2659         /// <returns>True if the conversion succeeded</returns>
2660         public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY)
2661         {
2662             bool ret = NDalicPINVOKE.Actor_ScreenToLocal(swigCPtr, out localX, out localY, screenX, screenY);
2663             if (NDalicPINVOKE.SWIGPendingException.Pending)
2664                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2665             return ret;
2666         }
2667
2668         internal void SetKeyboardFocusable(bool focusable)
2669         {
2670             NDalicPINVOKE.Actor_SetKeyboardFocusable(swigCPtr, focusable);
2671             if (NDalicPINVOKE.SWIGPendingException.Pending)
2672                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2673         }
2674
2675         internal bool IsKeyboardFocusable()
2676         {
2677             bool ret = NDalicPINVOKE.Actor_IsKeyboardFocusable(swigCPtr);
2678             if (NDalicPINVOKE.SWIGPendingException.Pending)
2679                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2680             return ret;
2681         }
2682
2683         internal void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)
2684         {
2685             NDalicPINVOKE.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
2686             if (NDalicPINVOKE.SWIGPendingException.Pending)
2687                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2688         }
2689
2690         internal ResizePolicyType GetResizePolicy(DimensionType dimension)
2691         {
2692             ResizePolicyType ret = (ResizePolicyType)NDalicPINVOKE.Actor_GetResizePolicy(swigCPtr, (int)dimension);
2693             if (NDalicPINVOKE.SWIGPendingException.Pending)
2694                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2695             return ret;
2696         }
2697
2698         /// <summary>
2699         /// Sets the relative to parent size factor of the view.<br>
2700         /// This factor is only used when ResizePolicy is set to either:
2701         /// ResizePolicy::SIZE_RELATIVE_TO_PARENT or ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT.<br>
2702         /// This view's size is set to the view's size multiplied by or added to this factor, depending on ResizePolicy.<br>
2703         /// </summary>
2704         /// <pre>The View has been initialized.</pre>
2705         /// <param name="factor">A Vector3 representing the relative factor to be applied to each axis</param>
2706         public void SetSizeModeFactor(Vector3 factor)
2707         {
2708             NDalicPINVOKE.Actor_SetSizeModeFactor(swigCPtr, Vector3.getCPtr(factor));
2709             if (NDalicPINVOKE.SWIGPendingException.Pending)
2710                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2711         }
2712
2713         internal Vector3 GetSizeModeFactor()
2714         {
2715             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetSizeModeFactor(swigCPtr), true);
2716             if (NDalicPINVOKE.SWIGPendingException.Pending)
2717                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2718             return ret;
2719         }
2720
2721         /// <summary>
2722         /// Calculates the height of the view given a width.<br>
2723         /// The natural size is used for default calculation. <br>
2724         /// size 0 is treated as aspect ratio 1:1.<br>
2725         /// </summary>
2726         /// <param name="width">Width to use</param>
2727         /// <returns>The height based on the width</returns>
2728         public float GetHeightForWidth(float width)
2729         {
2730             float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);
2731             if (NDalicPINVOKE.SWIGPendingException.Pending)
2732                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2733             return ret;
2734         }
2735
2736         /// <summary>
2737         /// Calculates the width of the view given a height.<br>
2738         /// The natural size is used for default calculation.<br>
2739         /// size 0 is treated as aspect ratio 1:1.<br>
2740         /// </summary>
2741         /// <param name="height">Height to use</param>
2742         /// <returns>The width based on the height</returns>
2743         public float GetWidthForHeight(float height)
2744         {
2745             float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);
2746             if (NDalicPINVOKE.SWIGPendingException.Pending)
2747                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2748             return ret;
2749         }
2750
2751         public float GetRelayoutSize(DimensionType dimension)
2752         {
2753             float ret = NDalicPINVOKE.Actor_GetRelayoutSize(swigCPtr, (int)dimension);
2754             if (NDalicPINVOKE.SWIGPendingException.Pending)
2755                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2756             return ret;
2757         }
2758
2759         public void SetPadding(PaddingType padding)
2760         {
2761             NDalicPINVOKE.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));
2762             if (NDalicPINVOKE.SWIGPendingException.Pending)
2763                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2764         }
2765
2766         public void GetPadding(PaddingType paddingOut)
2767         {
2768             NDalicPINVOKE.Actor_GetPadding(swigCPtr, PaddingType.getCPtr(paddingOut));
2769             if (NDalicPINVOKE.SWIGPendingException.Pending)
2770                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2771         }
2772
2773         internal void SetMinimumSize(Vector2 size)
2774         {
2775             NDalicPINVOKE.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));
2776             if (NDalicPINVOKE.SWIGPendingException.Pending)
2777                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2778         }
2779
2780         internal Vector2 GetMinimumSize()
2781         {
2782             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMinimumSize(swigCPtr), true);
2783             if (NDalicPINVOKE.SWIGPendingException.Pending)
2784                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2785             return ret;
2786         }
2787
2788         internal void SetMaximumSize(Vector2 size)
2789         {
2790             NDalicPINVOKE.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));
2791             if (NDalicPINVOKE.SWIGPendingException.Pending)
2792                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2793         }
2794
2795         internal Vector2 GetMaximumSize()
2796         {
2797             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMaximumSize(swigCPtr), true);
2798             if (NDalicPINVOKE.SWIGPendingException.Pending)
2799                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2800             return ret;
2801         }
2802
2803         internal int GetHierarchyDepth()
2804         {
2805             int ret = NDalicPINVOKE.Actor_GetHierarchyDepth(swigCPtr);
2806             if (NDalicPINVOKE.SWIGPendingException.Pending)
2807                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2808             return ret;
2809         }
2810
2811         public uint AddRenderer(Renderer renderer)
2812         {
2813             uint ret = NDalicPINVOKE.Actor_AddRenderer(swigCPtr, Renderer.getCPtr(renderer));
2814             if (NDalicPINVOKE.SWIGPendingException.Pending)
2815                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2816             return ret;
2817         }
2818
2819         internal uint GetRendererCount()
2820         {
2821             uint ret = NDalicPINVOKE.Actor_GetRendererCount(swigCPtr);
2822             if (NDalicPINVOKE.SWIGPendingException.Pending)
2823                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2824             return ret;
2825         }
2826
2827         public Renderer GetRendererAt(uint index)
2828         {
2829             IntPtr cPtr = NDalicPINVOKE.Actor_GetRendererAt(swigCPtr, index);
2830             Renderer ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as Renderer;
2831
2832             if (NDalicPINVOKE.SWIGPendingException.Pending)
2833                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2834             return ret;
2835         }
2836
2837         public void RemoveRenderer(Renderer renderer)
2838         {
2839             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_0(swigCPtr, Renderer.getCPtr(renderer));
2840             if (NDalicPINVOKE.SWIGPendingException.Pending)
2841                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2842         }
2843
2844         public void RemoveRenderer(uint index)
2845         {
2846             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_1(swigCPtr, index);
2847             if (NDalicPINVOKE.SWIGPendingException.Pending)
2848                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2849         }
2850
2851         internal TouchDataSignal TouchSignal()
2852         {
2853             TouchDataSignal ret = new TouchDataSignal(NDalicPINVOKE.Actor_TouchSignal(swigCPtr), false);
2854             if (NDalicPINVOKE.SWIGPendingException.Pending)
2855                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2856             return ret;
2857         }
2858
2859         internal HoverSignal HoveredSignal()
2860         {
2861             HoverSignal ret = new HoverSignal(NDalicPINVOKE.Actor_HoveredSignal(swigCPtr), false);
2862             if (NDalicPINVOKE.SWIGPendingException.Pending)
2863                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2864             return ret;
2865         }
2866
2867         internal WheelSignal WheelEventSignal()
2868         {
2869             WheelSignal ret = new WheelSignal(NDalicPINVOKE.Actor_WheelEventSignal(swigCPtr), false);
2870             if (NDalicPINVOKE.SWIGPendingException.Pending)
2871                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2872             return ret;
2873         }
2874
2875         internal ViewSignal OnWindowSignal()
2876         {
2877             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnStageSignal(swigCPtr), false);
2878             if (NDalicPINVOKE.SWIGPendingException.Pending)
2879                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2880             return ret;
2881         }
2882
2883         internal ViewSignal OffWindowSignal()
2884         {
2885             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OffStageSignal(swigCPtr), false);
2886             if (NDalicPINVOKE.SWIGPendingException.Pending)
2887                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2888             return ret;
2889         }
2890
2891         internal ViewSignal OnRelayoutSignal()
2892         {
2893             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnRelayoutSignal(swigCPtr), false);
2894             if (NDalicPINVOKE.SWIGPendingException.Pending)
2895                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2896             return ret;
2897         }
2898
2899         internal ViewVisibilityChangedSignal VisibilityChangedSignal(View view) {
2900             ViewVisibilityChangedSignal ret = new ViewVisibilityChangedSignal(NDalicPINVOKE.VisibilityChangedSignal(View.getCPtr(view)), false);
2901             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2902             return ret;
2903         }
2904
2905         internal ViewSignal ResourcesLoadedSignal()
2906         {
2907             ViewSignal ret = new ViewSignal(NDalicPINVOKE.ResourceReadySignal(swigCPtr), false);
2908             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2909             return ret;
2910         }
2911
2912         /// <summary>
2913         /// Gets/Sets the origin of an view, within its parent's area.<br>
2914         /// 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>
2915         /// The default parent-origin is ParentOrigin.TopLeft (0.0, 0.0, 0.5).<br>
2916         /// An view's position is the distance between this origin, and the view's anchor-point.<br>
2917         /// </summary>
2918         /// <pre>The View has been initialized.</pre>
2919         public Position ParentOrigin
2920         {
2921             get
2922             {
2923                 Position temp = new Position(0.0f, 0.0f, 0.0f);
2924                 GetProperty(View.Property.PARENT_ORIGIN).Get(temp);
2925                 return temp;
2926             }
2927             set
2928             {
2929                 SetProperty(View.Property.PARENT_ORIGIN, new Tizen.NUI.PropertyValue(value));
2930             }
2931         }
2932
2933         internal float ParentOriginX
2934         {
2935             get
2936             {
2937                 float temp = 0.0f;
2938                 GetProperty(View.Property.PARENT_ORIGIN_X).Get(out temp);
2939                 return temp;
2940             }
2941             set
2942             {
2943                 SetProperty(View.Property.PARENT_ORIGIN_X, new Tizen.NUI.PropertyValue(value));
2944             }
2945         }
2946
2947         internal float ParentOriginY
2948         {
2949             get
2950             {
2951                 float temp = 0.0f;
2952                 GetProperty(View.Property.PARENT_ORIGIN_Y).Get(out temp);
2953                 return temp;
2954             }
2955             set
2956             {
2957                 SetProperty(View.Property.PARENT_ORIGIN_Y, new Tizen.NUI.PropertyValue(value));
2958             }
2959         }
2960
2961         internal float ParentOriginZ
2962         {
2963             get
2964             {
2965                 float temp = 0.0f;
2966                 GetProperty(View.Property.PARENT_ORIGIN_Z).Get(out temp);
2967                 return temp;
2968             }
2969             set
2970             {
2971                 SetProperty(View.Property.PARENT_ORIGIN_Z, new Tizen.NUI.PropertyValue(value));
2972             }
2973         }
2974
2975         /// <summary>
2976         /// Gets/Sets the anchor-point of an view.<br>
2977         /// 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>
2978         /// The default pivot point is PivotPoint.Center (0.5, 0.5, 0.5).<br>
2979         /// An view position is the distance between its parent-origin and this anchor-point.<br>
2980         /// An view's orientation is the rotation from its default orientation, the rotation is centered around its anchor-point.<br>
2981         /// <pre>The View has been initialized.</pre>
2982         /// </summary>
2983         public Position PivotPoint
2984         {
2985             get
2986             {
2987                 Position temp = new Position(0.0f, 0.0f, 0.0f);
2988                 GetProperty(View.Property.ANCHOR_POINT).Get(temp);
2989                 return temp;
2990             }
2991             set
2992             {
2993                 SetProperty(View.Property.ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
2994             }
2995         }
2996
2997         internal float PivotPointX
2998         {
2999             get
3000             {
3001                 float temp = 0.0f;
3002                 GetProperty(View.Property.ANCHOR_POINT_X).Get(out temp);
3003                 return temp;
3004             }
3005             set
3006             {
3007                 SetProperty(View.Property.ANCHOR_POINT_X, new Tizen.NUI.PropertyValue(value));
3008             }
3009         }
3010
3011         internal float PivotPointY
3012         {
3013             get
3014             {
3015                 float temp = 0.0f;
3016                 GetProperty(View.Property.ANCHOR_POINT_Y).Get(out temp);
3017                 return temp;
3018             }
3019             set
3020             {
3021                 SetProperty(View.Property.ANCHOR_POINT_Y, new Tizen.NUI.PropertyValue(value));
3022             }
3023         }
3024
3025         internal float PivotPointZ
3026         {
3027             get
3028             {
3029                 float temp = 0.0f;
3030                 GetProperty(View.Property.ANCHOR_POINT_Z).Get(out temp);
3031                 return temp;
3032             }
3033             set
3034             {
3035                 SetProperty(View.Property.ANCHOR_POINT_Z, new Tizen.NUI.PropertyValue(value));
3036             }
3037         }
3038
3039         /// <summary>
3040         /// Gets/Sets the size width of an view.
3041         /// </summary>
3042         public float SizeWidth
3043         {
3044             get
3045             {
3046                 float temp = 0.0f;
3047                 GetProperty(View.Property.SIZE_WIDTH).Get(out temp);
3048                 return temp;
3049             }
3050             set
3051             {
3052                 SetProperty(View.Property.SIZE_WIDTH, new Tizen.NUI.PropertyValue(value));
3053             }
3054         }
3055
3056         /// <summary>
3057         /// Gets/Sets the size height of an view.
3058         /// </summary>
3059         public float SizeHeight
3060         {
3061             get
3062             {
3063                 float temp = 0.0f;
3064                 GetProperty(View.Property.SIZE_HEIGHT).Get(out temp);
3065                 return temp;
3066             }
3067             set
3068             {
3069                 SetProperty(View.Property.SIZE_HEIGHT, new Tizen.NUI.PropertyValue(value));
3070             }
3071         }
3072
3073         /// <summary>
3074         /// Gets/Sets the position of the View.<br>
3075         /// By default, sets the position vector between the parent origin and pivot point(default).<br>
3076         /// If Position inheritance if disabled, sets the world position.<br>
3077         /// </summary>
3078         public Position Position
3079         {
3080             get
3081             {
3082                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3083                 GetProperty(View.Property.POSITION).Get(temp);
3084                 return temp;
3085             }
3086             set
3087             {
3088                 SetProperty(View.Property.POSITION, new Tizen.NUI.PropertyValue(value));
3089             }
3090         }
3091
3092         /// <summary>
3093         /// Gets/Sets the position x of the View.
3094         /// </summary>
3095         public float PositionX
3096         {
3097             get
3098             {
3099                 float temp = 0.0f;
3100                 GetProperty(View.Property.POSITION_X).Get(out temp);
3101                 return temp;
3102             }
3103             set
3104             {
3105                 SetProperty(View.Property.POSITION_X, new Tizen.NUI.PropertyValue(value));
3106             }
3107         }
3108
3109         /// <summary>
3110         /// Gets/Sets the position y of the View.
3111         /// </summary>
3112         public float PositionY
3113         {
3114             get
3115             {
3116                 float temp = 0.0f;
3117                 GetProperty(View.Property.POSITION_Y).Get(out temp);
3118                 return temp;
3119             }
3120             set
3121             {
3122                 SetProperty(View.Property.POSITION_Y, new Tizen.NUI.PropertyValue(value));
3123             }
3124         }
3125
3126         /// <summary>
3127         /// Gets/Sets the position z of the View.
3128         /// </summary>
3129         public float PositionZ
3130         {
3131             get
3132             {
3133                 float temp = 0.0f;
3134                 GetProperty(View.Property.POSITION_Z).Get(out temp);
3135                 return temp;
3136             }
3137             set
3138             {
3139                 SetProperty(View.Property.POSITION_Z, new Tizen.NUI.PropertyValue(value));
3140             }
3141         }
3142
3143         /// <summary>
3144         /// Gets/Sets the world position of the View.
3145         /// </summary>
3146         public Vector3 WorldPosition
3147         {
3148             get
3149             {
3150                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3151                 GetProperty(View.Property.WORLD_POSITION).Get(temp);
3152                 return temp;
3153             }
3154         }
3155
3156         internal float WorldPositionX
3157         {
3158             get
3159             {
3160                 float temp = 0.0f;
3161                 GetProperty(View.Property.WORLD_POSITION_X).Get(out temp);
3162                 return temp;
3163             }
3164         }
3165
3166         internal float WorldPositionY
3167         {
3168             get
3169             {
3170                 float temp = 0.0f;
3171                 GetProperty(View.Property.WORLD_POSITION_Y).Get(out temp);
3172                 return temp;
3173             }
3174         }
3175
3176         internal float WorldPositionZ
3177         {
3178             get
3179             {
3180                 float temp = 0.0f;
3181                 GetProperty(View.Property.WORLD_POSITION_Z).Get(out temp);
3182                 return temp;
3183             }
3184         }
3185
3186         /// <summary>
3187         /// Gets/Sets the orientation of the View.<br>
3188         /// An view's orientation is the rotation from its default orientation, and the rotation is centered around its anchor-point.<br>
3189         /// </summary>
3190         /// <remarks>This is an asynchronous method.</remarks>
3191         public Rotation Orientation
3192         {
3193             get
3194             {
3195                 Rotation temp = new Rotation();
3196                 GetProperty(View.Property.ORIENTATION).Get(temp);
3197                 return temp;
3198             }
3199             set
3200             {
3201                 SetProperty(View.Property.ORIENTATION, new Tizen.NUI.PropertyValue(value));
3202             }
3203         }
3204
3205         /// <summary>
3206         /// Gets/Sets the world orientation of the View.<br>
3207         /// </summary>
3208         public Rotation WorldOrientation
3209         {
3210             get
3211             {
3212                 Rotation temp = new Rotation();
3213                 GetProperty(View.Property.WORLD_ORIENTATION).Get(temp);
3214                 return temp;
3215             }
3216         }
3217
3218         /// <summary>
3219         /// Gets/Sets the scale factor applied to an view.<br>
3220         /// </summary>
3221         public Vector3 Scale
3222         {
3223             get
3224             {
3225                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3226                 GetProperty(View.Property.SCALE).Get(temp);
3227                 return temp;
3228             }
3229             set
3230             {
3231                 SetProperty(View.Property.SCALE, new Tizen.NUI.PropertyValue(value));
3232             }
3233         }
3234
3235         /// <summary>
3236         /// Gets/Sets the scale x factor applied to an view.
3237         /// </summary>
3238         public float ScaleX
3239         {
3240             get
3241             {
3242                 float temp = 0.0f;
3243                 GetProperty(View.Property.SCALE_X).Get(out temp);
3244                 return temp;
3245             }
3246             set
3247             {
3248                 SetProperty(View.Property.SCALE_X, new Tizen.NUI.PropertyValue(value));
3249             }
3250         }
3251
3252         /// <summary>
3253         /// Gets/Sets the scale y factor applied to an view.
3254         /// </summary>
3255         public float ScaleY
3256         {
3257             get
3258             {
3259                 float temp = 0.0f;
3260                 GetProperty(View.Property.SCALE_Y).Get(out temp);
3261                 return temp;
3262             }
3263             set
3264             {
3265                 SetProperty(View.Property.SCALE_Y, new Tizen.NUI.PropertyValue(value));
3266             }
3267         }
3268
3269         /// <summary>
3270         /// Gets/Sets the scale z factor applied to an view.
3271         /// </summary>
3272         public float ScaleZ
3273         {
3274             get
3275             {
3276                 float temp = 0.0f;
3277                 GetProperty(View.Property.SCALE_Z).Get(out temp);
3278                 return temp;
3279             }
3280             set
3281             {
3282                 SetProperty(View.Property.SCALE_Z, new Tizen.NUI.PropertyValue(value));
3283             }
3284         }
3285
3286         /// <summary>
3287         /// Gets the world scale of View.
3288         /// </summary>
3289         public Vector3 WorldScale
3290         {
3291             get
3292             {
3293                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3294                 GetProperty(View.Property.WORLD_SCALE).Get(temp);
3295                 return temp;
3296             }
3297         }
3298
3299         /// <summary>
3300         /// Retrieves the visibility flag of an view.
3301         /// </summary>
3302         /// <remarks>
3303         /// If an view is not visible, then the view and its children will not be rendered.
3304         /// 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.
3305         /// </remarks>
3306         public bool Visible
3307         {
3308             get
3309             {
3310                 bool temp = false;
3311                 GetProperty(View.Property.VISIBLE).Get(out temp);
3312                 return temp;
3313             }/* only get is required : removed
3314             set
3315             {
3316                 SetProperty(View.Property.VISIBLE, new Tizen.NUI.PropertyValue(value));
3317             }*/
3318         }
3319
3320         /// <summary>
3321         /// Gets the view's world color.
3322         /// </summary>
3323         public Vector4 WorldColor
3324         {
3325             get
3326             {
3327                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
3328                 GetProperty(View.Property.WORLD_COLOR).Get(temp);
3329                 return temp;
3330             }
3331         }
3332
3333         internal Matrix WorldMatrix
3334         {
3335             get
3336             {
3337                 Matrix temp = new Matrix();
3338                 GetProperty(View.Property.WORLD_MATRIX).Get(temp);
3339                 return temp;
3340             }
3341         }
3342
3343         /// <summary>
3344         /// Gets/Sets the View's name.
3345         /// </summary>
3346         public string Name
3347         {
3348             get
3349             {
3350                 string temp;
3351                 GetProperty(View.Property.NAME).Get(out temp);
3352                 return temp;
3353             }
3354             set
3355             {
3356                 SetProperty(View.Property.NAME, new Tizen.NUI.PropertyValue(value));
3357             }
3358         }
3359
3360         /// <summary>
3361         /// Gets the View's ID.
3362         /// Readonly
3363         /// </summary>
3364         public uint ID
3365         {
3366             get
3367             {
3368                 return GetId();
3369             }
3370         }
3371
3372         /// <summary>
3373         /// Gets/Sets the status of whether an view should emit touch or hover signals.
3374         /// </summary>
3375         public bool Sensitive
3376         {
3377             get
3378             {
3379                 bool temp = false;
3380                 GetProperty(View.Property.SENSITIVE).Get(out temp);
3381                 return temp;
3382             }
3383             set
3384             {
3385                 SetProperty(View.Property.SENSITIVE, new Tizen.NUI.PropertyValue(value));
3386             }
3387         }
3388
3389         /// <summary>
3390         /// Gets/Sets the status of whether the view should receive a notification when touch or hover motion events leave the boundary of the view.
3391         /// </summary>
3392         public bool LeaveRequired
3393         {
3394             get
3395             {
3396                 bool temp = false;
3397                 GetProperty(View.Property.LEAVE_REQUIRED).Get(out temp);
3398                 return temp;
3399             }
3400             set
3401             {
3402                 SetProperty(View.Property.LEAVE_REQUIRED, new Tizen.NUI.PropertyValue(value));
3403             }
3404         }
3405
3406         /// <summary>
3407         /// Gets/Sets the status of whether a child view inherits it's parent's orientation.
3408         /// </summary>
3409         public bool InheritOrientation
3410         {
3411             get
3412             {
3413                 bool temp = false;
3414                 GetProperty(View.Property.INHERIT_ORIENTATION).Get(out temp);
3415                 return temp;
3416             }
3417             set
3418             {
3419                 SetProperty(View.Property.INHERIT_ORIENTATION, new Tizen.NUI.PropertyValue(value));
3420             }
3421         }
3422
3423         /// <summary>
3424         /// Gets/Sets the status of whether a child view inherits it's parent's scale.
3425         /// </summary>
3426         public bool InheritScale
3427         {
3428             get
3429             {
3430                 bool temp = false;
3431                 GetProperty(View.Property.INHERIT_SCALE).Get(out temp);
3432                 return temp;
3433             }
3434             set
3435             {
3436                 SetProperty(View.Property.INHERIT_SCALE, new Tizen.NUI.PropertyValue(value));
3437             }
3438         }
3439
3440         /// <summary>
3441         /// Gets/Sets the status of how the view and its children should be drawn.<br>
3442         /// Not all views are renderable, but DrawMode can be inherited from any view.<br>
3443         /// 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>
3444         /// If DrawMode.Overlay2D is used, the view and its children will be drawn as a 2D overlay.<br>
3445         /// Overlay views are drawn in a separate pass, after all non-overlay views within the Layer.<br>
3446         /// For overlay views, the drawing order is with respect to tree levels of Views, and depth-testing will not be used.<br>
3447         /// </summary>
3448         public DrawModeType DrawMode
3449         {
3450             get
3451             {
3452                 string temp;
3453                 if (GetProperty(View.Property.DRAW_MODE).Get(out temp) == false)
3454                 {
3455                     NUILog.Error("DrawMode get error!");
3456                 }
3457                 switch (temp)
3458                 {
3459                     case "NORMAL":
3460                     return DrawModeType.Normal;
3461                     case "OVERLAY_2D":
3462                     return DrawModeType.Overlay2D;
3463                     case "STENCIL":
3464                     return DrawModeType.Stencil;
3465                     default:
3466                     return DrawModeType.Normal;
3467                 }
3468             }
3469             set
3470             {
3471                 SetProperty(View.Property.DRAW_MODE, new Tizen.NUI.PropertyValue((int)value));
3472             }
3473         }
3474
3475         /// <summary>
3476         /// Gets/Sets the relative to parent size factor of the view.<br>
3477         /// This factor is only used when ResizePolicyType is set to either: ResizePolicyType.SizeRelativeToParent or ResizePolicyType.SizeFixedOffsetFromParent.<br>
3478         /// This view's size is set to the view's size multiplied by or added to this factor, depending on ResizePolicyType.<br>
3479         /// </summary>
3480         public Vector3 SizeModeFactor
3481         {
3482             get
3483             {
3484                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3485                 GetProperty(View.Property.SIZE_MODE_FACTOR).Get(temp);
3486                 return temp;
3487             }
3488             set
3489             {
3490                 SetProperty(View.Property.SIZE_MODE_FACTOR, new Tizen.NUI.PropertyValue(value));
3491             }
3492         }
3493
3494         /// <summary>
3495         /// Gets/Sets the width resize policy to be used.
3496         /// </summary>
3497         public ResizePolicyType WidthResizePolicy
3498         {
3499             get
3500             {
3501                 string temp;
3502                 if (GetProperty(View.Property.WIDTH_RESIZE_POLICY).Get(out temp) == false)
3503                 {
3504                     NUILog.Error("WidthResizePolicy get error!");
3505                 }
3506                 switch (temp)
3507                 {
3508                     case "FIXED":
3509                         return ResizePolicyType.Fixed;
3510                     case "USE_NATURAL_SIZE":
3511                         return ResizePolicyType.UseNaturalSize;
3512                     case "FILL_TO_PARENT":
3513                         return ResizePolicyType.FillToParent;
3514                     case "SIZE_RELATIVE_TO_PARENT":
3515                         return ResizePolicyType.SizeRelativeToParent;
3516                     case "SIZE_FIXED_OFFSET_FROM_PARENT":
3517                         return ResizePolicyType.SizeFixedOffsetFromParent;
3518                     case "FIT_TO_CHILDREN":
3519                         return ResizePolicyType.FitToChildren;
3520                     case "DIMENSION_DEPENDENCY":
3521                         return ResizePolicyType.DimensionDependency;
3522                     case "USE_ASSIGNED_SIZE":
3523                         return ResizePolicyType.UseAssignedSize;
3524                     default:
3525                         return ResizePolicyType.Fixed;
3526                 }
3527             }
3528             set
3529             {
3530                 SetProperty(View.Property.WIDTH_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));
3531             }
3532         }
3533
3534         /// <summary>
3535         /// Gets/Sets the height resize policy to be used.
3536         /// </summary>
3537         public ResizePolicyType HeightResizePolicy
3538         {
3539             get
3540             {
3541                 string temp;
3542                 if (GetProperty(View.Property.HEIGHT_RESIZE_POLICY).Get(out temp) == false)
3543                 {
3544                     NUILog.Error("HeightResizePolicy get error!");
3545                 }
3546                 switch (temp)
3547                 {
3548                     case "FIXED":
3549                         return ResizePolicyType.Fixed;
3550                     case "USE_NATURAL_SIZE":
3551                         return ResizePolicyType.UseNaturalSize;
3552                     case "FILL_TO_PARENT":
3553                         return ResizePolicyType.FillToParent;
3554                     case "SIZE_RELATIVE_TO_PARENT":
3555                         return ResizePolicyType.SizeRelativeToParent;
3556                     case "SIZE_FIXED_OFFSET_FROM_PARENT":
3557                         return ResizePolicyType.SizeFixedOffsetFromParent;
3558                     case "FIT_TO_CHILDREN":
3559                         return ResizePolicyType.FitToChildren;
3560                     case "DIMENSION_DEPENDENCY":
3561                         return ResizePolicyType.DimensionDependency;
3562                     case "USE_ASSIGNED_SIZE":
3563                         return ResizePolicyType.UseAssignedSize;
3564                     default:
3565                         return ResizePolicyType.Fixed;
3566                 }
3567             }
3568             set
3569             {
3570                 SetProperty(View.Property.HEIGHT_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));
3571             }
3572         }
3573
3574         /// <summary>
3575         /// Gets/Sets the policy to use when setting size with size negotiation.<br>
3576         /// Defaults to  SizeScalePolicyType.UseSizeSet.<br>
3577         /// </summary>
3578         public SizeScalePolicyType SizeScalePolicy
3579         {
3580             get
3581             {
3582                 string temp;
3583                 if (GetProperty(View.Property.SIZE_SCALE_POLICY).Get(out temp) == false)
3584                 {
3585                     NUILog.Error("SizeScalePolicy get error!");
3586                 }
3587                 switch (temp)
3588                 {
3589                     case "USE_SIZE_SET":
3590                         return SizeScalePolicyType.UseSizeSet;
3591                     case "FIT_WITH_ASPECT_RATIO":
3592                         return SizeScalePolicyType.FitWithAspectRatio;
3593                     case "FILL_WITH_ASPECT_RATIO":
3594                         return SizeScalePolicyType.FillWithAspectRatio;
3595                     default:
3596                         return SizeScalePolicyType.UseSizeSet;
3597                 }
3598             }
3599             set
3600             {
3601                 string valueToString = "";
3602                 switch (value)
3603                 {
3604                     case SizeScalePolicyType.UseSizeSet:
3605                         {
3606                             valueToString = "USE_SIZE_SET";
3607                             break;
3608                         }
3609                     case SizeScalePolicyType.FitWithAspectRatio:
3610                         {
3611                             valueToString = "FIT_WITH_ASPECT_RATIO";
3612                             break;
3613                         }
3614                     case SizeScalePolicyType.FillWithAspectRatio:
3615                         {
3616                             valueToString = "FILL_WITH_ASPECT_RATIO";
3617                             break;
3618                         }
3619                     default:
3620                         {
3621                             valueToString = "USE_SIZE_SET";
3622                             break;
3623                         }
3624                 }
3625                 SetProperty(View.Property.SIZE_SCALE_POLICY, new Tizen.NUI.PropertyValue(valueToString));
3626             }
3627         }
3628
3629         /// <summary>
3630         ///  Gets/Sets the status of whether the width size is dependent on height size.
3631         /// </summary>
3632         public bool WidthForHeight
3633         {
3634             get
3635             {
3636                 bool temp = false;
3637                 GetProperty(View.Property.WIDTH_FOR_HEIGHT).Get(out temp);
3638                 return temp;
3639             }
3640             set
3641             {
3642                 SetProperty(View.Property.WIDTH_FOR_HEIGHT, new Tizen.NUI.PropertyValue(value));
3643             }
3644         }
3645
3646         /// <summary>
3647         ///  Gets/Sets the status of whether the height size is dependent on width size.
3648         /// </summary>
3649         public bool HeightForWidth
3650         {
3651             get
3652             {
3653                 bool temp = false;
3654                 GetProperty(View.Property.HEIGHT_FOR_WIDTH).Get(out temp);
3655                 return temp;
3656             }
3657             set
3658             {
3659                 SetProperty(View.Property.HEIGHT_FOR_WIDTH, new Tizen.NUI.PropertyValue(value));
3660             }
3661         }
3662
3663         /// <summary>
3664         /// Gets/Sets the padding for use in layout.
3665         /// </summary>
3666         public Vector4 Padding
3667         {
3668             get
3669             {
3670                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
3671                 GetProperty(View.Property.PADDING).Get(temp);
3672                 return temp;
3673             }
3674             set
3675             {
3676                 SetProperty(View.Property.PADDING, new Tizen.NUI.PropertyValue(value));
3677             }
3678         }
3679
3680         /// <summary>
3681         /// Gets/Sets the minimum size an view can be assigned in size negotiation.
3682         /// </summary>
3683         public Size2D MinimumSize
3684         {
3685             get
3686             {
3687                 Size2D temp = new Size2D(0, 0);
3688                 GetProperty(View.Property.MINIMUM_SIZE).Get(temp);
3689                 return temp;
3690             }
3691             set
3692             {
3693                 SetProperty(View.Property.MINIMUM_SIZE, new Tizen.NUI.PropertyValue(value));
3694             }
3695         }
3696
3697         /// <summary>
3698         /// Gets/Sets the maximum size an view can be assigned in size negotiation.
3699         /// </summary>
3700         public Size2D MaximumSize
3701         {
3702             get
3703             {
3704                 Size2D temp = new Size2D(0, 0);
3705                 GetProperty(View.Property.MAXIMUM_SIZE).Get(temp);
3706                 return temp;
3707             }
3708             set
3709             {
3710                 SetProperty(View.Property.MAXIMUM_SIZE, new Tizen.NUI.PropertyValue(value));
3711             }
3712         }
3713
3714         /// <summary>
3715         /// Gets/Sets whether a child view inherits it's parent's position.<br>
3716         /// Default is to inherit.<br>
3717         /// 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>
3718         /// </summary>
3719         public bool InheritPosition
3720         {
3721             get
3722             {
3723                 bool temp = false;
3724                 GetProperty(View.Property.INHERIT_POSITION).Get(out temp);
3725                 return temp;
3726             }
3727             set
3728             {
3729                 SetProperty(View.Property.INHERIT_POSITION, new Tizen.NUI.PropertyValue(value));
3730             }
3731         }
3732
3733         /// <summary>
3734         /// Gets/Sets clipping behavior(mode) of it's children.
3735         /// </summary>
3736         public ClippingModeType ClippingMode
3737         {
3738             get
3739             {
3740                 string temp;
3741                 if (GetProperty(View.Property.CLIPPING_MODE).Get(out temp) == false)
3742                 {
3743                     NUILog.Error("ClippingMode get error!");
3744                 }
3745                 switch (temp)
3746                 {
3747                     case "DISABLED":
3748                     return ClippingModeType.Disabled;
3749                     case "CLIP_CHILDREN":
3750                     return ClippingModeType.ClipChildren;
3751                     default:
3752                     return ClippingModeType.Disabled;
3753                 }
3754             }
3755             set
3756             {
3757                 SetProperty(View.Property.CLIPPING_MODE, new Tizen.NUI.PropertyValue((int)value));
3758             }
3759         }
3760
3761         /// <summary>
3762         /// Get the number of renderers held by the view.
3763         /// </summary>
3764         public uint RendererCount
3765         {
3766             get
3767             {
3768                 return GetRendererCount();
3769             }
3770         }
3771
3772
3773
3774
3775         [Obsolete("Please do not use! this will be deprecated")]
3776         public event EventHandlerWithReturnType<object, TouchEventArgs, bool> Touched
3777         {
3778             add
3779             {
3780                 if (_touchDataEventHandler == null)
3781                 {
3782                     _touchDataCallback = OnTouch;
3783                     this.TouchSignal().Connect(_touchDataCallback);
3784                 }
3785
3786                 _touchDataEventHandler += value;
3787             }
3788
3789             remove
3790             {
3791                 _touchDataEventHandler -= value;
3792
3793                 if (_touchDataEventHandler == null && TouchSignal().Empty() == false)
3794                 {
3795                     this.TouchSignal().Disconnect(_touchDataCallback);
3796                 }
3797
3798             }
3799         }
3800
3801         [Obsolete("Please do not use! this will be deprecated")]
3802         public event EventHandlerWithReturnType<object, HoverEventArgs, bool> Hovered
3803         {
3804             add
3805             {
3806                 if (_hoverEventHandler == null)
3807                 {
3808                     _hoverEventCallback = OnHoverEvent;
3809                     this.HoveredSignal().Connect(_hoverEventCallback);
3810                 }
3811
3812                 _hoverEventHandler += value;
3813             }
3814
3815             remove
3816             {
3817                 _hoverEventHandler -= value;
3818
3819                 if (_hoverEventHandler == null && HoveredSignal().Empty() == false)
3820                 {
3821                     this.HoveredSignal().Disconnect(_hoverEventCallback);
3822                 }
3823
3824             }
3825         }
3826
3827         [Obsolete("Please do not use! this will be deprecated")]
3828         public event EventHandlerWithReturnType<object, WheelEventArgs, bool> WheelMoved
3829         {
3830             add
3831             {
3832                 if (_wheelEventHandler == null)
3833                 {
3834                     _wheelEventCallback = OnWheelEvent;
3835                     this.WheelEventSignal().Connect(_wheelEventCallback);
3836                 }
3837
3838                 _wheelEventHandler += value;
3839             }
3840
3841             remove
3842             {
3843                 _wheelEventHandler -= value;
3844
3845                 if (_wheelEventHandler == null && WheelEventSignal().Empty() == false)
3846                 {
3847                     this.WheelEventSignal().Disconnect(_wheelEventCallback);
3848                 }
3849
3850             }
3851         }
3852
3853         [Obsolete("Please do not use! this will be deprecated")]
3854         public Position AnchorPoint
3855         {
3856             get
3857             {
3858                 Position temp = new Position(0.0f, 0.0f, 0.0f);
3859                 GetProperty(View.Property.ANCHOR_POINT).Get(temp);
3860                 return temp;
3861             }
3862             set
3863             {
3864                 SetProperty(View.Property.ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
3865             }
3866         }
3867
3868         [Obsolete("Please do not use! this will be deprecated")]
3869         public Size Size
3870         {
3871             get
3872             {
3873                 Size temp = new Size(0.0f, 0.0f, 0.0f);
3874                 GetProperty(View.Property.SIZE).Get(temp);
3875                 return temp;
3876             }
3877             set
3878             {
3879                 SetProperty(View.Property.SIZE, new Tizen.NUI.PropertyValue(value));
3880             }
3881         }
3882
3883         [Obsolete("Please do not use! this will be deprecated")]
3884         public event EventHandler OnWindowEvent
3885         {
3886             add
3887             {
3888                 if (_onWindowEventHandler == null)
3889                 {
3890                     _onWindowEventCallback = OnWindow;
3891                     this.OnWindowSignal().Connect(_onWindowEventCallback);
3892                 }
3893
3894                 _onWindowEventHandler += value;
3895             }
3896
3897             remove
3898             {
3899                 _onWindowEventHandler -= value;
3900
3901                 if (_onWindowEventHandler == null && OnWindowSignal().Empty() == false)
3902                 {
3903                     this.OnWindowSignal().Disconnect(_onWindowEventCallback);
3904                 }
3905             }
3906         }
3907
3908         [Obsolete("Please do not use! this will be deprecated")]
3909         public event EventHandler OffWindowEvent
3910         {
3911             add
3912             {
3913                 if (_offWindowEventHandler == null)
3914                 {
3915                     _offWindowEventCallback = OffWindow;
3916                     this.OffWindowSignal().Connect(_offWindowEventCallback);
3917                 }
3918
3919                 _offWindowEventHandler += value;
3920             }
3921
3922             remove
3923             {
3924                 _offWindowEventHandler -= value;
3925
3926                 if (_offWindowEventHandler == null && OffWindowSignal().Empty() == false)
3927                 {
3928                     this.OffWindowSignal().Disconnect(_offWindowEventCallback);
3929                 }
3930             }
3931         }
3932
3933         [Obsolete("Please do not use! this will be deprecated")]
3934         public event EventHandler OnRelayoutEvent
3935         {
3936             add
3937             {
3938                 if (_onRelayoutEventHandler == null)
3939                 {
3940                     _onRelayoutEventCallback = OnRelayout;
3941                     this.OnRelayoutSignal().Connect(_onRelayoutEventCallback);
3942                 }
3943
3944                 _onRelayoutEventHandler += value;
3945             }
3946
3947             remove
3948             {
3949                 _onRelayoutEventHandler -= value;
3950
3951                 if (_onRelayoutEventHandler == null && OnRelayoutSignal().Empty() == false)
3952                 {
3953                     this.OnRelayoutSignal().Disconnect(_onRelayoutEventCallback);
3954                 }
3955
3956             }
3957         }
3958
3959
3960
3961
3962     }
3963 }