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

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