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

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