src/Tizen.NUI/src/public/BaseComponents/View.cs

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