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