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.Parent;
  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         protected 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             if (GetParent() is View)
1200             {
1201                 View parentView = GetParent() as View;
1202                 view = parentView.FindChildById(id);
1203             }
1204
1205             if (!view)
1206             {
1207                 view = Window.Instance.GetRootLayer().FindChildById(id);
1208             }
1209
1210             return view;
1211         }
1212
1213         internal void SetKeyInputFocus()
1214         {
1215             NDalicPINVOKE.View_SetKeyInputFocus(swigCPtr);
1216             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1217         }
1218
1219         /// <summary>
1220         /// Queries whether the view has a focus.
1221         /// </summary>
1222         /// <returns>True if this view has a focus.</returns>
1223         /// <since_tizen> 3 </since_tizen>
1224         public bool HasFocus()
1225         {
1226             bool ret = NDalicPINVOKE.View_HasKeyInputFocus(swigCPtr);
1227             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1228             return ret;
1229         }
1230
1231         internal void ClearKeyInputFocus()
1232         {
1233             NDalicPINVOKE.View_ClearKeyInputFocus(swigCPtr);
1234             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1235         }
1236
1237         internal PinchGestureDetector GetPinchGestureDetector()
1238         {
1239             PinchGestureDetector ret = new PinchGestureDetector(NDalicPINVOKE.View_GetPinchGestureDetector(swigCPtr), true);
1240             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1241             return ret;
1242         }
1243
1244         internal PanGestureDetector GetPanGestureDetector()
1245         {
1246             PanGestureDetector ret = new PanGestureDetector(NDalicPINVOKE.View_GetPanGestureDetector(swigCPtr), true);
1247             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1248             return ret;
1249         }
1250
1251         internal TapGestureDetector GetTapGestureDetector()
1252         {
1253             TapGestureDetector ret = new TapGestureDetector(NDalicPINVOKE.View_GetTapGestureDetector(swigCPtr), true);
1254             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1255             return ret;
1256         }
1257
1258         internal LongPressGestureDetector GetLongPressGestureDetector()
1259         {
1260             LongPressGestureDetector ret = new LongPressGestureDetector(NDalicPINVOKE.View_GetLongPressGestureDetector(swigCPtr), true);
1261             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1262             return ret;
1263         }
1264
1265         /// <summary>
1266         /// Sets the name of the style to be applied to the view.
1267         /// </summary>
1268         /// <param name="styleName">A string matching a style described in a stylesheet.</param>
1269         /// <since_tizen> 3 </since_tizen>
1270         public void SetStyleName(string styleName)
1271         {
1272             NDalicPINVOKE.View_SetStyleName(swigCPtr, styleName);
1273             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1274         }
1275
1276         /// <summary>
1277         /// Retrieves the name of the style to be applied to the view (if any).
1278         /// </summary>
1279         /// <returns>A string matching a style, or an empty string.</returns>
1280         /// <since_tizen> 3 </since_tizen>
1281         public string GetStyleName()
1282         {
1283             string ret = NDalicPINVOKE.View_GetStyleName(swigCPtr);
1284             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1285             return ret;
1286         }
1287
1288         internal void SetBackgroundColor(Vector4 color)
1289         {
1290             NDalicPINVOKE.View_SetBackgroundColor(swigCPtr, Vector4.getCPtr(color));
1291             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1292         }
1293
1294         internal Vector4 GetBackgroundColor()
1295         {
1296             Vector4 ret = new Vector4(NDalicPINVOKE.View_GetBackgroundColor(swigCPtr), true);
1297             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1298             return ret;
1299         }
1300
1301         internal void SetBackgroundImage(Image image)
1302         {
1303             NDalicPINVOKE.View_SetBackgroundImage(swigCPtr, Image.getCPtr(image));
1304             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1305         }
1306
1307         /// <summary>
1308         /// Clears the background.
1309         /// </summary>
1310         /// <since_tizen> 3 </since_tizen>
1311         public void ClearBackground()
1312         {
1313             NDalicPINVOKE.View_ClearBackground(swigCPtr);
1314             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1315         }
1316
1317         internal ControlKeySignal KeyEventSignal()
1318         {
1319             ControlKeySignal ret = new ControlKeySignal(NDalicPINVOKE.View_KeyEventSignal(swigCPtr), false);
1320             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1321             return ret;
1322         }
1323
1324         internal KeyInputFocusSignal KeyInputFocusGainedSignal()
1325         {
1326             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusGainedSignal(swigCPtr), false);
1327             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1328             return ret;
1329         }
1330
1331         internal KeyInputFocusSignal KeyInputFocusLostSignal()
1332         {
1333             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusLostSignal(swigCPtr), false);
1334             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1335             return ret;
1336         }
1337
1338         internal View(ViewImpl implementation) : this(NDalicPINVOKE.new_View__SWIG_2(ViewImpl.getCPtr(implementation)), true)
1339         {
1340             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1341         }
1342
1343         internal enum PropertyRange
1344         {
1345             PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX,
1346             CONTROL_PROPERTY_START_INDEX = PROPERTY_START_INDEX,
1347             CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX + 1000
1348         }
1349
1350         /// <summary>
1351         /// The StyleName, type string.
1352         /// </summary>
1353         /// <since_tizen> 3 </since_tizen>
1354         public string StyleName
1355         {
1356             get
1357             {
1358                 string temp;
1359                 GetProperty(View.Property.STYLE_NAME).Get(out temp);
1360                 return temp;
1361             }
1362             set
1363             {
1364                 SetProperty(View.Property.STYLE_NAME, new Tizen.NUI.PropertyValue(value));
1365             }
1366         }
1367
1368         /// <summary>
1369         /// The mutually exclusive with BACKGROUND_IMAGE and BACKGROUND type Vector4.
1370         /// </summary>
1371         /// <since_tizen> 3 </since_tizen>
1372         public Color BackgroundColor
1373         {
1374             get
1375             {
1376                 Color backgroundColor = new Color(0.0f, 0.0f, 0.0f, 0.0f);
1377
1378                 Tizen.NUI.PropertyMap background = Background;
1379                 int visualType = 0;
1380                 background.Find(Visual.Property.Type)?.Get(out visualType);
1381                 if (visualType == (int)Visual.Type.Color)
1382                 {
1383                     background.Find(ColorVisualProperty.MixColor)?.Get(backgroundColor);
1384                 }
1385
1386                 return backgroundColor;
1387             }
1388             set
1389             {
1390                 SetProperty(View.Property.BACKGROUND, new Tizen.NUI.PropertyValue(value));
1391             }
1392         }
1393
1394         /// <summary>
1395         /// Creates an animation to animate the background color visual. If there is no
1396         /// background visual, creates one with transparent black as it's mixColor.
1397         /// </summary>
1398         /// <since_tizen> 3 </since_tizen>
1399         public Animation AnimateBackgroundColor(object destinationValue,
1400                                                  int startTime,
1401                                                  int endTime,
1402                                                  AlphaFunction.BuiltinFunctions? alphaFunction = null,
1403                                                  object initialValue = null)
1404         {
1405             Tizen.NUI.PropertyMap background = Background;
1406
1407             if (background.Empty())
1408             {
1409                 // If there is no background yet, ensure there is a transparent
1410                 // color visual
1411                 BackgroundColor = new Color(0.0f, 0.0f, 0.0f, 0.0f);
1412                 background = Background;
1413             }
1414             return AnimateColor("background", destinationValue, startTime, endTime, alphaFunction, initialValue);
1415         }
1416
1417         /// <summary>
1418         /// Creates an animation to animate the mixColor of the named visual.
1419         /// </summary>
1420         /// <since_tizen> 3 </since_tizen>
1421         public Animation AnimateColor(string targetVisual, object destinationColor, int startTime, int endTime, AlphaFunction.BuiltinFunctions? alphaFunction = null, object initialColor = null)
1422         {
1423             Animation animation = null;
1424             {
1425                 PropertyMap _animator = new PropertyMap();
1426                 if (alphaFunction != null)
1427                 {
1428                     _animator.Add("alphaFunction", new PropertyValue(AlphaFunction.BuiltinToPropertyKey(alphaFunction)));
1429                 }
1430
1431                 PropertyMap _timePeriod = new PropertyMap();
1432                 _timePeriod.Add("duration", new PropertyValue((endTime - startTime) / 1000.0f));
1433                 _timePeriod.Add("delay", new PropertyValue(startTime / 1000.0f));
1434                 _animator.Add("timePeriod", new PropertyValue(_timePeriod));
1435
1436                 PropertyMap _transition = new PropertyMap();
1437                 _transition.Add("animator", new PropertyValue(_animator));
1438                 _transition.Add("target", new PropertyValue(targetVisual));
1439                 _transition.Add("property", new PropertyValue("mixColor"));
1440
1441                 if (initialColor != null)
1442                 {
1443                     PropertyValue initValue = PropertyValue.CreateFromObject(initialColor);
1444                     _transition.Add("initialValue", initValue);
1445                 }
1446
1447                 PropertyValue destValue = PropertyValue.CreateFromObject(destinationColor);
1448                 _transition.Add("targetValue", destValue);
1449                 TransitionData _transitionData = new TransitionData(_transition);
1450
1451                 animation = new Animation(NDalicManualPINVOKE.View_CreateTransition(swigCPtr, TransitionData.getCPtr(_transitionData)), true);
1452                 if (NDalicPINVOKE.SWIGPendingException.Pending)
1453                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1454             }
1455             return animation;
1456         }
1457
1458         /// <summary>
1459         /// The mutually exclusive with BACKGROUND_COLOR and BACKGROUND type Map.
1460         /// </summary>
1461         /// <since_tizen> 3 </since_tizen>
1462         public string BackgroundImage
1463         {
1464             get
1465             {
1466                 string backgroundImage = "";
1467
1468                 Tizen.NUI.PropertyMap background = Background;
1469                 int visualType = 0;
1470                 background.Find(Visual.Property.Type)?.Get(out visualType);
1471                 if (visualType == (int)Visual.Type.Image)
1472                 {
1473                     background.Find(ImageVisualProperty.URL)?.Get(out backgroundImage);
1474                 }
1475
1476                 return backgroundImage;
1477             }
1478             set
1479             {
1480                 SetProperty(View.Property.BACKGROUND, new Tizen.NUI.PropertyValue(value));
1481             }
1482         }
1483
1484         /// <summary>
1485         /// The background of view.
1486         /// </summary>
1487         /// <since_tizen> 3 </since_tizen>
1488         public Tizen.NUI.PropertyMap Background
1489         {
1490             get
1491             {
1492                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
1493                 GetProperty(View.Property.BACKGROUND).Get(temp);
1494                 return temp;
1495             }
1496             set
1497             {
1498                 SetProperty(View.Property.BACKGROUND, new Tizen.NUI.PropertyValue(value));
1499             }
1500         }
1501
1502
1503         /// <summary>
1504         /// The current state of the view.
1505         /// </summary>
1506         /// <since_tizen> 3 </since_tizen>
1507         public States State
1508         {
1509             get
1510             {
1511                 int temp = 0;
1512                 if (GetProperty(View.Property.STATE).Get(out temp) == false)
1513                 {
1514                     NUILog.Error("State get error!");
1515                 }
1516                 switch (temp)
1517                 {
1518                     case 0:
1519                         {
1520                             return States.Normal;
1521                         }
1522                     case 1:
1523                         {
1524                             return States.Focused;
1525                         }
1526                     case 2:
1527                         {
1528                             return States.Disabled;
1529                         }
1530                     default:
1531                         {
1532                             return States.Normal;
1533                         }
1534                 }
1535             }
1536             set
1537             {
1538                 SetProperty(View.Property.STATE, new Tizen.NUI.PropertyValue((int)value));
1539             }
1540         }
1541
1542         /// <summary>
1543         /// The current sub state of the view.
1544         /// </summary>
1545         /// <since_tizen> 3 </since_tizen>
1546         public States SubState
1547         {
1548             get
1549             {
1550                 string temp;
1551                 if (GetProperty(View.Property.SUB_STATE).Get(out temp) == false)
1552                 {
1553                     NUILog.Error("subState get error!");
1554                 }
1555                 switch (temp)
1556                 {
1557                     case "NORMAL":
1558                         return States.Normal;
1559                     case "FOCUSED":
1560                         return States.Focused;
1561                     case "DISABLED":
1562                         return States.Disabled;
1563                     default:
1564                         return States.Normal;
1565                 }
1566             }
1567             set
1568             {
1569                 string valueToString = "";
1570                 switch (value)
1571                 {
1572                     case States.Normal:
1573                         {
1574                             valueToString = "NORMAL";
1575                             break;
1576                         }
1577                     case States.Focused:
1578                         {
1579                             valueToString = "FOCUSED";
1580                             break;
1581                         }
1582                     case States.Disabled:
1583                         {
1584                             valueToString = "DISABLED";
1585                             break;
1586                         }
1587                     default:
1588                         {
1589                             valueToString = "NORMAL";
1590                             break;
1591                         }
1592                 }
1593                 SetProperty(View.Property.SUB_STATE, new Tizen.NUI.PropertyValue(valueToString));
1594             }
1595         }
1596
1597         /// <summary>
1598         /// Displays a tooltip
1599         /// </summary>
1600         /// <since_tizen> 3 </since_tizen>
1601         public Tizen.NUI.PropertyMap Tooltip
1602         {
1603             get
1604             {
1605                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
1606                 GetProperty(View.Property.TOOLTIP).Get(temp);
1607                 return temp;
1608             }
1609             set
1610             {
1611                 SetProperty(View.Property.TOOLTIP, new Tizen.NUI.PropertyValue(value));
1612             }
1613         }
1614
1615         /// <summary>
1616         /// Displays a tooltip as a text.
1617         /// </summary>
1618         /// <since_tizen> 3 </since_tizen>
1619         public string TooltipText
1620         {
1621             set
1622             {
1623                 SetProperty(View.Property.TOOLTIP, new Tizen.NUI.PropertyValue(value));
1624             }
1625         }
1626
1627         private int LeftFocusableViewId
1628         {
1629             get
1630             {
1631                 int temp = 0;
1632                 GetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID).Get(out temp);
1633                 return temp;
1634             }
1635             set
1636             {
1637                 SetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
1638             }
1639         }
1640
1641         private int RightFocusableViewId
1642         {
1643             get
1644             {
1645                 int temp = 0;
1646                 GetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID).Get(out temp);
1647                 return temp;
1648             }
1649             set
1650             {
1651                 SetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
1652             }
1653         }
1654
1655         private int UpFocusableViewId
1656         {
1657             get
1658             {
1659                 int temp = 0;
1660                 GetProperty(View.Property.UP_FOCUSABLE_VIEW_ID).Get(out temp);
1661                 return temp;
1662             }
1663             set
1664             {
1665                 SetProperty(View.Property.UP_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
1666             }
1667         }
1668
1669         private int DownFocusableViewId
1670         {
1671             get
1672             {
1673                 int temp = 0;
1674                 GetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID).Get(out temp);
1675                 return temp;
1676             }
1677             set
1678             {
1679                 SetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
1680             }
1681         }
1682
1683         /// <summary>
1684         /// The Child property of FlexContainer.<br />
1685         /// The proportion of the free space in the container, the flex item will receive.<br />
1686         /// If all items in the container set this property, their sizes will be proportional to the specified flex factor.<br />
1687         /// </summary>
1688         /// <since_tizen> 3 </since_tizen>
1689         public float Flex
1690         {
1691             get
1692             {
1693                 float temp = 0.0f;
1694                 GetProperty(FlexContainer.ChildProperty.FLEX).Get(out temp);
1695                 return temp;
1696             }
1697             set
1698             {
1699                 SetProperty(FlexContainer.ChildProperty.FLEX, new Tizen.NUI.PropertyValue(value));
1700             }
1701         }
1702
1703         /// <summary>
1704         /// The Child property of FlexContainer.<br />
1705         /// The alignment of the flex item along the cross axis, which, if set, overides the default alignment for all items in the container.<br />
1706         /// </summary>
1707         /// <since_tizen> 3 </since_tizen>
1708         public int AlignSelf
1709         {
1710             get
1711             {
1712                 int temp = 0;
1713                 GetProperty(FlexContainer.ChildProperty.ALIGN_SELF).Get(out temp);
1714                 return temp;
1715             }
1716             set
1717             {
1718                 SetProperty(FlexContainer.ChildProperty.ALIGN_SELF, new Tizen.NUI.PropertyValue(value));
1719             }
1720         }
1721
1722         /// <summary>
1723         /// The Child property of FlexContainer.<br />
1724         /// The space around the flex item.<br />
1725         /// </summary>
1726         /// <since_tizen> 3 </since_tizen>
1727         public Vector4 FlexMargin
1728         {
1729             get
1730             {
1731                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
1732                 GetProperty(FlexContainer.ChildProperty.FLEX_MARGIN).Get(temp);
1733                 return temp;
1734             }
1735             set
1736             {
1737                 SetProperty(FlexContainer.ChildProperty.FLEX_MARGIN, new Tizen.NUI.PropertyValue(value));
1738             }
1739         }
1740
1741         /// <summary>
1742         /// The top-left cell this child occupies, if not set, the first available cell is used.
1743         /// </summary>
1744         /// <since_tizen> 3 </since_tizen>
1745         public Vector2 CellIndex
1746         {
1747             get
1748             {
1749                 Vector2 temp = new Vector2(0.0f, 0.0f);
1750                 GetProperty(TableView.ChildProperty.CELL_INDEX).Get(temp);
1751                 return temp;
1752             }
1753             set
1754             {
1755                 SetProperty(TableView.ChildProperty.CELL_INDEX, new Tizen.NUI.PropertyValue(value));
1756             }
1757         }
1758
1759         /// <summary>
1760         /// The number of rows this child occupies, if not set, the default value is 1.
1761         /// </summary>
1762         /// <since_tizen> 3 </since_tizen>
1763         public float RowSpan
1764         {
1765             get
1766             {
1767                 float temp = 0.0f;
1768                 GetProperty(TableView.ChildProperty.ROW_SPAN).Get(out temp);
1769                 return temp;
1770             }
1771             set
1772             {
1773                 SetProperty(TableView.ChildProperty.ROW_SPAN, new Tizen.NUI.PropertyValue(value));
1774             }
1775         }
1776
1777         /// <summary>
1778         /// The number of columns this child occupies, if not set, the default value is 1.
1779         /// </summary>
1780         /// <since_tizen> 3 </since_tizen>
1781         public float ColumnSpan
1782         {
1783             get
1784             {
1785                 float temp = 0.0f;
1786                 GetProperty(TableView.ChildProperty.COLUMN_SPAN).Get(out temp);
1787                 return temp;
1788             }
1789             set
1790             {
1791                 SetProperty(TableView.ChildProperty.COLUMN_SPAN, new Tizen.NUI.PropertyValue(value));
1792             }
1793         }
1794
1795         /// <summary>
1796         /// The horizontal alignment of this child inside the cells, if not set, the default value is 'left'.
1797         /// </summary>
1798         /// <since_tizen> 3 </since_tizen>
1799         public Tizen.NUI.HorizontalAlignmentType CellHorizontalAlignment
1800         {
1801             get
1802             {
1803                 string temp;
1804                 if (GetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT).Get(out temp) == false)
1805                 {
1806                     NUILog.Error("CellHorizontalAlignment get error!");
1807                 }
1808
1809                 switch (temp)
1810                 {
1811                     case "left":
1812                         return Tizen.NUI.HorizontalAlignmentType.Left;
1813                     case "center":
1814                         return Tizen.NUI.HorizontalAlignmentType.Center;
1815                     case "right":
1816                         return Tizen.NUI.HorizontalAlignmentType.Right;
1817                     default:
1818                         return Tizen.NUI.HorizontalAlignmentType.Left;
1819                 }
1820             }
1821             set
1822             {
1823                 string valueToString = "";
1824                 switch (value)
1825                 {
1826                     case Tizen.NUI.HorizontalAlignmentType.Left:
1827                         {
1828                             valueToString = "left";
1829                             break;
1830                         }
1831                     case Tizen.NUI.HorizontalAlignmentType.Center:
1832                         {
1833                             valueToString = "center";
1834                             break;
1835                         }
1836                     case Tizen.NUI.HorizontalAlignmentType.Right:
1837                         {
1838                             valueToString = "right";
1839                             break;
1840                         }
1841                     default:
1842                         {
1843                             valueToString = "left";
1844                             break;
1845                         }
1846                 }
1847                 SetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT, new Tizen.NUI.PropertyValue(valueToString));
1848             }
1849         }
1850
1851         /// <summary>
1852         /// The vertical alignment of this child inside the cells, if not set, the default value is 'top'.
1853         /// </summary>
1854         /// <since_tizen> 3 </since_tizen>
1855         public Tizen.NUI.VerticalAlignmentType CellVerticalAlignment
1856         {
1857             get
1858             {
1859                 string temp;
1860                 GetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT).Get(out temp);
1861                 {
1862                     NUILog.Error("CellVerticalAlignment get error!");
1863                 }
1864
1865                 switch (temp)
1866                 {
1867                     case "top":
1868                         return Tizen.NUI.VerticalAlignmentType.Top;
1869                     case "center":
1870                         return Tizen.NUI.VerticalAlignmentType.Center;
1871                     case "bottom":
1872                         return Tizen.NUI.VerticalAlignmentType.Bottom;
1873                     default:
1874                         return Tizen.NUI.VerticalAlignmentType.Top;
1875                 }
1876             }
1877             set
1878             {
1879                 string valueToString = "";
1880                 switch (value)
1881                 {
1882                     case Tizen.NUI.VerticalAlignmentType.Top:
1883                         {
1884                             valueToString = "top";
1885                             break;
1886                         }
1887                     case Tizen.NUI.VerticalAlignmentType.Center:
1888                         {
1889                             valueToString = "center";
1890                             break;
1891                         }
1892                     case Tizen.NUI.VerticalAlignmentType.Bottom:
1893                         {
1894                             valueToString = "bottom";
1895                             break;
1896                         }
1897                     default:
1898                         {
1899                             valueToString = "top";
1900                             break;
1901                         }
1902                 }
1903                 SetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT, new Tizen.NUI.PropertyValue(valueToString));
1904             }
1905         }
1906
1907         /// <summary>
1908         /// The left focusable view.<br />
1909         /// This will return null if not set.<br />
1910         /// This will also return null if the specified left focusable view is not on a window.<br />
1911         /// </summary>
1912         /// <since_tizen> 3 </since_tizen>
1913         public View LeftFocusableView
1914         {
1915             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1916             get
1917             {
1918                 if (LeftFocusableViewId >= 0)
1919                 {
1920                     return ConvertIdToView((uint)LeftFocusableViewId);
1921                 }
1922                 return null;
1923             }
1924             set
1925             {
1926                 if (value)
1927                 {
1928                     LeftFocusableViewId = (int)value.GetId();
1929                 }
1930                 else
1931                 {
1932                     LeftFocusableViewId = -1;
1933                 }
1934             }
1935         }
1936
1937         /// <summary>
1938         /// The right focusable view.<br />
1939         /// This will return null if not set.<br />
1940         /// This will also return null if the specified right focusable view is not on a window.<br />
1941         /// </summary>
1942         /// <since_tizen> 3 </since_tizen>
1943         public View RightFocusableView
1944         {
1945             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1946             get
1947             {
1948                 if (RightFocusableViewId >= 0)
1949                 {
1950                     return ConvertIdToView((uint)RightFocusableViewId);
1951                 }
1952                 return null;
1953             }
1954             set
1955             {
1956                 if (value)
1957                 {
1958                     RightFocusableViewId = (int)value.GetId();
1959                 }
1960                 else
1961                 {
1962                     RightFocusableViewId = -1;
1963                 }
1964             }
1965         }
1966
1967         /// <summary>
1968         /// The up focusable view.<br />
1969         /// This will return null if not set.<br />
1970         /// This will also return null if the specified up focusable view is not on a window.<br />
1971         /// </summary>
1972         /// <since_tizen> 3 </since_tizen>
1973         public View UpFocusableView
1974         {
1975             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1976             get
1977             {
1978                 if (UpFocusableViewId >= 0)
1979                 {
1980                     return ConvertIdToView((uint)UpFocusableViewId);
1981                 }
1982                 return null;
1983             }
1984             set
1985             {
1986                 if (value)
1987                 {
1988                     UpFocusableViewId = (int)value.GetId();
1989                 }
1990                 else
1991                 {
1992                     UpFocusableViewId = -1;
1993                 }
1994             }
1995         }
1996
1997         /// <summary>
1998         /// The down focusable view.<br />
1999         /// This will return null if not set.<br />
2000         /// This will also return null if the specified down focusable view is not on a window.<br />
2001         /// </summary>
2002         /// <since_tizen> 3 </since_tizen>
2003         public View DownFocusableView
2004         {
2005             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
2006             get
2007             {
2008                 if (DownFocusableViewId >= 0)
2009                 {
2010                     return ConvertIdToView((uint)DownFocusableViewId);
2011                 }
2012                 return null;
2013             }
2014             set
2015             {
2016                 if (value)
2017                 {
2018                     DownFocusableViewId = (int)value.GetId();
2019                 }
2020                 else
2021                 {
2022                     DownFocusableViewId = -1;
2023                 }
2024             }
2025         }
2026
2027         /// <summary>
2028         /// Whether the view should be focusable by keyboard navigation.
2029         /// </summary>
2030         /// <since_tizen> 3 </since_tizen>
2031         public bool Focusable
2032         {
2033             set
2034             {
2035                 SetKeyboardFocusable(value);
2036             }
2037             get
2038             {
2039                 return IsKeyboardFocusable();
2040             }
2041         }
2042
2043         /// <summary>
2044         /// Enumeration for describing the states of the view.
2045         /// </summary>
2046         /// <since_tizen> 3 </since_tizen>
2047         public enum States
2048         {
2049             /// <summary>
2050             /// The normal state.
2051             /// </summary>
2052             Normal,
2053             /// <summary>
2054             /// The focused state.
2055             /// </summary>
2056             Focused,
2057             /// <summary>
2058             /// The disabled state.
2059             /// </summary>
2060             Disabled
2061         }
2062
2063         /// <summary>
2064         ///  Retrieves the position of the view.<br />
2065         ///  The coordinates are relative to the view's parent.<br />
2066         /// </summary>
2067         /// <since_tizen> 3 </since_tizen>
2068         public Position CurrentPosition
2069         {
2070             get
2071             {
2072                 return GetCurrentPosition();
2073             }
2074         }
2075
2076         /// <summary>
2077         /// Sets the size of a view for the width and the height.<br />
2078         /// Geometry can be scaled to fit within this area.<br />
2079         /// This does not interfere with the view's scale factor.<br />
2080         /// The views default depth is the minimum of width and height.<br />
2081         /// </summary>
2082         /// <since_tizen> 3 </since_tizen>
2083         public Size2D Size2D
2084         {
2085             get
2086             {
2087                 Size temp = new Size(0.0f, 0.0f, 0.0f);
2088                 GetProperty(View.Property.SIZE).Get(temp);
2089                 Size2D size = new Size2D((int)temp.Width, (int)temp.Height);
2090                 return size;
2091             }
2092             set
2093             {
2094                 SetProperty(View.Property.SIZE, new Tizen.NUI.PropertyValue(new Size(value)));
2095             }
2096         }
2097
2098         /// <summary>
2099         ///  Retrieves the size of the view.<br />
2100         ///  The coordinates are relative to the view's parent.<br />
2101         /// </summary>
2102         /// <since_tizen> 3 </since_tizen>
2103         public Size2D CurrentSize
2104         {
2105             get
2106             {
2107                 return GetCurrentSize();
2108             }
2109         }
2110
2111         /// <summary>
2112         /// Retrieves and sets the view's opacity.<br />
2113         /// </summary>
2114         /// <since_tizen> 3 </since_tizen>
2115         public float Opacity
2116         {
2117             get
2118             {
2119                 float temp = 0.0f;
2120                 GetProperty(View.Property.OPACITY).Get(out temp);
2121                 return temp;
2122             }
2123             set
2124             {
2125                 SetProperty(View.Property.OPACITY, new Tizen.NUI.PropertyValue(value));
2126             }
2127         }
2128
2129         /// <summary>
2130         /// Sets the position of the view for X and Y.<br />
2131         /// By default, sets the position vector between the parent origin and the pivot point (default).<br />
2132         /// If the position inheritance is disabled, sets the world position.<br />
2133         /// </summary>
2134         /// <since_tizen> 3 </since_tizen>
2135         public Position2D Position2D
2136         {
2137             get
2138             {
2139                 Position temp = new Position(0.0f, 0.0f, 0.0f);
2140                 GetProperty(View.Property.POSITION).Get(temp);
2141                 return new Position2D(temp);
2142             }
2143             set
2144             {
2145                 SetProperty(View.Property.POSITION, new Tizen.NUI.PropertyValue(new Position(value)));
2146             }
2147         }
2148
2149         /// <summary>
2150         /// Retrieves the screen postion of the view.<br />
2151         /// </summary>
2152         /// <since_tizen> 3 </since_tizen>
2153         public Vector2 ScreenPosition
2154         {
2155             get
2156             {
2157                 Vector2 temp = new Vector2(0.0f, 0.0f);
2158                 GetProperty(View.Property.SCREEN_POSITION).Get(temp);
2159                 return temp;
2160             }
2161         }
2162
2163         /// <summary>
2164         /// Determines whether the pivot point should be used to determine the position of the view.
2165         /// This is true by default.
2166         /// </summary>
2167         /// <remarks>If false, then the top-left of the view is used for the position.
2168         /// Setting this to false will allow scaling or rotation around the anchor-point without affecting the view's position.
2169         /// </remarks>
2170         /// <since_tizen> 3 </since_tizen>
2171         public bool PositionUsesPivotPoint
2172         {
2173             get
2174             {
2175                 bool temp = false;
2176                 GetProperty(View.Property.POSITION_USES_ANCHOR_POINT).Get(out temp);
2177                 return temp;
2178             }
2179             set
2180             {
2181                 SetProperty(View.Property.POSITION_USES_ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
2182             }
2183         }
2184
2185         internal bool FocusState
2186         {
2187             get
2188             {
2189                 return IsKeyboardFocusable();
2190             }
2191             set
2192             {
2193                 SetKeyboardFocusable(value);
2194             }
2195         }
2196
2197         /// <summary>
2198         /// Queries whether the view is connected to the stage.<br />
2199         /// When a view is connected, it will be directly or indirectly parented to the root view.<br />
2200         /// </summary>
2201         /// <since_tizen> 3 </since_tizen>
2202         public bool IsOnWindow
2203         {
2204             get
2205             {
2206                 return OnWindow();
2207             }
2208         }
2209
2210         /// <summary>
2211         /// Gets the depth in the hierarchy for the view.
2212         /// </summary>
2213         /// <since_tizen> 3 </since_tizen>
2214         public int HierarchyDepth
2215         {
2216             get
2217             {
2218                 return GetHierarchyDepth();
2219             }
2220         }
2221
2222         /// <summary>
2223         /// Sets the sibling order of the view so the depth position can be defined within the same parent.
2224         /// </summary>
2225         /// <remarks>
2226         /// Note the initial value is 0. SiblingOrder should be bigger than 0 or equal to 0.
2227         /// Raise, Lower, RaiseToTop, LowerToBottom, RaiseAbove, and LowerBelow will override the sibling order.
2228         /// The values set by this property will likely change.
2229         /// </remarks>
2230         /// <since_tizen> 3 </since_tizen>
2231         public int SiblingOrder
2232         {
2233             get
2234             {
2235                 var parentChildren = GetParent()?.Children;
2236                 int currentOrder = 0;
2237                 if (parentChildren != null)
2238                 {
2239                     currentOrder = parentChildren.IndexOf(this);
2240
2241                     if (currentOrder < 0)
2242                     {
2243                         return 0;
2244                     }
2245                     else if (currentOrder < parentChildren.Count)
2246                     {
2247                         return currentOrder;
2248                     }
2249                 }
2250
2251                 return 0;
2252             }
2253             set
2254             {
2255                 if(value < 0)
2256                 {
2257                     NUILog.Error("SiblingOrder should be bigger than 0 or equal to 0.");
2258                     return;
2259                 }
2260                 var siblings = GetParent()?.Children;
2261                 if (siblings != null)
2262                 {
2263                     int currentOrder = siblings.IndexOf(this);
2264                     if (value != currentOrder)
2265                     {
2266                         if (value == 0)
2267                         {
2268                             LowerToBottom();
2269                         }
2270                         else if (value < siblings.Count - 1)
2271                         {
2272                             if (value > currentOrder)
2273                             {
2274                                 RaiseAbove(siblings[value]);
2275                             }
2276                             else
2277                             {
2278                                 LowerBelow(siblings[value]);
2279                             }
2280                         }
2281                         else
2282                         {
2283                             RaiseToTop();
2284                         }
2285                     }
2286                 }
2287             }
2288         }
2289
2290         /// <summary>
2291         /// Returns the natural size (Size2D) of the view.
2292         /// </summary>
2293         /// <remarks>
2294         /// Deriving classes stipulate the natural size and by default a view has a zero natural size.
2295         /// </remarks>
2296         /// <since_tizen> 4 </since_tizen>
2297         public Size2D NaturalSize2D
2298         {
2299             get
2300             {
2301                 Vector3 temp = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
2302                 if (NDalicPINVOKE.SWIGPendingException.Pending)
2303                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2304
2305                 return new Size2D((int)temp.Width, (int)temp.Height);
2306             }
2307         }
2308
2309         /// <summary>
2310         /// Shows the view.
2311         /// </summary>
2312         /// <remarks>
2313         /// This is an asynchronous method.
2314         /// </remarks>
2315         /// <since_tizen> 3 </since_tizen>
2316         public void Show()
2317         {
2318             SetVisible(true);
2319         }
2320
2321         /// <summary>
2322         /// Hides the view.
2323         /// </summary>
2324         /// <remarks>
2325         /// This is an asynchronous method.
2326         /// If the view is hidden, then the view and its children will not be rendered.
2327         /// 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.
2328         /// </remarks>
2329         /// <since_tizen> 3 </since_tizen>
2330         public void Hide()
2331         {
2332             SetVisible(false);
2333         }
2334
2335         internal void Raise()
2336         {
2337             var parentChildren = GetParent()?.Children;
2338
2339             if (parentChildren != null)
2340             {
2341                 int currentIndex = parentChildren.IndexOf(this);
2342
2343                 // If the view is not already the last item in the list.
2344                 if (currentIndex >= 0 && currentIndex < parentChildren.Count -1)
2345                 {
2346                     View temp = parentChildren[currentIndex + 1];
2347                     parentChildren[currentIndex + 1] = this;
2348                     parentChildren[currentIndex] = temp;
2349
2350                     NDalicPINVOKE.Raise(swigCPtr);
2351                     if (NDalicPINVOKE.SWIGPendingException.Pending)
2352                         throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2353                 }
2354             }
2355
2356         }
2357
2358         internal void Lower()
2359         {
2360             var parentChildren = GetParent()?.Children;
2361
2362             if (parentChildren != null)
2363             {
2364                 int currentIndex = parentChildren.IndexOf(this);
2365
2366                 // If the view is not already the first item in the list.
2367                 if (currentIndex > 0 && currentIndex < parentChildren.Count)
2368                 {
2369                     View temp = parentChildren[currentIndex - 1];
2370                     parentChildren[currentIndex - 1] = this;
2371                     parentChildren[currentIndex] = temp;
2372
2373                     NDalicPINVOKE.Lower(swigCPtr);
2374                     if (NDalicPINVOKE.SWIGPendingException.Pending)
2375                         throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2376                 }
2377             }
2378         }
2379
2380         /// <summary>
2381         /// Raises the view above all other views.
2382         /// </summary>
2383         /// <remarks>
2384         /// Sibling order of views within the parent will be updated automatically.
2385         /// Once a raise or lower API is used, that view will then have an exclusive sibling order independent of insertion.
2386         /// </remarks>
2387         /// <since_tizen> 3 </since_tizen>
2388         public void RaiseToTop()
2389         {
2390             var parentChildren = GetParent()?.Children;
2391
2392             if (parentChildren != null)
2393             {
2394                 parentChildren.Remove(this);
2395                 parentChildren.Add(this);
2396
2397                 NDalicPINVOKE.RaiseToTop(swigCPtr);
2398                 if (NDalicPINVOKE.SWIGPendingException.Pending)
2399                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2400             }
2401
2402         }
2403
2404         /// <summary>
2405         /// Lowers the view to the bottom of all views.
2406         /// </summary>
2407         /// <remarks>
2408         /// The sibling order of views within the parent will be updated automatically.
2409         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
2410         /// </remarks>
2411         /// <since_tizen> 3 </since_tizen>
2412         public void LowerToBottom()
2413         {
2414             var parentChildren = GetParent()?.Children;
2415
2416             if (parentChildren != null)
2417             {
2418                 parentChildren.Remove(this);
2419                 parentChildren.Insert(0, this);
2420
2421                 NDalicPINVOKE.LowerToBottom(swigCPtr);
2422                 if (NDalicPINVOKE.SWIGPendingException.Pending)
2423                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2424             }
2425         }
2426
2427         /// <summary>
2428         /// Queries if all resources required by a view are loaded and ready.
2429         /// </summary>
2430         /// <remarks>Most resources are only loaded when the control is placed on the stage.
2431         /// </remarks>
2432         /// <since_tizen> 3 </since_tizen>
2433         public bool IsResourceReady()
2434         {
2435             bool ret = NDalicPINVOKE.IsResourceReady(swigCPtr);
2436             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2437             return ret;
2438         }
2439
2440         /// <summary>
2441         /// Raises the view to above the target view.
2442         /// </summary>
2443         /// <remarks>The sibling order of views within the parent will be updated automatically.
2444         /// Views on the level above the target view will still be shown above this view.
2445         /// Raising this view above views with the same sibling order as each other will raise this view above them.
2446         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
2447         /// </remarks>
2448         /// <param name="target">Will be raised above this view.</param>
2449         internal void RaiseAbove(View target)
2450         {
2451             var parentChildren = GetParent()?.Children;
2452
2453             if (parentChildren != null)
2454             {
2455                 int currentIndex = parentChildren.IndexOf(this);
2456                 int targetIndex = parentChildren.IndexOf(target);
2457
2458                 if(currentIndex < 0 || targetIndex < 0 ||
2459                     currentIndex >= parentChildren.Count || targetIndex >= parentChildren.Count)
2460                 {
2461                     NUILog.Error("index should be bigger than 0 and less than children of layer count");
2462                     return;
2463                 }
2464                 // If the currentIndex is less than the target index and the target has the same parent.
2465                 if (currentIndex < targetIndex)
2466                 {
2467                     parentChildren.Remove(this);
2468                     parentChildren.Insert(targetIndex, this);
2469
2470                     NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
2471                     if (NDalicPINVOKE.SWIGPendingException.Pending)
2472                         throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2473                 }
2474             }
2475
2476         }
2477
2478         /// <summary>
2479         /// Lowers the view to below the target view.
2480         /// </summary>
2481         /// <remarks>The sibling order of views within the parent will be updated automatically.
2482         /// Lowering this view below views with the same sibling order as each other will lower this view above them.
2483         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
2484         /// </remarks>
2485         /// <param name="target">Will be lowered below this view.</param>
2486         internal void LowerBelow(View target)
2487         {
2488             var parentChildren = GetParent()?.Children;
2489
2490             if (parentChildren != null)
2491             {
2492                 int currentIndex = parentChildren.IndexOf(this);
2493                 int targetIndex = parentChildren.IndexOf(target);
2494                 if(currentIndex < 0 || targetIndex < 0 ||
2495                    currentIndex >= parentChildren.Count ||targetIndex >= parentChildren.Count)
2496                 {
2497                     NUILog.Error("index should be bigger than 0 and less than children of layer count");
2498                     return;
2499                 }
2500
2501                 // If the currentIndex is not already the 0th index and the target has the same parent.
2502                 if ((currentIndex != 0) && (targetIndex != -1) &&
2503                     (currentIndex > targetIndex))
2504                 {
2505                     parentChildren.Remove(this);
2506                     parentChildren.Insert(targetIndex, this);
2507
2508                     NDalicPINVOKE.LowerBelow(swigCPtr, View.getCPtr(target));
2509                     if (NDalicPINVOKE.SWIGPendingException.Pending)
2510                         throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2511                 }
2512             }
2513
2514         }
2515
2516         internal string GetName()
2517         {
2518             string ret = NDalicPINVOKE.Actor_GetName(swigCPtr);
2519             if (NDalicPINVOKE.SWIGPendingException.Pending)
2520                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2521             return ret;
2522         }
2523
2524         internal void SetName(string name)
2525         {
2526             NDalicPINVOKE.Actor_SetName(swigCPtr, name);
2527             if (NDalicPINVOKE.SWIGPendingException.Pending)
2528                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2529         }
2530
2531         internal uint GetId()
2532         {
2533             uint ret = NDalicPINVOKE.Actor_GetId(swigCPtr);
2534             if (NDalicPINVOKE.SWIGPendingException.Pending)
2535                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2536             return ret;
2537         }
2538
2539         internal bool IsRoot()
2540         {
2541             bool ret = NDalicPINVOKE.Actor_IsRoot(swigCPtr);
2542             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2543             return ret;
2544         }
2545
2546         internal bool OnWindow()
2547         {
2548             bool ret = NDalicPINVOKE.Actor_OnStage(swigCPtr);
2549             if (NDalicPINVOKE.SWIGPendingException.Pending)
2550                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2551             return ret;
2552         }
2553
2554         /// <summary>
2555         /// Gets the parent layer of this view.If a view has no parent, this method does nothing.
2556         /// </summary>
2557         /// <pre>The view has been initialized. </pre>
2558         /// <returns>the parent layer of view </returns>
2559         /// <since_tizen> 5 </since_tizen>
2560         public Layer GetLayer()
2561         {
2562             //to fix memory leak issue, match the handle count with native side.
2563             IntPtr cPtr = NDalicPINVOKE.Actor_GetLayer(swigCPtr);
2564             HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
2565             Layer ret = Registry.GetManagedBaseHandleFromNativePtr(CPtr.Handle) as Layer;
2566             NDalicPINVOKE.delete_BaseHandle(CPtr);
2567             CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
2568
2569             if (NDalicPINVOKE.SWIGPendingException.Pending)
2570                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2571             return ret;
2572         }
2573
2574         /// <summary>
2575         /// Removes a view from its parent view or layer. If a view has no parent, this method does nothing.
2576         /// </summary>
2577         /// <pre>The (child) view has been initialized. </pre>
2578         /// <since_tizen> 4 </since_tizen>
2579         public void Unparent()
2580         {
2581             GetParent()?.Remove(this);
2582         }
2583
2584         /// <summary>
2585         /// Search through this view's hierarchy for a view with the given name.
2586         /// The view itself is also considered in the search.
2587         /// </summary>
2588         /// <pre>The view has been initialized.</pre>
2589         /// <param name="viewName">The name of the view to find.</param>
2590         /// <returns>A handle to the view if found, or an empty handle if not.</returns>
2591         /// <since_tizen> 3 </since_tizen>
2592         public View FindChildByName(string viewName)
2593         {
2594             //to fix memory leak issue, match the handle count with native side.
2595             IntPtr cPtr = NDalicPINVOKE.Actor_FindChildByName(swigCPtr, viewName);
2596             HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
2597             View ret = Registry.GetManagedBaseHandleFromNativePtr(CPtr.Handle) as View;
2598             NDalicPINVOKE.delete_BaseHandle(CPtr);
2599             CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
2600
2601             if (NDalicPINVOKE.SWIGPendingException.Pending)
2602                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2603             return ret;
2604         }
2605
2606         internal View FindChildById(uint id)
2607         {
2608             //to fix memory leak issue, match the handle count with native side.
2609             IntPtr cPtr = NDalicPINVOKE.Actor_FindChildById(swigCPtr, id);
2610             HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
2611             View ret = Registry.GetManagedBaseHandleFromNativePtr(CPtr.Handle) as View;
2612             NDalicPINVOKE.delete_BaseHandle(CPtr);
2613             CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
2614
2615             if (NDalicPINVOKE.SWIGPendingException.Pending)
2616                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2617             return ret;
2618         }
2619
2620         internal void SetParentOrigin(Vector3 origin)
2621         {
2622             NDalicPINVOKE.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));
2623             if (NDalicPINVOKE.SWIGPendingException.Pending)
2624                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2625         }
2626
2627         internal Vector3 GetCurrentParentOrigin()
2628         {
2629             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentParentOrigin(swigCPtr), true);
2630             if (NDalicPINVOKE.SWIGPendingException.Pending)
2631                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2632             return ret;
2633         }
2634
2635         internal void SetAnchorPoint(Vector3 anchorPoint)
2636         {
2637             NDalicPINVOKE.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
2638             if (NDalicPINVOKE.SWIGPendingException.Pending)
2639                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2640         }
2641
2642         internal Vector3 GetCurrentAnchorPoint()
2643         {
2644             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentAnchorPoint(swigCPtr), true);
2645             if (NDalicPINVOKE.SWIGPendingException.Pending)
2646                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2647             return ret;
2648         }
2649
2650         internal void SetSize(float width, float height)
2651         {
2652             NDalicPINVOKE.Actor_SetSize__SWIG_0(swigCPtr, width, height);
2653             if (NDalicPINVOKE.SWIGPendingException.Pending)
2654                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2655         }
2656
2657         internal void SetSize(float width, float height, float depth)
2658         {
2659             NDalicPINVOKE.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);
2660             if (NDalicPINVOKE.SWIGPendingException.Pending)
2661                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2662         }
2663
2664         internal void SetSize(Vector2 size)
2665         {
2666             NDalicPINVOKE.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));
2667             if (NDalicPINVOKE.SWIGPendingException.Pending)
2668                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2669         }
2670
2671         internal void SetSize(Vector3 size)
2672         {
2673             NDalicPINVOKE.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));
2674             if (NDalicPINVOKE.SWIGPendingException.Pending)
2675                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2676         }
2677
2678         internal Vector3 GetTargetSize()
2679         {
2680             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetTargetSize(swigCPtr), true);
2681             if (NDalicPINVOKE.SWIGPendingException.Pending)
2682                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2683             return ret;
2684         }
2685
2686         internal Size2D GetCurrentSize()
2687         {
2688             Size ret = new Size(NDalicPINVOKE.Actor_GetCurrentSize(swigCPtr), true);
2689             if (NDalicPINVOKE.SWIGPendingException.Pending)
2690                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2691             Size2D size = new Size2D((int)ret.Width, (int)ret.Height);
2692             return size;
2693         }
2694
2695         internal Vector3 GetNaturalSize()
2696         {
2697             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
2698             if (NDalicPINVOKE.SWIGPendingException.Pending)
2699                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2700             return ret;
2701         }
2702
2703         internal void SetPosition(float x, float y)
2704         {
2705             NDalicPINVOKE.Actor_SetPosition__SWIG_0(swigCPtr, x, y);
2706             if (NDalicPINVOKE.SWIGPendingException.Pending)
2707                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2708         }
2709
2710         internal void SetPosition(float x, float y, float z)
2711         {
2712             NDalicPINVOKE.Actor_SetPosition__SWIG_1(swigCPtr, x, y, z);
2713             if (NDalicPINVOKE.SWIGPendingException.Pending)
2714                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2715         }
2716
2717         internal void SetPosition(Vector3 position)
2718         {
2719             NDalicPINVOKE.Actor_SetPosition__SWIG_2(swigCPtr, Vector3.getCPtr(position));
2720             if (NDalicPINVOKE.SWIGPendingException.Pending)
2721                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2722         }
2723
2724         internal void SetX(float x)
2725         {
2726             NDalicPINVOKE.Actor_SetX(swigCPtr, x);
2727             if (NDalicPINVOKE.SWIGPendingException.Pending)
2728                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2729         }
2730
2731         internal void SetY(float y)
2732         {
2733             NDalicPINVOKE.Actor_SetY(swigCPtr, y);
2734             if (NDalicPINVOKE.SWIGPendingException.Pending)
2735                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2736         }
2737
2738         internal void SetZ(float z)
2739         {
2740             NDalicPINVOKE.Actor_SetZ(swigCPtr, z);
2741             if (NDalicPINVOKE.SWIGPendingException.Pending)
2742                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2743         }
2744
2745         internal void TranslateBy(Vector3 distance)
2746         {
2747             NDalicPINVOKE.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));
2748             if (NDalicPINVOKE.SWIGPendingException.Pending)
2749                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2750         }
2751
2752         internal Position GetCurrentPosition()
2753         {
2754             Position ret = new Position(NDalicPINVOKE.Actor_GetCurrentPosition(swigCPtr), true);
2755             if (NDalicPINVOKE.SWIGPendingException.Pending)
2756                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2757             return ret;
2758         }
2759
2760         internal Vector3 GetCurrentWorldPosition()
2761         {
2762             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldPosition(swigCPtr), true);
2763             if (NDalicPINVOKE.SWIGPendingException.Pending)
2764                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2765             return ret;
2766         }
2767
2768         internal void SetInheritPosition(bool inherit)
2769         {
2770             NDalicPINVOKE.Actor_SetInheritPosition(swigCPtr, inherit);
2771             if (NDalicPINVOKE.SWIGPendingException.Pending)
2772                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2773         }
2774
2775         internal bool IsPositionInherited()
2776         {
2777             bool ret = NDalicPINVOKE.Actor_IsPositionInherited(swigCPtr);
2778             if (NDalicPINVOKE.SWIGPendingException.Pending)
2779                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2780             return ret;
2781         }
2782
2783         internal void SetOrientation(Degree angle, Vector3 axis)
2784         {
2785             NDalicPINVOKE.Actor_SetOrientation__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
2786             if (NDalicPINVOKE.SWIGPendingException.Pending)
2787                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2788         }
2789
2790         internal void SetOrientation(Radian angle, Vector3 axis)
2791         {
2792             NDalicPINVOKE.Actor_SetOrientation__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
2793             if (NDalicPINVOKE.SWIGPendingException.Pending)
2794                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2795         }
2796
2797         internal void SetOrientation(Rotation orientation)
2798         {
2799             NDalicPINVOKE.Actor_SetOrientation__SWIG_2(swigCPtr, Rotation.getCPtr(orientation));
2800             if (NDalicPINVOKE.SWIGPendingException.Pending)
2801                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2802         }
2803
2804         internal void RotateBy(Degree angle, Vector3 axis)
2805         {
2806             NDalicPINVOKE.Actor_RotateBy__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
2807             if (NDalicPINVOKE.SWIGPendingException.Pending)
2808                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2809         }
2810
2811         internal void RotateBy(Radian angle, Vector3 axis)
2812         {
2813             NDalicPINVOKE.Actor_RotateBy__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
2814             if (NDalicPINVOKE.SWIGPendingException.Pending)
2815                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2816         }
2817
2818         internal void RotateBy(Rotation relativeRotation)
2819         {
2820             NDalicPINVOKE.Actor_RotateBy__SWIG_2(swigCPtr, Rotation.getCPtr(relativeRotation));
2821             if (NDalicPINVOKE.SWIGPendingException.Pending)
2822                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2823         }
2824
2825         internal Rotation GetCurrentOrientation()
2826         {
2827             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentOrientation(swigCPtr), true);
2828             if (NDalicPINVOKE.SWIGPendingException.Pending)
2829                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2830             return ret;
2831         }
2832
2833         internal void SetInheritOrientation(bool inherit)
2834         {
2835             NDalicPINVOKE.Actor_SetInheritOrientation(swigCPtr, inherit);
2836             if (NDalicPINVOKE.SWIGPendingException.Pending)
2837                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2838         }
2839
2840         internal bool IsOrientationInherited()
2841         {
2842             bool ret = NDalicPINVOKE.Actor_IsOrientationInherited(swigCPtr);
2843             if (NDalicPINVOKE.SWIGPendingException.Pending)
2844                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2845             return ret;
2846         }
2847
2848         internal Rotation GetCurrentWorldOrientation()
2849         {
2850             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentWorldOrientation(swigCPtr), true);
2851             if (NDalicPINVOKE.SWIGPendingException.Pending)
2852                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2853             return ret;
2854         }
2855
2856         internal void SetScale(float scale)
2857         {
2858             NDalicPINVOKE.Actor_SetScale__SWIG_0(swigCPtr, scale);
2859             if (NDalicPINVOKE.SWIGPendingException.Pending)
2860                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2861         }
2862
2863         internal void SetScale(float scaleX, float scaleY, float scaleZ)
2864         {
2865             NDalicPINVOKE.Actor_SetScale__SWIG_1(swigCPtr, scaleX, scaleY, scaleZ);
2866             if (NDalicPINVOKE.SWIGPendingException.Pending)
2867                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2868         }
2869
2870         internal void SetScale(Vector3 scale)
2871         {
2872             NDalicPINVOKE.Actor_SetScale__SWIG_2(swigCPtr, Vector3.getCPtr(scale));
2873             if (NDalicPINVOKE.SWIGPendingException.Pending)
2874                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2875         }
2876
2877         internal void ScaleBy(Vector3 relativeScale)
2878         {
2879             NDalicPINVOKE.Actor_ScaleBy(swigCPtr, Vector3.getCPtr(relativeScale));
2880             if (NDalicPINVOKE.SWIGPendingException.Pending)
2881                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2882         }
2883
2884         internal Vector3 GetCurrentScale()
2885         {
2886             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentScale(swigCPtr), true);
2887             if (NDalicPINVOKE.SWIGPendingException.Pending)
2888                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2889             return ret;
2890         }
2891
2892         internal Vector3 GetCurrentWorldScale()
2893         {
2894             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldScale(swigCPtr), true);
2895             if (NDalicPINVOKE.SWIGPendingException.Pending)
2896                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2897             return ret;
2898         }
2899
2900         internal void SetInheritScale(bool inherit)
2901         {
2902             NDalicPINVOKE.Actor_SetInheritScale(swigCPtr, inherit);
2903             if (NDalicPINVOKE.SWIGPendingException.Pending)
2904                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2905         }
2906
2907         internal bool IsScaleInherited()
2908         {
2909             bool ret = NDalicPINVOKE.Actor_IsScaleInherited(swigCPtr);
2910             if (NDalicPINVOKE.SWIGPendingException.Pending)
2911                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2912             return ret;
2913         }
2914
2915         internal Matrix GetCurrentWorldMatrix()
2916         {
2917             Matrix ret = new Matrix(NDalicPINVOKE.Actor_GetCurrentWorldMatrix(swigCPtr), true);
2918             if (NDalicPINVOKE.SWIGPendingException.Pending)
2919                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2920             return ret;
2921         }
2922
2923         internal void SetVisible(bool visible)
2924         {
2925             NDalicPINVOKE.Actor_SetVisible(swigCPtr, visible);
2926             if (NDalicPINVOKE.SWIGPendingException.Pending)
2927                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2928         }
2929
2930         internal bool IsVisible()
2931         {
2932             bool ret = NDalicPINVOKE.Actor_IsVisible(swigCPtr);
2933             if (NDalicPINVOKE.SWIGPendingException.Pending)
2934                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2935             return ret;
2936         }
2937
2938         internal void SetOpacity(float opacity)
2939         {
2940             NDalicPINVOKE.Actor_SetOpacity(swigCPtr, opacity);
2941             if (NDalicPINVOKE.SWIGPendingException.Pending)
2942                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2943         }
2944
2945         internal float GetCurrentOpacity()
2946         {
2947             float ret = NDalicPINVOKE.Actor_GetCurrentOpacity(swigCPtr);
2948             if (NDalicPINVOKE.SWIGPendingException.Pending)
2949                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2950             return ret;
2951         }
2952
2953         internal void SetColor(Vector4 color)
2954         {
2955             NDalicPINVOKE.Actor_SetColor(swigCPtr, Vector4.getCPtr(color));
2956             if (NDalicPINVOKE.SWIGPendingException.Pending)
2957                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2958         }
2959
2960         internal Vector4 GetCurrentColor()
2961         {
2962             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentColor(swigCPtr), true);
2963             if (NDalicPINVOKE.SWIGPendingException.Pending)
2964                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2965             return ret;
2966         }
2967
2968         internal void SetColorMode(ColorMode colorMode)
2969         {
2970             NDalicPINVOKE.Actor_SetColorMode(swigCPtr, (int)colorMode);
2971             if (NDalicPINVOKE.SWIGPendingException.Pending)
2972                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2973         }
2974
2975         internal ColorMode GetColorMode()
2976         {
2977             ColorMode ret = (ColorMode)NDalicPINVOKE.Actor_GetColorMode(swigCPtr);
2978             if (NDalicPINVOKE.SWIGPendingException.Pending)
2979                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2980             return ret;
2981         }
2982
2983         internal Vector4 GetCurrentWorldColor()
2984         {
2985             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentWorldColor(swigCPtr), true);
2986             if (NDalicPINVOKE.SWIGPendingException.Pending)
2987                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2988             return ret;
2989         }
2990
2991         internal void SetDrawMode(DrawModeType drawMode)
2992         {
2993             NDalicPINVOKE.Actor_SetDrawMode(swigCPtr, (int)drawMode);
2994             if (NDalicPINVOKE.SWIGPendingException.Pending)
2995                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2996         }
2997
2998         internal DrawModeType GetDrawMode()
2999         {
3000             DrawModeType ret = (DrawModeType)NDalicPINVOKE.Actor_GetDrawMode(swigCPtr);
3001             if (NDalicPINVOKE.SWIGPendingException.Pending)
3002                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3003             return ret;
3004         }
3005
3006         /// <summary>
3007         /// Converts screen coordinates into the view's coordinate system using the default camera.
3008         /// </summary>
3009         /// <pre>The view has been initialized.</pre>
3010         /// <remarks>The view coordinates are relative to the top-left(0.0, 0.0, 0.5).</remarks>
3011         /// <param name="localX">On return, the X-coordinate relative to the view.</param>
3012         /// <param name="localY">On return, the Y-coordinate relative to the view.</param>
3013         /// <param name="screenX">The screen X-coordinate.</param>
3014         /// <param name="screenY">The screen Y-coordinate.</param>
3015         /// <returns>True if the conversion succeeded.</returns>
3016         /// <since_tizen> 3 </since_tizen>
3017         public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY)
3018         {
3019             bool ret = NDalicPINVOKE.Actor_ScreenToLocal(swigCPtr, out localX, out localY, screenX, screenY);
3020             if (NDalicPINVOKE.SWIGPendingException.Pending)
3021                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3022             return ret;
3023         }
3024
3025         internal void SetKeyboardFocusable(bool focusable)
3026         {
3027             NDalicPINVOKE.Actor_SetKeyboardFocusable(swigCPtr, focusable);
3028             if (NDalicPINVOKE.SWIGPendingException.Pending)
3029                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3030         }
3031
3032         internal bool IsKeyboardFocusable()
3033         {
3034             bool ret = NDalicPINVOKE.Actor_IsKeyboardFocusable(swigCPtr);
3035             if (NDalicPINVOKE.SWIGPendingException.Pending)
3036                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3037             return ret;
3038         }
3039
3040         internal void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)
3041         {
3042             NDalicPINVOKE.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
3043             if (NDalicPINVOKE.SWIGPendingException.Pending)
3044                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3045         }
3046
3047         internal ResizePolicyType GetResizePolicy(DimensionType dimension)
3048         {
3049             ResizePolicyType ret = (ResizePolicyType)NDalicPINVOKE.Actor_GetResizePolicy(swigCPtr, (int)dimension);
3050             if (NDalicPINVOKE.SWIGPendingException.Pending)
3051                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3052             return ret;
3053         }
3054
3055         /// <summary>
3056         /// Sets the relative to parent size factor of the view.<br />
3057         /// This factor is only used when ResizePolicy is set to either:
3058         /// ResizePolicy::SIZE_RELATIVE_TO_PARENT or ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT.<br />
3059         /// This view's size is set to the view's size multiplied by or added to this factor, depending on ResizePolicy.<br />
3060         /// </summary>
3061         /// <pre>The view has been initialized.</pre>
3062         /// <param name="factor">A Vector3 representing the relative factor to be applied to each axis.</param>
3063         /// <since_tizen> 3 </since_tizen>
3064         public void SetSizeModeFactor(Vector3 factor)
3065         {
3066             NDalicPINVOKE.Actor_SetSizeModeFactor(swigCPtr, Vector3.getCPtr(factor));
3067             if (NDalicPINVOKE.SWIGPendingException.Pending)
3068                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3069         }
3070
3071         internal Vector3 GetSizeModeFactor()
3072         {
3073             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetSizeModeFactor(swigCPtr), true);
3074             if (NDalicPINVOKE.SWIGPendingException.Pending)
3075                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3076             return ret;
3077         }
3078
3079         /// <summary>
3080         /// Calculates the height of the view given a width.<br />
3081         /// The natural size is used for default calculation.<br />
3082         /// Size 0 is treated as aspect ratio 1:1.<br />
3083         /// </summary>
3084         /// <param name="width">The width to use.</param>
3085         /// <returns>The height based on the width.</returns>
3086         /// <since_tizen> 3 </since_tizen>
3087         public float GetHeightForWidth(float width)
3088         {
3089             float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);
3090             if (NDalicPINVOKE.SWIGPendingException.Pending)
3091                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3092             return ret;
3093         }
3094
3095         /// <summary>
3096         /// Calculates the width of the view given a height.<br />
3097         /// The natural size is used for default calculation.<br />
3098         /// Size 0 is treated as aspect ratio 1:1.<br />
3099         /// </summary>
3100         /// <param name="height">The height to use.</param>
3101         /// <returns>The width based on the height.</returns>
3102         /// <since_tizen> 3 </since_tizen>
3103         public float GetWidthForHeight(float height)
3104         {
3105             float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);
3106             if (NDalicPINVOKE.SWIGPendingException.Pending)
3107                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3108             return ret;
3109         }
3110
3111         /// <summary>
3112         /// Return the amount of size allocated for relayout.
3113         /// </summary>
3114         /// <param name="dimension">The dimension to retrieve.</param>
3115         /// <returns>Return the size.</returns>
3116         /// <since_tizen> 3 </since_tizen>
3117         public float GetRelayoutSize(DimensionType dimension)
3118         {
3119             float ret = NDalicPINVOKE.Actor_GetRelayoutSize(swigCPtr, (int)dimension);
3120             if (NDalicPINVOKE.SWIGPendingException.Pending)
3121                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3122             return ret;
3123         }
3124
3125         /// <summary>
3126         /// Set the padding for the view.
3127         /// </summary>
3128         /// <param name="padding">Padding for the view.</param>
3129         /// <since_tizen> 3 </since_tizen>
3130         public void SetPadding(PaddingType padding)
3131         {
3132             NDalicPINVOKE.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));
3133             if (NDalicPINVOKE.SWIGPendingException.Pending)
3134                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3135         }
3136
3137         /// <summary>
3138         /// Return the value of padding for the view.
3139         /// </summary>
3140         /// <param name="paddingOut">the value of padding for the view</param>
3141         /// <since_tizen> 3 </since_tizen>
3142         public void GetPadding(PaddingType paddingOut)
3143         {
3144             NDalicPINVOKE.Actor_GetPadding(swigCPtr, PaddingType.getCPtr(paddingOut));
3145             if (NDalicPINVOKE.SWIGPendingException.Pending)
3146                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3147         }
3148
3149         internal void SetMinimumSize(Vector2 size)
3150         {
3151             NDalicPINVOKE.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));
3152             if (NDalicPINVOKE.SWIGPendingException.Pending)
3153                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3154         }
3155
3156         internal Vector2 GetMinimumSize()
3157         {
3158             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMinimumSize(swigCPtr), true);
3159             if (NDalicPINVOKE.SWIGPendingException.Pending)
3160                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3161             return ret;
3162         }
3163
3164         internal void SetMaximumSize(Vector2 size)
3165         {
3166             NDalicPINVOKE.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));
3167             if (NDalicPINVOKE.SWIGPendingException.Pending)
3168                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3169         }
3170
3171         internal Vector2 GetMaximumSize()
3172         {
3173             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMaximumSize(swigCPtr), true);
3174             if (NDalicPINVOKE.SWIGPendingException.Pending)
3175                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3176             return ret;
3177         }
3178
3179         internal int GetHierarchyDepth()
3180         {
3181             int ret = NDalicPINVOKE.Actor_GetHierarchyDepth(swigCPtr);
3182             if (NDalicPINVOKE.SWIGPendingException.Pending)
3183                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3184             return ret;
3185         }
3186
3187         /// <since_tizen> 3 </since_tizen>
3188         public uint AddRenderer(Renderer renderer)
3189         {
3190             uint ret = NDalicPINVOKE.Actor_AddRenderer(swigCPtr, Renderer.getCPtr(renderer));
3191             if (NDalicPINVOKE.SWIGPendingException.Pending)
3192                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3193             return ret;
3194         }
3195
3196         internal uint GetRendererCount()
3197         {
3198             uint ret = NDalicPINVOKE.Actor_GetRendererCount(swigCPtr);
3199             if (NDalicPINVOKE.SWIGPendingException.Pending)
3200                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3201             return ret;
3202         }
3203
3204         /// <since_tizen> 3 </since_tizen>
3205         public Renderer GetRendererAt(uint index)
3206         {
3207             //to fix memory leak issue, match the handle count with native side.
3208             IntPtr cPtr = NDalicPINVOKE.Actor_GetRendererAt(swigCPtr, index);
3209             HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
3210             Renderer ret = Registry.GetManagedBaseHandleFromNativePtr(CPtr.Handle) as Renderer;
3211             NDalicPINVOKE.delete_BaseHandle(CPtr);
3212             CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
3213
3214             if (NDalicPINVOKE.SWIGPendingException.Pending)
3215                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3216             return ret;
3217         }
3218
3219         /// <since_tizen> 3 </since_tizen>
3220         public void RemoveRenderer(Renderer renderer)
3221         {
3222             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_0(swigCPtr, Renderer.getCPtr(renderer));
3223             if (NDalicPINVOKE.SWIGPendingException.Pending)
3224                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3225         }
3226
3227         /// <since_tizen> 3 </since_tizen>
3228         public void RemoveRenderer(uint index)
3229         {
3230             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_1(swigCPtr, index);
3231             if (NDalicPINVOKE.SWIGPendingException.Pending)
3232                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3233         }
3234
3235         internal TouchDataSignal TouchSignal()
3236         {
3237             TouchDataSignal ret = new TouchDataSignal(NDalicPINVOKE.Actor_TouchSignal(swigCPtr), false);
3238             if (NDalicPINVOKE.SWIGPendingException.Pending)
3239                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3240             return ret;
3241         }
3242
3243         internal HoverSignal HoveredSignal()
3244         {
3245             HoverSignal ret = new HoverSignal(NDalicPINVOKE.Actor_HoveredSignal(swigCPtr), false);
3246             if (NDalicPINVOKE.SWIGPendingException.Pending)
3247                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3248             return ret;
3249         }
3250
3251         internal WheelSignal WheelEventSignal()
3252         {
3253             WheelSignal ret = new WheelSignal(NDalicPINVOKE.Actor_WheelEventSignal(swigCPtr), false);
3254             if (NDalicPINVOKE.SWIGPendingException.Pending)
3255                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3256             return ret;
3257         }
3258
3259         internal ViewSignal OnWindowSignal()
3260         {
3261             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnStageSignal(swigCPtr), false);
3262             if (NDalicPINVOKE.SWIGPendingException.Pending)
3263                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3264             return ret;
3265         }
3266
3267         internal ViewSignal OffWindowSignal()
3268         {
3269             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OffStageSignal(swigCPtr), false);
3270             if (NDalicPINVOKE.SWIGPendingException.Pending)
3271                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3272             return ret;
3273         }
3274
3275         internal ViewSignal OnRelayoutSignal()
3276         {
3277             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnRelayoutSignal(swigCPtr), false);
3278             if (NDalicPINVOKE.SWIGPendingException.Pending)
3279                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3280             return ret;
3281         }
3282
3283         internal ViewVisibilityChangedSignal VisibilityChangedSignal(View view)
3284         {
3285             ViewVisibilityChangedSignal ret = new ViewVisibilityChangedSignal(NDalicPINVOKE.VisibilityChangedSignal(View.getCPtr(view)), false);
3286             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3287             return ret;
3288         }
3289
3290
3291         internal ViewLayoutDirectionChangedSignal LayoutDirectionChangedSignal(View view)
3292         {
3293             ViewLayoutDirectionChangedSignal ret = new ViewLayoutDirectionChangedSignal(NDalicManualPINVOKE.LayoutDirectionChangedSignal(View.getCPtr(view)), false);
3294             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3295             return ret;
3296         }
3297
3298
3299         internal ViewSignal ResourcesLoadedSignal()
3300         {
3301             ViewSignal ret = new ViewSignal(NDalicPINVOKE.ResourceReadySignal(swigCPtr), false);
3302             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3303             return ret;
3304         }
3305
3306         /// <summary>
3307         /// Gets or sets the origin of a view within its parent's area.<br />
3308         /// 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 />
3309         /// The default parent-origin is ParentOrigin.TopLeft (0.0, 0.0, 0.5).<br />
3310         /// A view's position is the distance between this origin and the view's anchor-point.<br />
3311         /// </summary>
3312         /// <pre>The view has been initialized.</pre>
3313         /// <since_tizen> 3 </since_tizen>
3314         public Position ParentOrigin
3315         {
3316             get
3317             {
3318                 Position temp = new Position(0.0f, 0.0f, 0.0f);
3319                 GetProperty(View.Property.PARENT_ORIGIN).Get(temp);
3320                 return temp;
3321             }
3322             set
3323             {
3324                 SetProperty(View.Property.PARENT_ORIGIN, new Tizen.NUI.PropertyValue(value));
3325             }
3326         }
3327
3328         internal float ParentOriginX
3329         {
3330             get
3331             {
3332                 float temp = 0.0f;
3333                 GetProperty(View.Property.PARENT_ORIGIN_X).Get(out temp);
3334                 return temp;
3335             }
3336             set
3337             {
3338                 SetProperty(View.Property.PARENT_ORIGIN_X, new Tizen.NUI.PropertyValue(value));
3339             }
3340         }
3341
3342         internal float ParentOriginY
3343         {
3344             get
3345             {
3346                 float temp = 0.0f;
3347                 GetProperty(View.Property.PARENT_ORIGIN_Y).Get(out temp);
3348                 return temp;
3349             }
3350             set
3351             {
3352                 SetProperty(View.Property.PARENT_ORIGIN_Y, new Tizen.NUI.PropertyValue(value));
3353             }
3354         }
3355
3356         internal float ParentOriginZ
3357         {
3358             get
3359             {
3360                 float temp = 0.0f;
3361                 GetProperty(View.Property.PARENT_ORIGIN_Z).Get(out temp);
3362                 return temp;
3363             }
3364             set
3365             {
3366                 SetProperty(View.Property.PARENT_ORIGIN_Z, new Tizen.NUI.PropertyValue(value));
3367             }
3368         }
3369
3370         /// <summary>
3371         /// Gets or sets the anchor-point of a view.<br />
3372         /// 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 />
3373         /// The default pivot point is PivotPoint.Center (0.5, 0.5, 0.5).<br />
3374         /// A view position is the distance between its parent-origin and this anchor-point.<br />
3375         /// A view's orientation is the rotation from its default orientation, the rotation is centered around its anchor-point.<br />
3376         /// <pre>The view has been initialized.</pre>
3377         /// </summary>
3378         /// <since_tizen> 3 </since_tizen>
3379         public Position PivotPoint
3380         {
3381             get
3382             {
3383                 Position temp = new Position(0.0f, 0.0f, 0.0f);
3384                 GetProperty(View.Property.ANCHOR_POINT).Get(temp);
3385                 return temp;
3386             }
3387             set
3388             {
3389                 SetProperty(View.Property.ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
3390             }
3391         }
3392
3393         internal float PivotPointX
3394         {
3395             get
3396             {
3397                 float temp = 0.0f;
3398                 GetProperty(View.Property.ANCHOR_POINT_X).Get(out temp);
3399                 return temp;
3400             }
3401             set
3402             {
3403                 SetProperty(View.Property.ANCHOR_POINT_X, new Tizen.NUI.PropertyValue(value));
3404             }
3405         }
3406
3407         internal float PivotPointY
3408         {
3409             get
3410             {
3411                 float temp = 0.0f;
3412                 GetProperty(View.Property.ANCHOR_POINT_Y).Get(out temp);
3413                 return temp;
3414             }
3415             set
3416             {
3417                 SetProperty(View.Property.ANCHOR_POINT_Y, new Tizen.NUI.PropertyValue(value));
3418             }
3419         }
3420
3421         internal float PivotPointZ
3422         {
3423             get
3424             {
3425                 float temp = 0.0f;
3426                 GetProperty(View.Property.ANCHOR_POINT_Z).Get(out temp);
3427                 return temp;
3428             }
3429             set
3430             {
3431                 SetProperty(View.Property.ANCHOR_POINT_Z, new Tizen.NUI.PropertyValue(value));
3432             }
3433         }
3434
3435         /// <summary>
3436         /// Gets or sets the size width of the view.
3437         /// </summary>
3438         /// <since_tizen> 3 </since_tizen>
3439         public float SizeWidth
3440         {
3441             get
3442             {
3443                 float temp = 0.0f;
3444                 GetProperty(View.Property.SIZE_WIDTH).Get(out temp);
3445                 return temp;
3446             }
3447             set
3448             {
3449                 SetProperty(View.Property.SIZE_WIDTH, new Tizen.NUI.PropertyValue(value));
3450             }
3451         }
3452
3453         /// <summary>
3454         /// Gets or sets the size height of the view.
3455         /// </summary>
3456         /// <since_tizen> 3 </since_tizen>
3457         public float SizeHeight
3458         {
3459             get
3460             {
3461                 float temp = 0.0f;
3462                 GetProperty(View.Property.SIZE_HEIGHT).Get(out temp);
3463                 return temp;
3464             }
3465             set
3466             {
3467                 SetProperty(View.Property.SIZE_HEIGHT, new Tizen.NUI.PropertyValue(value));
3468             }
3469         }
3470
3471         /// <summary>
3472         /// Gets or sets the position of the view.<br />
3473         /// By default, sets the position vector between the parent origin and pivot point (default).<br />
3474         /// If the position inheritance is disabled, sets the world position.<br />
3475         /// </summary>
3476         /// <since_tizen> 3 </since_tizen>
3477         public Position Position
3478         {
3479             get
3480             {
3481                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3482                 GetProperty(View.Property.POSITION).Get(temp);
3483                 return temp;
3484             }
3485             set
3486             {
3487                 SetProperty(View.Property.POSITION, new Tizen.NUI.PropertyValue(value));
3488             }
3489         }
3490
3491         /// <summary>
3492         /// Gets or sets the position X of the view.
3493         /// </summary>
3494         /// <since_tizen> 3 </since_tizen>
3495         public float PositionX
3496         {
3497             get
3498             {
3499                 float temp = 0.0f;
3500                 GetProperty(View.Property.POSITION_X).Get(out temp);
3501                 return temp;
3502             }
3503             set
3504             {
3505                 SetProperty(View.Property.POSITION_X, new Tizen.NUI.PropertyValue(value));
3506             }
3507         }
3508
3509         /// <summary>
3510         /// Gets or sets the position Y of the view.
3511         /// </summary>
3512         /// <since_tizen> 3 </since_tizen>
3513         public float PositionY
3514         {
3515             get
3516             {
3517                 float temp = 0.0f;
3518                 GetProperty(View.Property.POSITION_Y).Get(out temp);
3519                 return temp;
3520             }
3521             set
3522             {
3523                 SetProperty(View.Property.POSITION_Y, new Tizen.NUI.PropertyValue(value));
3524             }
3525         }
3526
3527         /// <summary>
3528         /// Gets or sets the position Z of the view.
3529         /// </summary>
3530         /// <since_tizen> 3 </since_tizen>
3531         public float PositionZ
3532         {
3533             get
3534             {
3535                 float temp = 0.0f;
3536                 GetProperty(View.Property.POSITION_Z).Get(out temp);
3537                 return temp;
3538             }
3539             set
3540             {
3541                 SetProperty(View.Property.POSITION_Z, new Tizen.NUI.PropertyValue(value));
3542             }
3543         }
3544
3545         /// <summary>
3546         /// Gets or sets the world position of the view.
3547         /// </summary>
3548         /// <since_tizen> 3 </since_tizen>
3549         public Vector3 WorldPosition
3550         {
3551             get
3552             {
3553                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3554                 GetProperty(View.Property.WORLD_POSITION).Get(temp);
3555                 return temp;
3556             }
3557         }
3558
3559         internal float WorldPositionX
3560         {
3561             get
3562             {
3563                 float temp = 0.0f;
3564                 GetProperty(View.Property.WORLD_POSITION_X).Get(out temp);
3565                 return temp;
3566             }
3567         }
3568
3569         internal float WorldPositionY
3570         {
3571             get
3572             {
3573                 float temp = 0.0f;
3574                 GetProperty(View.Property.WORLD_POSITION_Y).Get(out temp);
3575                 return temp;
3576             }
3577         }
3578
3579         internal float WorldPositionZ
3580         {
3581             get
3582             {
3583                 float temp = 0.0f;
3584                 GetProperty(View.Property.WORLD_POSITION_Z).Get(out temp);
3585                 return temp;
3586             }
3587         }
3588
3589         /// <summary>
3590         /// Gets or sets the orientation of the view.<br />
3591         /// The view's orientation is the rotation from its default orientation, and the rotation is centered around its anchor-point.<br />
3592         /// </summary>
3593         /// <remarks>This is an asynchronous method.</remarks>
3594         /// <since_tizen> 3 </since_tizen>
3595         public Rotation Orientation
3596         {
3597             get
3598             {
3599                 Rotation temp = new Rotation();
3600                 GetProperty(View.Property.ORIENTATION).Get(temp);
3601                 return temp;
3602             }
3603             set
3604             {
3605                 SetProperty(View.Property.ORIENTATION, new Tizen.NUI.PropertyValue(value));
3606             }
3607         }
3608
3609         /// <summary>
3610         /// Gets or sets the world orientation of the view.<br />
3611         /// </summary>
3612         /// <since_tizen> 3 </since_tizen>
3613         public Rotation WorldOrientation
3614         {
3615             get
3616             {
3617                 Rotation temp = new Rotation();
3618                 GetProperty(View.Property.WORLD_ORIENTATION).Get(temp);
3619                 return temp;
3620             }
3621         }
3622
3623         /// <summary>
3624         /// Gets or sets the scale factor applied to the view.<br />
3625         /// </summary>
3626         /// <since_tizen> 3 </since_tizen>
3627         public Vector3 Scale
3628         {
3629             get
3630             {
3631                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3632                 GetProperty(View.Property.SCALE).Get(temp);
3633                 return temp;
3634             }
3635             set
3636             {
3637                 SetProperty(View.Property.SCALE, new Tizen.NUI.PropertyValue(value));
3638             }
3639         }
3640
3641         /// <summary>
3642         /// Gets or sets the scale X factor applied to the view.
3643         /// </summary>
3644         /// <since_tizen> 3 </since_tizen>
3645         public float ScaleX
3646         {
3647             get
3648             {
3649                 float temp = 0.0f;
3650                 GetProperty(View.Property.SCALE_X).Get(out temp);
3651                 return temp;
3652             }
3653             set
3654             {
3655                 SetProperty(View.Property.SCALE_X, new Tizen.NUI.PropertyValue(value));
3656             }
3657         }
3658
3659         /// <summary>
3660         /// Gets or sets the scale Y factor applied to the view.
3661         /// </summary>
3662         /// <since_tizen> 3 </since_tizen>
3663         public float ScaleY
3664         {
3665             get
3666             {
3667                 float temp = 0.0f;
3668                 GetProperty(View.Property.SCALE_Y).Get(out temp);
3669                 return temp;
3670             }
3671             set
3672             {
3673                 SetProperty(View.Property.SCALE_Y, new Tizen.NUI.PropertyValue(value));
3674             }
3675         }
3676
3677         /// <summary>
3678         /// Gets or sets the scale Z factor applied to the view.
3679         /// </summary>
3680         /// <since_tizen> 3 </since_tizen>
3681         public float ScaleZ
3682         {
3683             get
3684             {
3685                 float temp = 0.0f;
3686                 GetProperty(View.Property.SCALE_Z).Get(out temp);
3687                 return temp;
3688             }
3689             set
3690             {
3691                 SetProperty(View.Property.SCALE_Z, new Tizen.NUI.PropertyValue(value));
3692             }
3693         }
3694
3695         /// <summary>
3696         /// Gets the world scale of the view.
3697         /// </summary>
3698         /// <since_tizen> 3 </since_tizen>
3699         public Vector3 WorldScale
3700         {
3701             get
3702             {
3703                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3704                 GetProperty(View.Property.WORLD_SCALE).Get(temp);
3705                 return temp;
3706             }
3707         }
3708
3709         /// <summary>
3710         /// Retrieves the visibility flag of the view.
3711         /// </summary>
3712         /// <remarks>
3713         /// If the view is not visible, then the view and its children will not be rendered.
3714         /// 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.
3715         /// </remarks>
3716         /// <since_tizen> 3 </since_tizen>
3717         public bool Visibility
3718         {
3719             get
3720             {
3721                 bool temp = false;
3722                 GetProperty(View.Property.VISIBLE).Get(out temp);
3723                 return temp;
3724             }
3725         }
3726
3727         /// <summary>
3728         /// Gets the view's world color.
3729         /// </summary>
3730         /// <since_tizen> 3 </since_tizen>
3731         public Vector4 WorldColor
3732         {
3733             get
3734             {
3735                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
3736                 GetProperty(View.Property.WORLD_COLOR).Get(temp);
3737                 return temp;
3738             }
3739         }
3740
3741         internal Matrix WorldMatrix
3742         {
3743             get
3744             {
3745                 Matrix temp = new Matrix();
3746                 GetProperty(View.Property.WORLD_MATRIX).Get(temp);
3747                 return temp;
3748             }
3749         }
3750
3751         /// <summary>
3752         /// Gets or sets the view's name.
3753         /// </summary>
3754         /// <since_tizen> 3 </since_tizen>
3755         public string Name
3756         {
3757             get
3758             {
3759                 string temp;
3760                 GetProperty(View.Property.NAME).Get(out temp);
3761                 return temp;
3762             }
3763             set
3764             {
3765                 SetProperty(View.Property.NAME, new Tizen.NUI.PropertyValue(value));
3766             }
3767         }
3768
3769         /// <summary>
3770         /// Get the number of children held by the view.
3771         /// </summary>
3772         /// <since_tizen> 3 </since_tizen>
3773         public new uint ChildCount
3774         {
3775             get
3776             {
3777                 return GetChildCount();
3778             }
3779         }
3780
3781         /// <summary>
3782         /// Gets the view's ID.
3783         /// Readonly
3784         /// </summary>
3785         /// <since_tizen> 3 </since_tizen>
3786         public uint ID
3787         {
3788             get
3789             {
3790                 return GetId();
3791             }
3792         }
3793
3794         /// <summary>
3795         /// Gets or sets the status of whether the view should emit touch or hover signals.
3796         /// </summary>
3797         /// <since_tizen> 3 </since_tizen>
3798         public bool Sensitive
3799         {
3800             get
3801             {
3802                 bool temp = false;
3803                 GetProperty(View.Property.SENSITIVE).Get(out temp);
3804                 return temp;
3805             }
3806             set
3807             {
3808                 SetProperty(View.Property.SENSITIVE, new Tizen.NUI.PropertyValue(value));
3809             }
3810         }
3811
3812         /// <summary>
3813         /// Gets or sets the status of whether the view should receive a notification when touch or hover motion events leave the boundary of the view.
3814         /// </summary>
3815         /// <since_tizen> 3 </since_tizen>
3816         public bool LeaveRequired
3817         {
3818             get
3819             {
3820                 bool temp = false;
3821                 GetProperty(View.Property.LEAVE_REQUIRED).Get(out temp);
3822                 return temp;
3823             }
3824             set
3825             {
3826                 SetProperty(View.Property.LEAVE_REQUIRED, new Tizen.NUI.PropertyValue(value));
3827             }
3828         }
3829
3830         /// <summary>
3831         /// Gets or sets the status of whether a child view inherits it's parent's orientation.
3832         /// </summary>
3833         /// <since_tizen> 3 </since_tizen>
3834         public bool InheritOrientation
3835         {
3836             get
3837             {
3838                 bool temp = false;
3839                 GetProperty(View.Property.INHERIT_ORIENTATION).Get(out temp);
3840                 return temp;
3841             }
3842             set
3843             {
3844                 SetProperty(View.Property.INHERIT_ORIENTATION, new Tizen.NUI.PropertyValue(value));
3845             }
3846         }
3847
3848         /// <summary>
3849         /// Gets or sets the status of whether a child view inherits it's parent's scale.
3850         /// </summary>
3851         /// <since_tizen> 3 </since_tizen>
3852         public bool InheritScale
3853         {
3854             get
3855             {
3856                 bool temp = false;
3857                 GetProperty(View.Property.INHERIT_SCALE).Get(out temp);
3858                 return temp;
3859             }
3860             set
3861             {
3862                 SetProperty(View.Property.INHERIT_SCALE, new Tizen.NUI.PropertyValue(value));
3863             }
3864         }
3865
3866         /// <summary>
3867         /// Gets or sets the status of how the view and its children should be drawn.<br />
3868         /// Not all views are renderable, but DrawMode can be inherited from any view.<br />
3869         /// If an object is in a 3D layer, it will be depth-tested against other objects in the world, i.e., it may be obscured if other objects are in front.<br />
3870         /// If DrawMode.Overlay2D is used, the view and its children will be drawn as a 2D overlay.<br />
3871         /// Overlay views are drawn in a separate pass, after all non-overlay views within the layer.<br />
3872         /// For overlay views, the drawing order is with respect to tree levels of views, and depth-testing will not be used.<br />
3873         /// </summary>
3874         /// <since_tizen> 3 </since_tizen>
3875         public DrawModeType DrawMode
3876         {
3877             get
3878             {
3879                 string temp;
3880                 if (GetProperty(View.Property.DRAW_MODE).Get(out temp) == false)
3881                 {
3882                     NUILog.Error("DrawMode get error!");
3883                 }
3884                 switch (temp)
3885                 {
3886                     case "NORMAL":
3887                         return DrawModeType.Normal;
3888                     case "OVERLAY_2D":
3889                         return DrawModeType.Overlay2D;
3890                     case "STENCIL":
3891                         return DrawModeType.Stencil;
3892                     default:
3893                         return DrawModeType.Normal;
3894                 }
3895             }
3896             set
3897             {
3898                 SetProperty(View.Property.DRAW_MODE, new Tizen.NUI.PropertyValue((int)value));
3899             }
3900         }
3901
3902         /// <summary>
3903         /// Gets or sets the relative to parent size factor of the view.<br />
3904         /// This factor is only used when ResizePolicyType is set to either: ResizePolicyType.SizeRelativeToParent or ResizePolicyType.SizeFixedOffsetFromParent.<br />
3905         /// This view's size is set to the view's size multiplied by or added to this factor, depending on ResizePolicyType.<br />
3906         /// </summary>
3907         /// <since_tizen> 3 </since_tizen>
3908         public Vector3 SizeModeFactor
3909         {
3910             get
3911             {
3912                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3913                 GetProperty(View.Property.SIZE_MODE_FACTOR).Get(temp);
3914                 return temp;
3915             }
3916             set
3917             {
3918                 SetProperty(View.Property.SIZE_MODE_FACTOR, new Tizen.NUI.PropertyValue(value));
3919             }
3920         }
3921
3922         /// <summary>
3923         /// Gets or sets the width resize policy to be used.
3924         /// </summary>
3925         /// <since_tizen> 3 </since_tizen>
3926         public ResizePolicyType WidthResizePolicy
3927         {
3928             get
3929             {
3930                 string temp;
3931                 if (GetProperty(View.Property.WIDTH_RESIZE_POLICY).Get(out temp) == false)
3932                 {
3933                     NUILog.Error("WidthResizePolicy get error!");
3934                 }
3935                 switch (temp)
3936                 {
3937                     case "FIXED":
3938                         return ResizePolicyType.Fixed;
3939                     case "USE_NATURAL_SIZE":
3940                         return ResizePolicyType.UseNaturalSize;
3941                     case "FILL_TO_PARENT":
3942                         return ResizePolicyType.FillToParent;
3943                     case "SIZE_RELATIVE_TO_PARENT":
3944                         return ResizePolicyType.SizeRelativeToParent;
3945                     case "SIZE_FIXED_OFFSET_FROM_PARENT":
3946                         return ResizePolicyType.SizeFixedOffsetFromParent;
3947                     case "FIT_TO_CHILDREN":
3948                         return ResizePolicyType.FitToChildren;
3949                     case "DIMENSION_DEPENDENCY":
3950                         return ResizePolicyType.DimensionDependency;
3951                     case "USE_ASSIGNED_SIZE":
3952                         return ResizePolicyType.UseAssignedSize;
3953                     default:
3954                         return ResizePolicyType.Fixed;
3955                 }
3956             }
3957             set
3958             {
3959                 SetProperty(View.Property.WIDTH_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));
3960             }
3961         }
3962
3963         /// <summary>
3964         /// Gets or sets the height resize policy to be used.
3965         /// </summary>
3966         /// <since_tizen> 3 </since_tizen>
3967         public ResizePolicyType HeightResizePolicy
3968         {
3969             get
3970             {
3971                 string temp;
3972                 if (GetProperty(View.Property.HEIGHT_RESIZE_POLICY).Get(out temp) == false)
3973                 {
3974                     NUILog.Error("HeightResizePolicy get error!");
3975                 }
3976                 switch (temp)
3977                 {
3978                     case "FIXED":
3979                         return ResizePolicyType.Fixed;
3980                     case "USE_NATURAL_SIZE":
3981                         return ResizePolicyType.UseNaturalSize;
3982                     case "FILL_TO_PARENT":
3983                         return ResizePolicyType.FillToParent;
3984                     case "SIZE_RELATIVE_TO_PARENT":
3985                         return ResizePolicyType.SizeRelativeToParent;
3986                     case "SIZE_FIXED_OFFSET_FROM_PARENT":
3987                         return ResizePolicyType.SizeFixedOffsetFromParent;
3988                     case "FIT_TO_CHILDREN":
3989                         return ResizePolicyType.FitToChildren;
3990                     case "DIMENSION_DEPENDENCY":
3991                         return ResizePolicyType.DimensionDependency;
3992                     case "USE_ASSIGNED_SIZE":
3993                         return ResizePolicyType.UseAssignedSize;
3994                     default:
3995                         return ResizePolicyType.Fixed;
3996                 }
3997             }
3998             set
3999             {
4000                 SetProperty(View.Property.HEIGHT_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));
4001             }
4002         }
4003
4004         /// <summary>
4005         /// Gets or sets the policy to use when setting size with size negotiation.<br />
4006         /// Defaults to SizeScalePolicyType.UseSizeSet.<br />
4007         /// </summary>
4008         /// <since_tizen> 3 </since_tizen>
4009         public SizeScalePolicyType SizeScalePolicy
4010         {
4011             get
4012             {
4013                 string temp;
4014                 if (GetProperty(View.Property.SIZE_SCALE_POLICY).Get(out temp) == false)
4015                 {
4016                     NUILog.Error("SizeScalePolicy get error!");
4017                 }
4018                 switch (temp)
4019                 {
4020                     case "USE_SIZE_SET":
4021                         return SizeScalePolicyType.UseSizeSet;
4022                     case "FIT_WITH_ASPECT_RATIO":
4023                         return SizeScalePolicyType.FitWithAspectRatio;
4024                     case "FILL_WITH_ASPECT_RATIO":
4025                         return SizeScalePolicyType.FillWithAspectRatio;
4026                     default:
4027                         return SizeScalePolicyType.UseSizeSet;
4028                 }
4029             }
4030             set
4031             {
4032                 string valueToString = "";
4033                 switch (value)
4034                 {
4035                     case SizeScalePolicyType.UseSizeSet:
4036                         {
4037                             valueToString = "USE_SIZE_SET";
4038                             break;
4039                         }
4040                     case SizeScalePolicyType.FitWithAspectRatio:
4041                         {
4042                             valueToString = "FIT_WITH_ASPECT_RATIO";
4043                             break;
4044                         }
4045                     case SizeScalePolicyType.FillWithAspectRatio:
4046                         {
4047                             valueToString = "FILL_WITH_ASPECT_RATIO";
4048                             break;
4049                         }
4050                     default:
4051                         {
4052                             valueToString = "USE_SIZE_SET";
4053                             break;
4054                         }
4055                 }
4056                 SetProperty(View.Property.SIZE_SCALE_POLICY, new Tizen.NUI.PropertyValue(valueToString));
4057             }
4058         }
4059
4060         /// <summary>
4061         ///  Gets or sets the status of whether the width size is dependent on the height size.
4062         /// </summary>
4063         /// <since_tizen> 3 </since_tizen>
4064         public bool WidthForHeight
4065         {
4066             get
4067             {
4068                 bool temp = false;
4069                 GetProperty(View.Property.WIDTH_FOR_HEIGHT).Get(out temp);
4070                 return temp;
4071             }
4072             set
4073             {
4074                 SetProperty(View.Property.WIDTH_FOR_HEIGHT, new Tizen.NUI.PropertyValue(value));
4075             }
4076         }
4077
4078         /// <summary>
4079         /// Gets or sets the status of whether the height size is dependent on the width size.
4080         /// </summary>
4081         /// <since_tizen> 3 </since_tizen>
4082         public bool HeightForWidth
4083         {
4084             get
4085             {
4086                 bool temp = false;
4087                 GetProperty(View.Property.HEIGHT_FOR_WIDTH).Get(out temp);
4088                 return temp;
4089             }
4090             set
4091             {
4092                 SetProperty(View.Property.HEIGHT_FOR_WIDTH, new Tizen.NUI.PropertyValue(value));
4093             }
4094         }
4095
4096         /// <summary>
4097         /// Gets or sets the padding for use in layout.
4098         /// </summary>
4099         /// <since_tizen> 5 </since_tizen>
4100         public Extents Padding
4101         {
4102             get
4103             {
4104                 Extents temp = new Extents(0, 0, 0, 0);
4105                 GetProperty(View.Property.PADDING).Get(temp);
4106                 return temp;
4107             }
4108             set
4109             {
4110                 SetProperty(View.Property.PADDING, new Tizen.NUI.PropertyValue(value));
4111             }
4112         }
4113
4114         /// <summary>
4115         /// Gets or sets the minimum size the view can be assigned in size negotiation.
4116         /// </summary>
4117         /// <since_tizen> 3 </since_tizen>
4118         public Size2D MinimumSize
4119         {
4120             get
4121             {
4122                 Size2D temp = new Size2D(0, 0);
4123                 GetProperty(View.Property.MINIMUM_SIZE).Get(temp);
4124                 return temp;
4125             }
4126             set
4127             {
4128                 SetProperty(View.Property.MINIMUM_SIZE, new Tizen.NUI.PropertyValue(value));
4129             }
4130         }
4131
4132         /// <summary>
4133         /// Gets or sets the maximum size the view can be assigned in size negotiation.
4134         /// </summary>
4135         /// <since_tizen> 3 </since_tizen>
4136         public Size2D MaximumSize
4137         {
4138             get
4139             {
4140                 Size2D temp = new Size2D(0, 0);
4141                 GetProperty(View.Property.MAXIMUM_SIZE).Get(temp);
4142                 return temp;
4143             }
4144             set
4145             {
4146                 SetProperty(View.Property.MAXIMUM_SIZE, new Tizen.NUI.PropertyValue(value));
4147             }
4148         }
4149
4150         /// <summary>
4151         /// Gets or sets whether a child view inherits it's parent's position.<br />
4152         /// Default is to inherit.<br />
4153         /// Switching this off means that using position sets the view's world position, i.e., translates from the world origin (0,0,0) to the pivot point of the view.<br />
4154         /// </summary>
4155         /// <since_tizen> 3 </since_tizen>
4156         public bool InheritPosition
4157         {
4158             get
4159             {
4160                 bool temp = false;
4161                 GetProperty(View.Property.INHERIT_POSITION).Get(out temp);
4162                 return temp;
4163             }
4164             set
4165             {
4166                 SetProperty(View.Property.INHERIT_POSITION, new Tizen.NUI.PropertyValue(value));
4167             }
4168         }
4169
4170         /// <summary>
4171         /// Gets or sets the clipping behavior (mode) of it's children.
4172         /// </summary>
4173         /// <since_tizen> 3 </since_tizen>
4174         public ClippingModeType ClippingMode
4175         {
4176             get
4177             {
4178                 string temp;
4179                 if (GetProperty(View.Property.CLIPPING_MODE).Get(out temp) == false)
4180                 {
4181                     NUILog.Error("ClippingMode get error!");
4182                 }
4183                 switch (temp)
4184                 {
4185                     case "DISABLED":
4186                         return ClippingModeType.Disabled;
4187                     case "CLIP_CHILDREN":
4188                         return ClippingModeType.ClipChildren;
4189                     case "CLIP_TO_BOUNDING_BOX":
4190                         return ClippingModeType.ClipToBoundingBox;
4191                     default:
4192                         return ClippingModeType.Disabled;
4193                 }
4194             }
4195             set
4196             {
4197                 SetProperty(View.Property.CLIPPING_MODE, new Tizen.NUI.PropertyValue((int)value));
4198             }
4199         }
4200
4201         /// <summary>
4202         /// Gets the number of renderers held by the view.
4203         /// </summary>
4204         /// <since_tizen> 3 </since_tizen>
4205         public uint RendererCount
4206         {
4207             get
4208             {
4209                 return GetRendererCount();
4210             }
4211         }
4212
4213         /// <summary>
4214         /// Gets/Sets whether inherit parent's the layout Direction.
4215         /// </summary>
4216         /// <since_tizen> 4 </since_tizen>
4217         public bool InheritLayoutDirection
4218         {
4219             get
4220             {
4221                 bool temp = false;
4222                 GetProperty(View.Property.INHERIT_LAYOUT_DIRECTION).Get(out temp);
4223                 return temp;
4224             }
4225             set
4226             {
4227                 SetProperty(View.Property.INHERIT_LAYOUT_DIRECTION, new Tizen.NUI.PropertyValue(value));
4228             }
4229         }
4230
4231         /// <summary>
4232         /// Gets/Sets the layout Direction.
4233         /// </summary>
4234         /// <since_tizen> 4 </since_tizen>
4235         public ViewLayoutDirectionType LayoutDirection
4236         {
4237             get
4238             {
4239                 int temp;
4240                 if (GetProperty(View.Property.LAYOUT_DIRECTION).Get(out temp) == false)
4241                 {
4242                     NUILog.Error("LAYOUT_DIRECTION get error!");
4243                 }
4244                 return (ViewLayoutDirectionType)temp;
4245             }
4246             set
4247             {
4248                 SetProperty(View.Property.LAYOUT_DIRECTION, new Tizen.NUI.PropertyValue((int)value));
4249             }
4250         }
4251
4252         /// <summary>
4253         /// Gets or sets the Margin for use in layout.
4254         /// </summary>
4255         /// <since_tizen> 4 </since_tizen>
4256         public Extents Margin
4257         {
4258             get
4259             {
4260                 Extents temp = new Extents(0, 0, 0, 0);
4261                 GetProperty(View.Property.MARGIN).Get(temp);
4262                 return temp;
4263             }
4264             set
4265             {
4266                 SetProperty(View.Property.MARGIN, new Tizen.NUI.PropertyValue(value));
4267             }
4268         }
4269
4270         /// <summary>
4271         /// Perform an action on a visual registered to this view. <br />
4272         /// Visuals will have actions, this API is used to perform one of these actions with the given attributes.
4273         /// </summary>
4274         /// <param name="propertyIndexOfVisual">The Property index of the visual.</param>
4275         /// <param name="propertyIndexOfActionId">The action to perform.  See Visual to find supported actions.</param>
4276         /// <param name="attributes">Optional attributes for the action.</param>
4277         /// <since_tizen> 5 </since_tizen>
4278         public void DoAction(int propertyIndexOfVisual, int propertyIndexOfActionId, PropertyValue attributes)
4279         {
4280             NDalicManualPINVOKE.View_DoAction(swigCPtr, propertyIndexOfVisual, propertyIndexOfActionId, PropertyValue.getCPtr(attributes));
4281             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4282         }
4283
4284     }
4285
4286     /// <summary>
4287     /// The View layout Direction type.
4288     /// </summary>
4289     /// <since_tizen> 4 </since_tizen>
4290     public enum ViewLayoutDirectionType
4291     {
4292         /// <summary>
4293         /// Left to right.
4294         /// </summary>
4295         /// <since_tizen> 4 </since_tizen>
4296         LTR,
4297         /// <summary>
4298         /// Right to left.
4299         /// </summary>
4300         /// <since_tizen> 4 </since_tizen>
4301         RTL
4302     }
4303 }