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

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