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

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