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