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

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