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