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

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