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