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