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         }
1101
1102         /// <summary>
1103         /// Describes the direction to move the focus towards.
1104         /// </summary>
1105         /// <since_tizen> 3 </since_tizen>
1106         public enum FocusDirection
1107         {
1108             /// <summary>
1109             /// Move keyboard focus towards the left direction.
1110             /// </summary>
1111             /// <since_tizen> 3 </since_tizen>
1112             Left,
1113             /// <summary>
1114             /// Move keyboard focus towards the right direction.
1115             /// </summary>
1116             /// <since_tizen> 3 </since_tizen>
1117             Right,
1118             /// <summary>
1119             /// Move keyboard focus towards the up direction.
1120             /// </summary>
1121             /// <since_tizen> 3 </since_tizen>
1122             Up,
1123             /// <summary>
1124             /// Move keyboard focus towards the down direction.
1125             /// </summary>
1126             /// <since_tizen> 3 </since_tizen>
1127             Down,
1128             /// <summary>
1129             /// Move keyboard focus towards the previous page direction.
1130             /// </summary>
1131             /// <since_tizen> 3 </since_tizen>
1132             PageUp,
1133             /// <summary>
1134             /// Move keyboard focus towards the next page direction.
1135             /// </summary>
1136             /// <since_tizen> 3 </since_tizen>
1137             PageDown
1138         }
1139
1140         /// <summary>
1141         /// Creates a new instance of a view.
1142         /// </summary>
1143         /// <since_tizen> 3 </since_tizen>
1144         public View() : this(NDalicPINVOKE.View_New(), true)
1145         {
1146             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1147
1148         }
1149         internal View(View uiControl) : this(NDalicPINVOKE.new_View__SWIG_1(View.getCPtr(uiControl)), true)
1150         {
1151             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1152         }
1153
1154         /// <summary>
1155         /// Downcasts a handle to view handle.<br />
1156         /// If handle points to a view, the downcast produces a valid handle.<br />
1157         /// If not, the returned handle is left uninitialized.<br />
1158         /// </summary>
1159         /// <param name="handle">A handle to an object.</param>
1160         /// <returns>A handle to a view or an uninitialized handle.</returns>
1161         [Obsolete("Please do not use! this will be deprecated, instead please use as keyword.")]
1162         public static View DownCast(BaseHandle handle)
1163         {
1164             View ret =  Registry.GetManagedBaseHandleFromNativePtr(handle) as View;
1165             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1166             return ret;
1167         }
1168
1169         /// <summary>
1170         /// [Obsolete("Please do not use! this will be deprecated, instead please use as keyword.")]
1171         /// </summary>
1172         /// <since_tizen> 3 </since_tizen>
1173         [Obsolete("Please do not use! this will be deprecated, instead please use as keyword.")]
1174         public static T DownCast<T>(View view) where T : View
1175         {
1176             T ret = Registry.GetManagedBaseHandleFromNativePtr(view) as T;
1177             if (ret != null)
1178             {
1179                 return ret;
1180             }
1181             return null;
1182         }
1183
1184         private View ConvertIdToView(uint id)
1185         {
1186             View view = null;
1187
1188             if (Parent is View)
1189             {
1190                 View parentView = Parent as View;
1191                 view = parentView.FindChildById(id);
1192             }
1193
1194             if (!view)
1195             {
1196                 view = Window.Instance.GetRootLayer().FindChildById(id);
1197             }
1198
1199             return view;
1200         }
1201
1202         internal void SetKeyInputFocus()
1203         {
1204             NDalicPINVOKE.View_SetKeyInputFocus(swigCPtr);
1205             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1206         }
1207
1208         /// <summary>
1209         /// Queries whether the view has a focus.
1210         /// </summary>
1211         /// <returns>True if this view has a focus.</returns>
1212         /// <since_tizen> 3 </since_tizen>
1213         public bool HasFocus()
1214         {
1215             bool ret = NDalicPINVOKE.View_HasKeyInputFocus(swigCPtr);
1216             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1217             return ret;
1218         }
1219
1220         internal void ClearKeyInputFocus()
1221         {
1222             NDalicPINVOKE.View_ClearKeyInputFocus(swigCPtr);
1223             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1224         }
1225
1226         internal PinchGestureDetector GetPinchGestureDetector()
1227         {
1228             PinchGestureDetector ret = new PinchGestureDetector(NDalicPINVOKE.View_GetPinchGestureDetector(swigCPtr), true);
1229             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1230             return ret;
1231         }
1232
1233         internal PanGestureDetector GetPanGestureDetector()
1234         {
1235             PanGestureDetector ret = new PanGestureDetector(NDalicPINVOKE.View_GetPanGestureDetector(swigCPtr), true);
1236             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1237             return ret;
1238         }
1239
1240         internal TapGestureDetector GetTapGestureDetector()
1241         {
1242             TapGestureDetector ret = new TapGestureDetector(NDalicPINVOKE.View_GetTapGestureDetector(swigCPtr), true);
1243             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1244             return ret;
1245         }
1246
1247         internal LongPressGestureDetector GetLongPressGestureDetector()
1248         {
1249             LongPressGestureDetector ret = new LongPressGestureDetector(NDalicPINVOKE.View_GetLongPressGestureDetector(swigCPtr), true);
1250             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1251             return ret;
1252         }
1253
1254         /// <summary>
1255         /// Sets the name of the style to be applied to the view.
1256         /// </summary>
1257         /// <param name="styleName">A string matching a style described in a stylesheet.</param>
1258         /// <since_tizen> 3 </since_tizen>
1259         public void SetStyleName(string styleName)
1260         {
1261             NDalicPINVOKE.View_SetStyleName(swigCPtr, styleName);
1262             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1263         }
1264
1265         /// <summary>
1266         /// Retrieves the name of the style to be applied to the view (if any).
1267         /// </summary>
1268         /// <returns>A string matching a style, or an empty string.</returns>
1269         /// <since_tizen> 3 </since_tizen>
1270         public string GetStyleName()
1271         {
1272             string ret = NDalicPINVOKE.View_GetStyleName(swigCPtr);
1273             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1274             return ret;
1275         }
1276
1277         internal void SetBackgroundColor(Vector4 color)
1278         {
1279             NDalicPINVOKE.View_SetBackgroundColor(swigCPtr, Vector4.getCPtr(color));
1280             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1281         }
1282
1283         internal Vector4 GetBackgroundColor()
1284         {
1285             Vector4 ret = new Vector4(NDalicPINVOKE.View_GetBackgroundColor(swigCPtr), true);
1286             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1287             return ret;
1288         }
1289
1290         internal void SetBackgroundImage(Image image)
1291         {
1292             NDalicPINVOKE.View_SetBackgroundImage(swigCPtr, Image.getCPtr(image));
1293             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1294         }
1295
1296         /// <summary>
1297         /// Clears the background.
1298         /// </summary>
1299         /// <since_tizen> 3 </since_tizen>
1300         public void ClearBackground()
1301         {
1302             NDalicPINVOKE.View_ClearBackground(swigCPtr);
1303             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1304         }
1305
1306         internal ControlKeySignal KeyEventSignal()
1307         {
1308             ControlKeySignal ret = new ControlKeySignal(NDalicPINVOKE.View_KeyEventSignal(swigCPtr), false);
1309             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1310             return ret;
1311         }
1312
1313         internal KeyInputFocusSignal KeyInputFocusGainedSignal()
1314         {
1315             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusGainedSignal(swigCPtr), false);
1316             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1317             return ret;
1318         }
1319
1320         internal KeyInputFocusSignal KeyInputFocusLostSignal()
1321         {
1322             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusLostSignal(swigCPtr), false);
1323             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1324             return ret;
1325         }
1326
1327         internal View(ViewImpl implementation) : this(NDalicPINVOKE.new_View__SWIG_2(ViewImpl.getCPtr(implementation)), true)
1328         {
1329             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1330         }
1331
1332         internal enum PropertyRange
1333         {
1334             PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX,
1335             CONTROL_PROPERTY_START_INDEX = PROPERTY_START_INDEX,
1336             CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX + 1000
1337         }
1338
1339         /// <summary>
1340         /// The StyleName, type string.
1341         /// </summary>
1342         /// <since_tizen> 3 </since_tizen>
1343         public string StyleName
1344         {
1345             get
1346             {
1347                 string temp;
1348                 GetProperty(View.Property.STYLE_NAME).Get(out temp);
1349                 return temp;
1350             }
1351             set
1352             {
1353                 SetProperty(View.Property.STYLE_NAME, new Tizen.NUI.PropertyValue(value));
1354             }
1355         }
1356
1357         /// <summary>
1358         /// The mutually exclusive with BACKGROUND_IMAGE and BACKGROUND type Vector4.
1359         /// </summary>
1360         /// <since_tizen> 3 </since_tizen>
1361         public Color BackgroundColor
1362         {
1363             get
1364             {
1365                 Color backgroundColor = new Color(0.0f, 0.0f, 0.0f, 0.0f);
1366
1367                 Tizen.NUI.PropertyMap background = Background;
1368                 int visualType = 0;
1369                 background.Find(Visual.Property.Type)?.Get(out visualType);
1370                 if (visualType == (int)Visual.Type.Color)
1371                 {
1372                     background.Find(ColorVisualProperty.MixColor)?.Get(backgroundColor);
1373                 }
1374
1375                 return backgroundColor;
1376             }
1377             set
1378             {
1379                 SetProperty(View.Property.BACKGROUND, new Tizen.NUI.PropertyValue(value));
1380             }
1381         }
1382
1383         /// <summary>
1384         /// Creates an animation to animate the background color visual. If there is no
1385         /// background visual, creates one with transparent black as it's mixColor.
1386         /// </summary>
1387         /// <since_tizen> 4 </since_tizen>
1388         public Animation AnimateBackgroundColor( object destinationValue,
1389                                                  int startTime,
1390                                                  int endTime,
1391                                                  AlphaFunction.BuiltinFunctions? alphaFunction = null,
1392                                                  object initialValue = null)
1393         {
1394             Tizen.NUI.PropertyMap background = Background;
1395
1396             if( background.Empty() )
1397             {
1398                 // If there is no background yet, ensure there is a transparent
1399                 // color visual
1400                 BackgroundColor = new Color(0.0f, 0.0f, 0.0f, 0.0f);
1401                 background = Background;
1402             }
1403             return AnimateColor( "background", destinationValue, startTime, endTime, alphaFunction, initialValue );
1404         }
1405
1406         /// <summary>
1407         /// Creates an animation to animate the mixColor of the named visual.
1408         /// </summary>
1409         /// <since_tizen> 4 </since_tizen>
1410         public Animation AnimateColor( string targetVisual, object destinationColor, int startTime, int endTime, AlphaFunction.BuiltinFunctions? alphaFunction = null, object initialColor = null )
1411         {
1412             Animation animation = null;
1413             {
1414                 PropertyMap _animator = new PropertyMap();
1415                 if( alphaFunction != null )
1416                 {
1417                     _animator.Add("alphaFunction", new PropertyValue( AlphaFunction.BuiltinToPropertyKey(alphaFunction) ) );
1418                 }
1419
1420                 PropertyMap _timePeriod = new PropertyMap();
1421                 _timePeriod.Add( "duration", new PropertyValue((endTime-startTime)/1000.0f) );
1422                 _timePeriod.Add( "delay", new PropertyValue( startTime/1000.0f ) );
1423                 _animator.Add( "timePeriod", new PropertyValue( _timePeriod ) );
1424
1425                 PropertyMap _transition = new PropertyMap();
1426                 _transition.Add( "animator", new PropertyValue( _animator ) );
1427                 _transition.Add( "target", new PropertyValue( targetVisual ) );
1428                 _transition.Add( "property", new PropertyValue( "mixColor" ) );
1429
1430                 if( initialColor != null )
1431                 {
1432                     PropertyValue initValue = PropertyValue.CreateFromObject( initialColor );
1433                     _transition.Add( "initialValue", initValue );
1434                 }
1435
1436                 PropertyValue destValue = PropertyValue.CreateFromObject( destinationColor );
1437                 _transition.Add( "targetValue", destValue );
1438                 TransitionData _transitionData = new TransitionData( _transition );
1439
1440                 animation = new Animation( NDalicManualPINVOKE.View_CreateTransition(swigCPtr, TransitionData.getCPtr(_transitionData)), true );
1441                 if (NDalicPINVOKE.SWIGPendingException.Pending)
1442                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1443             }
1444             return animation;
1445         }
1446
1447         /// <summary>
1448         /// The mutually exclusive with BACKGROUND_COLOR and BACKGROUND type Map.
1449         /// </summary>
1450         /// <since_tizen> 3 </since_tizen>
1451         public string BackgroundImage
1452         {
1453             get
1454             {
1455                 string backgroundImage = "";
1456
1457                 Tizen.NUI.PropertyMap background = Background;
1458                 int visualType = 0;
1459                 background.Find(Visual.Property.Type)?.Get(out visualType);
1460                 if (visualType == (int)Visual.Type.Image)
1461                 {
1462                     background.Find(ImageVisualProperty.URL)?.Get(out backgroundImage);
1463                 }
1464
1465                 return backgroundImage;
1466             }
1467             set
1468             {
1469                 SetProperty(View.Property.BACKGROUND, new Tizen.NUI.PropertyValue(value));
1470             }
1471         }
1472
1473         /// <summary>
1474         /// The background of view.
1475         /// </summary>
1476         /// <since_tizen> 3 </since_tizen>
1477         public Tizen.NUI.PropertyMap Background
1478         {
1479             get
1480             {
1481                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
1482                 GetProperty( View.Property.BACKGROUND ).Get(temp);
1483                 return temp;
1484             }
1485             set
1486             {
1487                 SetProperty(View.Property.BACKGROUND, new Tizen.NUI.PropertyValue(value));
1488             }
1489         }
1490
1491
1492         /// <summary>
1493         /// The current state of the view.
1494         /// </summary>
1495         /// <since_tizen> 3 </since_tizen>
1496         public States State
1497         {
1498             get
1499             {
1500                 int temp = 0;
1501                 if (GetProperty(View.Property.STATE).Get(out temp) == false)
1502                 {
1503                     NUILog.Error("State get error!");
1504                 }
1505                 switch (temp)
1506                 {
1507                     case 0:
1508                     {
1509                         return States.Normal;
1510                     }
1511                     case 1:
1512                     {
1513                         return States.Focused;
1514                     }
1515                     case 2:
1516                     {
1517                         return States.Disabled;
1518                     }
1519                     default:
1520                     {
1521                         return States.Normal;
1522                     }
1523                 }
1524             }
1525             set
1526             {
1527                 SetProperty(View.Property.STATE, new Tizen.NUI.PropertyValue((int)value));
1528             }
1529         }
1530
1531         /// <summary>
1532         /// The current sub state of the view.
1533         /// </summary>
1534         /// <since_tizen> 3 </since_tizen>
1535         public States SubState
1536         {
1537             get
1538             {
1539                 string temp;
1540                 if (GetProperty(View.Property.SUB_STATE).Get(out temp) == false)
1541                 {
1542                     NUILog.Error("subState get error!");
1543                 }
1544                 switch (temp)
1545                 {
1546                     case "NORMAL":
1547                         return States.Normal;
1548                     case "FOCUSED":
1549                         return States.Focused;
1550                     case "DISABLED":
1551                         return States.Disabled;
1552                     default:
1553                         return States.Normal;
1554                 }
1555             }
1556             set
1557             {
1558                 string valueToString = "";
1559                 switch (value)
1560                 {
1561                     case States.Normal:
1562                     {
1563                         valueToString = "NORMAL";
1564                         break;
1565                     }
1566                     case States.Focused:
1567                     {
1568                         valueToString = "FOCUSED";
1569                         break;
1570                     }
1571                     case States.Disabled:
1572                     {
1573                         valueToString = "DISABLED";
1574                         break;
1575                     }
1576                     default:
1577                     {
1578                         valueToString = "NORMAL";
1579                         break;
1580                     }
1581                 }
1582                 SetProperty(View.Property.SUB_STATE, new Tizen.NUI.PropertyValue(valueToString));
1583             }
1584         }
1585
1586         /// <summary>
1587         /// Displays a tooltip
1588         /// </summary>
1589         /// <since_tizen> 3 </since_tizen>
1590         public Tizen.NUI.PropertyMap Tooltip
1591         {
1592             get
1593             {
1594                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
1595                 GetProperty(View.Property.TOOLTIP).Get(temp);
1596                 return temp;
1597             }
1598             set
1599             {
1600                 SetProperty(View.Property.TOOLTIP, new Tizen.NUI.PropertyValue(value));
1601             }
1602         }
1603
1604         /// <summary>
1605         /// Displays a tooltip as a text.
1606         /// </summary>
1607         /// <since_tizen> 3 </since_tizen>
1608         public string TooltipText
1609         {
1610             set
1611             {
1612                 SetProperty(View.Property.TOOLTIP, new Tizen.NUI.PropertyValue(value));
1613             }
1614         }
1615
1616         private int LeftFocusableViewId
1617         {
1618             get
1619             {
1620                 int temp = 0;
1621                 GetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID).Get(out temp);
1622                 return temp;
1623             }
1624             set
1625             {
1626                 SetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
1627             }
1628         }
1629
1630         private int RightFocusableViewId
1631         {
1632             get
1633             {
1634                 int temp = 0;
1635                 GetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID).Get(out temp);
1636                 return temp;
1637             }
1638             set
1639             {
1640                 SetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
1641             }
1642         }
1643
1644         private int UpFocusableViewId
1645         {
1646             get
1647             {
1648                 int temp = 0;
1649                 GetProperty(View.Property.UP_FOCUSABLE_VIEW_ID).Get(out temp);
1650                 return temp;
1651             }
1652             set
1653             {
1654                 SetProperty(View.Property.UP_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
1655             }
1656         }
1657
1658         private int DownFocusableViewId
1659         {
1660             get
1661             {
1662                 int temp = 0;
1663                 GetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID).Get(out temp);
1664                 return temp;
1665             }
1666             set
1667             {
1668                 SetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
1669             }
1670         }
1671
1672         /// <summary>
1673         /// The Child property of FlexContainer.<br />
1674         /// The proportion of the free space in the container, the flex item will receive.<br />
1675         /// If all items in the container set this property, their sizes will be proportional to the specified flex factor.<br />
1676         /// </summary>
1677         /// <since_tizen> 3 </since_tizen>
1678         public float Flex
1679         {
1680             get
1681             {
1682                 float temp = 0.0f;
1683                 GetProperty(FlexContainer.ChildProperty.FLEX).Get(out temp);
1684                 return temp;
1685             }
1686             set
1687             {
1688                 SetProperty(FlexContainer.ChildProperty.FLEX, new Tizen.NUI.PropertyValue(value));
1689             }
1690         }
1691
1692         /// <summary>
1693         /// The Child property of FlexContainer.<br />
1694         /// The alignment of the flex item along the cross axis, which, if set, overides the default alignment for all items in the container.<br />
1695         /// </summary>
1696         /// <since_tizen> 3 </since_tizen>
1697         public int AlignSelf
1698         {
1699             get
1700             {
1701                 int temp = 0;
1702                 GetProperty(FlexContainer.ChildProperty.ALIGN_SELF).Get(out temp);
1703                 return temp;
1704             }
1705             set
1706             {
1707                 SetProperty(FlexContainer.ChildProperty.ALIGN_SELF, new Tizen.NUI.PropertyValue(value));
1708             }
1709         }
1710
1711         /// <summary>
1712         /// The Child property of FlexContainer.<br />
1713         /// The space around the flex item.<br />
1714         /// </summary>
1715         /// <since_tizen> 3 </since_tizen>
1716         public Vector4 FlexMargin
1717         {
1718             get
1719             {
1720                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
1721                 GetProperty(FlexContainer.ChildProperty.FLEX_MARGIN).Get(temp);
1722                 return temp;
1723             }
1724             set
1725             {
1726                 SetProperty(FlexContainer.ChildProperty.FLEX_MARGIN, new Tizen.NUI.PropertyValue(value));
1727             }
1728         }
1729
1730         /// <summary>
1731         /// The top-left cell this child occupies, if not set, the first available cell is used.
1732         /// </summary>
1733         /// <since_tizen> 3 </since_tizen>
1734         public Vector2 CellIndex
1735         {
1736             get
1737             {
1738                 Vector2 temp = new Vector2(0.0f, 0.0f);
1739                 GetProperty(TableView.ChildProperty.CELL_INDEX).Get(temp);
1740                 return temp;
1741             }
1742             set
1743             {
1744                 SetProperty(TableView.ChildProperty.CELL_INDEX, new Tizen.NUI.PropertyValue(value));
1745             }
1746         }
1747
1748         /// <summary>
1749         /// The number of rows this child occupies, if not set, the default value is 1.
1750         /// </summary>
1751         /// <since_tizen> 3 </since_tizen>
1752         public float RowSpan
1753         {
1754             get
1755             {
1756                 float temp = 0.0f;
1757                 GetProperty(TableView.ChildProperty.ROW_SPAN).Get(out temp);
1758                 return temp;
1759             }
1760             set
1761             {
1762                 SetProperty(TableView.ChildProperty.ROW_SPAN, new Tizen.NUI.PropertyValue(value));
1763             }
1764         }
1765
1766         /// <summary>
1767         /// The number of columns this child occupies, if not set, the default value is 1.
1768         /// </summary>
1769         /// <since_tizen> 3 </since_tizen>
1770         public float ColumnSpan
1771         {
1772             get
1773             {
1774                 float temp = 0.0f;
1775                 GetProperty(TableView.ChildProperty.COLUMN_SPAN).Get(out temp);
1776                 return temp;
1777             }
1778             set
1779             {
1780                 SetProperty(TableView.ChildProperty.COLUMN_SPAN, new Tizen.NUI.PropertyValue(value));
1781             }
1782         }
1783
1784         /// <summary>
1785         /// The horizontal alignment of this child inside the cells, if not set, the default value is 'left'.
1786         /// </summary>
1787         /// <since_tizen> 3 </since_tizen>
1788         public Tizen.NUI.HorizontalAlignmentType CellHorizontalAlignment
1789         {
1790             get
1791             {
1792                 string temp;
1793                 if (GetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT).Get(out temp) == false)
1794                 {
1795                     NUILog.Error("CellHorizontalAlignment get error!");
1796                 }
1797
1798                 switch (temp)
1799                 {
1800                     case "left":
1801                         return Tizen.NUI.HorizontalAlignmentType.Left;
1802                     case "center":
1803                         return Tizen.NUI.HorizontalAlignmentType.Center;
1804                     case "right":
1805                         return Tizen.NUI.HorizontalAlignmentType.Right;
1806                     default:
1807                         return Tizen.NUI.HorizontalAlignmentType.Left;
1808                 }
1809             }
1810             set
1811             {
1812                 string valueToString = "";
1813                 switch (value)
1814                 {
1815                     case Tizen.NUI.HorizontalAlignmentType.Left:
1816                     {
1817                         valueToString = "left";
1818                         break;
1819                     }
1820                     case Tizen.NUI.HorizontalAlignmentType.Center:
1821                     {
1822                         valueToString = "center";
1823                         break;
1824                     }
1825                     case Tizen.NUI.HorizontalAlignmentType.Right:
1826                     {
1827                         valueToString = "right";
1828                         break;
1829                     }
1830                     default:
1831                     {
1832                         valueToString = "left";
1833                         break;
1834                     }
1835                 }
1836                 SetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT, new Tizen.NUI.PropertyValue(valueToString));
1837             }
1838         }
1839
1840         /// <summary>
1841         /// The vertical alignment of this child inside the cells, if not set, the default value is 'top'.
1842         /// </summary>
1843         /// <since_tizen> 3 </since_tizen>
1844         public Tizen.NUI.VerticalAlignmentType CellVerticalAlignment
1845         {
1846             get
1847             {
1848                 string temp;
1849                 GetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT).Get(out temp);
1850                 {
1851                     NUILog.Error("CellVerticalAlignment get error!");
1852                 }
1853
1854                 switch (temp)
1855                 {
1856                     case "top":
1857                         return Tizen.NUI.VerticalAlignmentType.Top;
1858                     case "center":
1859                         return Tizen.NUI.VerticalAlignmentType.Center;
1860                     case "bottom":
1861                         return Tizen.NUI.VerticalAlignmentType.Bottom;
1862                     default:
1863                         return Tizen.NUI.VerticalAlignmentType.Top;
1864                 }
1865             }
1866             set
1867             {
1868                 string valueToString = "";
1869                 switch (value)
1870                 {
1871                     case Tizen.NUI.VerticalAlignmentType.Top:
1872                     {
1873                         valueToString = "top";
1874                         break;
1875                     }
1876                     case Tizen.NUI.VerticalAlignmentType.Center:
1877                     {
1878                         valueToString = "center";
1879                         break;
1880                     }
1881                     case Tizen.NUI.VerticalAlignmentType.Bottom:
1882                     {
1883                         valueToString = "bottom";
1884                         break;
1885                     }
1886                     default:
1887                     {
1888                         valueToString = "top";
1889                         break;
1890                     }
1891                 }
1892                 SetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT, new Tizen.NUI.PropertyValue(valueToString));
1893             }
1894         }
1895
1896         /// <summary>
1897         /// The left focusable view.<br />
1898         /// This will return null if not set.<br />
1899         /// This will also return null if the specified left focusable view is not on a window.<br />
1900         /// </summary>
1901         /// <since_tizen> 3 </since_tizen>
1902         public View LeftFocusableView
1903         {
1904             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1905             get
1906             {
1907                 if (LeftFocusableViewId >= 0)
1908                 {
1909                     return ConvertIdToView((uint)LeftFocusableViewId);
1910                 }
1911                 return null;
1912             }
1913             set
1914             {
1915                 LeftFocusableViewId = (int)value.GetId();
1916             }
1917         }
1918
1919         /// <summary>
1920         /// The right focusable view.<br />
1921         /// This will return null if not set.<br />
1922         /// This will also return null if the specified right focusable view is not on a window.<br />
1923         /// </summary>
1924         /// <since_tizen> 3 </since_tizen>
1925         public View RightFocusableView
1926         {
1927             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1928             get
1929             {
1930                 if (RightFocusableViewId >= 0)
1931                 {
1932                     return ConvertIdToView((uint)RightFocusableViewId);
1933                 }
1934                 return null;
1935             }
1936             set
1937             {
1938                 RightFocusableViewId = (int)value.GetId();
1939             }
1940         }
1941
1942         /// <summary>
1943         /// The up focusable view.<br />
1944         /// This will return null if not set.<br />
1945         /// This will also return null if the specified up focusable view is not on a window.<br />
1946         /// </summary>
1947         /// <since_tizen> 3 </since_tizen>
1948         public View UpFocusableView
1949         {
1950             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1951             get
1952             {
1953                 if (UpFocusableViewId >= 0)
1954                 {
1955                     return ConvertIdToView((uint)UpFocusableViewId);
1956                 }
1957                 return null;
1958             }
1959             set
1960             {
1961                 UpFocusableViewId = (int)value.GetId();
1962             }
1963         }
1964
1965         /// <summary>
1966         /// The down focusable view.<br />
1967         /// This will return null if not set.<br />
1968         /// This will also return null if the specified down focusable view is not on a window.<br />
1969         /// </summary>
1970         /// <since_tizen> 3 </since_tizen>
1971         public View DownFocusableView
1972         {
1973             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1974             get
1975             {
1976                 if (DownFocusableViewId >= 0)
1977                 {
1978                     return ConvertIdToView((uint)DownFocusableViewId);
1979                 }
1980                 return null;
1981             }
1982             set
1983             {
1984                 DownFocusableViewId = (int)value.GetId();
1985             }
1986         }
1987
1988         /// <summary>
1989         /// Whether the view should be focusable by keyboard navigation.
1990         /// </summary>
1991         /// <since_tizen> 3 </since_tizen>
1992         public bool Focusable
1993         {
1994             set
1995             {
1996                 SetKeyboardFocusable(value);
1997             }
1998             get
1999             {
2000                 return IsKeyboardFocusable();
2001             }
2002         }
2003
2004         /// <summary>
2005         /// Enumeration for describing the states of the view.
2006         /// </summary>
2007         /// <since_tizen> 3 </since_tizen>
2008         public enum States
2009         {
2010             /// <summary>
2011             /// The normal state.
2012             /// </summary>
2013             Normal,
2014             /// <summary>
2015             /// The focused state.
2016             /// </summary>
2017             Focused,
2018             /// <summary>
2019             /// The disabled state.
2020             /// </summary>
2021             Disabled
2022         }
2023
2024         /// <summary>
2025         ///  Retrieves the position of the view.<br />
2026         ///  The coordinates are relative to the view's parent.<br />
2027         /// </summary>
2028         /// <since_tizen> 3 </since_tizen>
2029         public Position CurrentPosition
2030         {
2031             get
2032             {
2033                 return GetCurrentPosition();
2034             }
2035         }
2036
2037         /// <summary>
2038         /// Sets the size of a view for the width and the height.<br />
2039         /// Geometry can be scaled to fit within this area.<br />
2040         /// This does not interfere with the view's scale factor.<br />
2041         /// The views default depth is the minimum of width and height.<br />
2042         /// </summary>
2043         /// <since_tizen> 3 </since_tizen>
2044         public Size2D Size2D
2045         {
2046             get
2047             {
2048                 Size temp = new Size(0.0f, 0.0f, 0.0f);
2049                 GetProperty(View.Property.SIZE).Get(temp);
2050                 Size2D size = new Size2D((int)temp.Width, (int)temp.Height);
2051                 return size;
2052             }
2053             set
2054             {
2055                 SetProperty(View.Property.SIZE, new Tizen.NUI.PropertyValue(new Size(value)));
2056             }
2057         }
2058
2059         /// <summary>
2060         ///  Retrieves the size of the view.<br />
2061         ///  The coordinates are relative to the view's parent.<br />
2062         /// </summary>
2063         /// <since_tizen> 3 </since_tizen>
2064         public Size2D CurrentSize
2065         {
2066             get
2067             {
2068                 return GetCurrentSize();
2069             }
2070         }
2071
2072         /// <summary>
2073         /// [Obsolete("Please do not use! this will be deprecated. Please use Visibility instead.")]
2074         /// </summary>
2075         /// <since_tizen> 3 </since_tizen>
2076         [Obsolete("Please do not use! this will be deprecated. Please use Visibility instead.")]
2077         public bool Visible
2078         {
2079             get
2080             {
2081                 return IsVisible();
2082             }
2083         }
2084
2085         /// <summary>
2086         /// Retrieves and sets the view's opacity.<br />
2087         /// </summary>
2088         /// <since_tizen> 3 </since_tizen>
2089         public float Opacity
2090         {
2091             get
2092             {
2093                 float temp = 0.0f;
2094                 GetProperty(View.Property.OPACITY).Get(out temp);
2095                 return temp;
2096             }
2097             set
2098             {
2099                 SetProperty(View.Property.OPACITY, new Tizen.NUI.PropertyValue(value));
2100             }
2101         }
2102
2103         /// <summary>
2104         /// Sets the position of the view for X and Y.<br />
2105         /// By default, sets the position vector between the parent origin and the pivot point (default).<br />
2106         /// If the position inheritance is disabled, sets the world position.<br />
2107         /// </summary>
2108         /// <since_tizen> 3 </since_tizen>
2109         public Position2D Position2D
2110         {
2111             get
2112             {
2113                 Position temp = new Position(0.0f, 0.0f, 0.0f);
2114                 GetProperty(View.Property.POSITION).Get(temp);
2115                 return new Position2D(temp);
2116             }
2117             set
2118             {
2119                 SetProperty(View.Property.POSITION, new Tizen.NUI.PropertyValue(new Position(value)));
2120             }
2121         }
2122
2123         /// <summary>
2124         /// Retrieves the screen postion of the view.<br />
2125         /// </summary>
2126         /// <since_tizen> 3 </since_tizen>
2127         public Vector2 ScreenPosition
2128         {
2129             get
2130             {
2131                 Vector2 temp = new Vector2(0.0f, 0.0f);
2132                 GetProperty(View.Property.SCREEN_POSITION).Get(temp);
2133                 return temp;
2134             }
2135         }
2136
2137         /// <summary>
2138         /// Determines whether the pivot point should be used to determine the position of the view.
2139         /// This is true by default.
2140         /// </summary>
2141         /// <remarks>If false, then the top-left of the view is used for the position.
2142         /// Setting this to false will allow scaling or rotation around the anchor-point without affecting the view's position.
2143         /// </remarks>
2144         /// <since_tizen> 4 </since_tizen>
2145         public bool PositionUsesPivotPoint
2146         {
2147             get
2148             {
2149                 bool temp = false;
2150                 GetProperty(View.Property.POSITION_USES_ANCHOR_POINT).Get(out temp);
2151                 return temp;
2152             }
2153             set
2154             {
2155                 SetProperty(View.Property.POSITION_USES_ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
2156             }
2157         }
2158
2159         /// <summary>
2160         /// [Obsolete("Please do not use! this will be deprecated")]
2161         /// </summary>
2162         /// <since_tizen> 3 </since_tizen>
2163         [Obsolete("Please do not use! this will be deprecated")]
2164         public bool PositionUsesAnchorPoint
2165         {
2166             get
2167             {
2168                 bool temp = false;
2169                 GetProperty(View.Property.POSITION_USES_ANCHOR_POINT).Get(out temp);
2170                 return temp;
2171             }
2172             set
2173             {
2174                 SetProperty(View.Property.POSITION_USES_ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
2175             }
2176         }
2177
2178         internal bool FocusState
2179         {
2180             get
2181             {
2182                 return IsKeyboardFocusable();
2183             }
2184             set
2185             {
2186                 SetKeyboardFocusable(value);
2187             }
2188         }
2189
2190         /// <summary>
2191         /// Queries whether the view is connected to the stage.<br />
2192         /// When a view is connected, it will be directly or indirectly parented to the root view.<br />
2193         /// </summary>
2194         /// <since_tizen> 3 </since_tizen>
2195         public bool IsOnWindow
2196         {
2197             get
2198             {
2199                 return OnWindow();
2200             }
2201         }
2202
2203         /// <summary>
2204         /// Gets the depth in the hierarchy for the view.
2205         /// </summary>
2206         /// <since_tizen> 3 </since_tizen>
2207         public int HierarchyDepth
2208         {
2209             get
2210             {
2211                 return GetHierarchyDepth();
2212             }
2213         }
2214
2215         /// <summary>
2216         /// Sets the sibling order of the view so the depth position can be defined within the same parent.
2217         /// </summary>
2218         /// <remarks>
2219         /// Note the initial value is 0.
2220         /// Raise, Lower, RaiseToTop, LowerToBottom, RaiseAbove, and LowerBelow will override the sibling order.
2221         /// The values set by this property will likely change.
2222         /// </remarks>
2223         /// <since_tizen> 3 </since_tizen>
2224         public int SiblingOrder
2225         {
2226             get
2227             {
2228                 int temp = 0;
2229                 GetProperty(View.Property.SIBLING_ORDER).Get(out temp);
2230                 return temp;
2231             }
2232             set
2233             {
2234                 SetProperty(View.Property.SIBLING_ORDER, new Tizen.NUI.PropertyValue(value));
2235             }
2236         }
2237
2238         /// <summary>
2239         /// Returns the natural size of the view.
2240         /// </summary>
2241         /// <remarks>
2242         /// Deriving classes stipulate the natural size and by default a view has a zero natural size.
2243         /// </remarks>
2244         [Obsolete("Please do not use! this will be deprecated, please use NaturalSize2D instead")]
2245         public Vector3 NaturalSize
2246         {
2247             get
2248             {
2249                 Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
2250                 if (NDalicPINVOKE.SWIGPendingException.Pending)
2251                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2252                 return ret;
2253             }
2254         }
2255
2256         /// <summary>
2257         /// Returns the natural size (Size2D) of the view.
2258         /// </summary>
2259         /// <remarks>
2260         /// Deriving classes stipulate the natural size and by default a view has a zero natural size.
2261         /// </remarks>
2262         /// <since_tizen> 4 </since_tizen>
2263         public Size2D NaturalSize2D
2264         {
2265             get
2266             {
2267                 Vector3 temp = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
2268                 if (NDalicPINVOKE.SWIGPendingException.Pending)
2269                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2270
2271                 return new Size2D((int)temp.Width, (int)temp.Height);
2272             }
2273         }
2274
2275         /// <summary>
2276         /// Shows the view.
2277         /// </summary>
2278         /// <remarks>
2279         /// This is an asynchronous method.
2280         /// </remarks>
2281         /// <since_tizen> 3 </since_tizen>
2282         public void Show()
2283         {
2284             SetVisible(true);
2285         }
2286
2287         /// <summary>
2288         /// Hides the view.
2289         /// </summary>
2290         /// <remarks>
2291         /// This is an asynchronous method.
2292         /// If the view is hidden, then the view and its children will not be rendered.
2293         /// 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.
2294         /// </remarks>
2295         /// <since_tizen> 3 </since_tizen>
2296         public void Hide()
2297         {
2298             SetVisible(false);
2299         }
2300
2301         internal void Raise()
2302         {
2303             var parentChildren = Parent?.Children;
2304
2305             if (parentChildren != null)
2306             {
2307                 int currentIndex = parentChildren.IndexOf(this);
2308
2309                 // If the view is not already the last item in the list.
2310                 if (currentIndex != parentChildren.Count -1)
2311                 {
2312                     View temp = parentChildren[currentIndex + 1];
2313                     parentChildren[currentIndex + 1] = this;
2314                     parentChildren[currentIndex] = temp;
2315                 }
2316             }
2317
2318             NDalicPINVOKE.Raise(swigCPtr);
2319             if (NDalicPINVOKE.SWIGPendingException.Pending)
2320                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2321         }
2322
2323         internal void Lower()
2324         {
2325             var parentChildren = Parent?.Children;
2326
2327             if (parentChildren != null)
2328             {
2329                 int currentIndex = parentChildren.IndexOf(this);
2330
2331                 // If the view is not already the first item in the list.
2332                 if (currentIndex > 0)
2333                 {
2334                     View temp = parentChildren[currentIndex - 1];
2335                     parentChildren[currentIndex - 1] = this;
2336                     parentChildren[currentIndex] = temp;
2337                 }
2338             }
2339
2340             NDalicPINVOKE.Lower(swigCPtr);
2341             if (NDalicPINVOKE.SWIGPendingException.Pending)
2342                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2343         }
2344
2345         /// <summary>
2346         /// Raises the view above all other views.
2347         /// </summary>
2348         /// <remarks>
2349         /// Sibling order of views within the parent will be updated automatically.
2350         /// Once a raise or lower API is used, that view will then have an exclusive sibling order independent of insertion.
2351         /// </remarks>
2352         /// <since_tizen> 3 </since_tizen>
2353         public void RaiseToTop()
2354         {
2355             var parentChildren = Parent?.Children;
2356
2357             if (parentChildren != null)
2358             {
2359                 parentChildren.Remove(this);
2360                 parentChildren.Add(this);
2361             }
2362
2363             NDalicPINVOKE.RaiseToTop(swigCPtr);
2364             if (NDalicPINVOKE.SWIGPendingException.Pending)
2365                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2366         }
2367
2368         /// <summary>
2369         /// Lowers the view to the bottom of all views.
2370         /// </summary>
2371         /// <remarks>
2372         /// The sibling order of views within the parent will be updated automatically.
2373         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
2374         /// </remarks>
2375         /// <since_tizen> 3 </since_tizen>
2376         public void LowerToBottom()
2377         {
2378             var parentChildren = Parent?.Children;
2379
2380             if (parentChildren != null)
2381             {
2382                 parentChildren.Remove(this);
2383                 parentChildren.Insert(0, this);
2384             }
2385
2386             NDalicPINVOKE.LowerToBottom(swigCPtr);
2387             if (NDalicPINVOKE.SWIGPendingException.Pending)
2388                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2389         }
2390
2391         /// <summary>
2392         /// Queries if all resources required by a view are loaded and ready.
2393         /// </summary>
2394         /// <remarks>Most resources are only loaded when the control is placed on the stage.
2395         /// </remarks>
2396         /// <since_tizen> 4 </since_tizen>
2397         public bool IsResourceReady()
2398         {
2399             bool ret = NDalicPINVOKE.IsResourceReady(swigCPtr);
2400             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2401             return ret;
2402         }
2403
2404         /// <summary>
2405         /// Raises the view to above the target view.
2406         /// </summary>
2407         /// <remarks>The sibling order of views within the parent will be updated automatically.
2408         /// Views on the level above the target view will still be shown above this view.
2409         /// Raising this view above views with the same sibling order as each other will raise this view above them.
2410         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
2411         /// </remarks>
2412         /// <param name="target">Will be raised above this view.</param>
2413         internal void RaiseAbove(View target)
2414         {
2415             var parentChildren = Parent?.Children;
2416
2417             if (parentChildren != null)
2418             {
2419                 int currentIndex = parentChildren.IndexOf(this);
2420                 int targetIndex = parentChildren.IndexOf(target);
2421
2422                 // If the currentIndex is less than the target index and the target has the same parent.
2423                 if (currentIndex < targetIndex)
2424                 {
2425                     parentChildren.Remove(this);
2426                     parentChildren.Insert(targetIndex, this);
2427                 }
2428             }
2429
2430             NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
2431             if (NDalicPINVOKE.SWIGPendingException.Pending)
2432                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2433         }
2434
2435         /// <summary>
2436         /// Lowers the view to below the target view.
2437         /// </summary>
2438         /// <remarks>The sibling order of views within the parent will be updated automatically.
2439         /// Lowering this view below views with the same sibling order as each other will lower 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 lowered below this view.</param>
2443         internal void LowerBelow(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 not already the 0th index and the target has the same parent.
2453                 if ((currentIndex != 0) && (targetIndex != -1) &&
2454                     (currentIndex > targetIndex))
2455                 {
2456                     parentChildren.Remove(this);
2457                     parentChildren.Insert(targetIndex, this);
2458                 }
2459             }
2460
2461             NDalicPINVOKE.LowerBelow(swigCPtr, View.getCPtr(target));
2462             if (NDalicPINVOKE.SWIGPendingException.Pending)
2463                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2464         }
2465
2466         internal string GetName()
2467         {
2468             string ret = NDalicPINVOKE.Actor_GetName(swigCPtr);
2469             if (NDalicPINVOKE.SWIGPendingException.Pending)
2470                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2471             return ret;
2472         }
2473
2474         internal void SetName(string name)
2475         {
2476             NDalicPINVOKE.Actor_SetName(swigCPtr, name);
2477             if (NDalicPINVOKE.SWIGPendingException.Pending)
2478                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2479         }
2480
2481         internal uint GetId()
2482         {
2483             uint ret = NDalicPINVOKE.Actor_GetId(swigCPtr);
2484             if (NDalicPINVOKE.SWIGPendingException.Pending)
2485                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2486             return ret;
2487         }
2488
2489         internal bool IsRoot()
2490         {
2491             bool ret = NDalicPINVOKE.Actor_IsRoot(swigCPtr);
2492             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2493             return ret;
2494         }
2495
2496         internal bool OnWindow()
2497         {
2498             bool ret = NDalicPINVOKE.Actor_OnStage(swigCPtr);
2499             if (NDalicPINVOKE.SWIGPendingException.Pending)
2500                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2501             return ret;
2502         }
2503
2504         internal Layer GetLayer()
2505         {
2506             IntPtr cPtr = NDalicPINVOKE.Actor_GetLayer(swigCPtr);
2507             Layer ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as Layer;
2508
2509             if (NDalicPINVOKE.SWIGPendingException.Pending)
2510                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2511             return ret;
2512         }
2513
2514         /// <summary>
2515         /// Removes a view from its parent view or layer. If a view has no parent, this method does nothing.
2516         /// </summary>
2517         /// <pre>The (child) view has been initialized. </pre>
2518         /// <since_tizen> 4 </since_tizen>
2519         public void Unparent()
2520         {
2521             GetParent()?.Remove(this);
2522         }
2523
2524         /// <summary>
2525         /// Search through this view's hierarchy for a view with the given name.
2526         /// The view itself is also considered in the search.
2527         /// </summary>
2528         /// <pre>The view has been initialized.</pre>
2529         /// <param name="viewName">The name of the view to find.</param>
2530         /// <returns>A handle to the view if found, or an empty handle if not.</returns>
2531         /// <since_tizen> 3 </since_tizen>
2532         public View FindChildByName(string viewName)
2533         {
2534             IntPtr cPtr = NDalicPINVOKE.Actor_FindChildByName(swigCPtr, viewName);
2535
2536             View ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as View;
2537
2538             if (NDalicPINVOKE.SWIGPendingException.Pending)
2539                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2540             return ret;
2541         }
2542
2543         internal View FindChildById(uint id)
2544         {
2545             IntPtr cPtr = NDalicPINVOKE.Actor_FindChildById(swigCPtr, id);
2546
2547             View ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as View;
2548
2549             if (NDalicPINVOKE.SWIGPendingException.Pending)
2550                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2551             return ret;
2552         }
2553
2554         internal void SetParentOrigin(Vector3 origin)
2555         {
2556             NDalicPINVOKE.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));
2557             if (NDalicPINVOKE.SWIGPendingException.Pending)
2558                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2559         }
2560
2561         internal Vector3 GetCurrentParentOrigin()
2562         {
2563             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentParentOrigin(swigCPtr), true);
2564             if (NDalicPINVOKE.SWIGPendingException.Pending)
2565                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2566             return ret;
2567         }
2568
2569         internal void SetAnchorPoint(Vector3 anchorPoint)
2570         {
2571             NDalicPINVOKE.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
2572             if (NDalicPINVOKE.SWIGPendingException.Pending)
2573                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2574         }
2575
2576         internal Vector3 GetCurrentAnchorPoint()
2577         {
2578             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentAnchorPoint(swigCPtr), true);
2579             if (NDalicPINVOKE.SWIGPendingException.Pending)
2580                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2581             return ret;
2582         }
2583
2584         internal void SetSize(float width, float height)
2585         {
2586             NDalicPINVOKE.Actor_SetSize__SWIG_0(swigCPtr, width, height);
2587             if (NDalicPINVOKE.SWIGPendingException.Pending)
2588                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2589         }
2590
2591         internal void SetSize(float width, float height, float depth)
2592         {
2593             NDalicPINVOKE.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);
2594             if (NDalicPINVOKE.SWIGPendingException.Pending)
2595                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2596         }
2597
2598         internal void SetSize(Vector2 size)
2599         {
2600             NDalicPINVOKE.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));
2601             if (NDalicPINVOKE.SWIGPendingException.Pending)
2602                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2603         }
2604
2605         internal void SetSize(Vector3 size)
2606         {
2607             NDalicPINVOKE.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));
2608             if (NDalicPINVOKE.SWIGPendingException.Pending)
2609                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2610         }
2611
2612         internal Vector3 GetTargetSize()
2613         {
2614             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetTargetSize(swigCPtr), true);
2615             if (NDalicPINVOKE.SWIGPendingException.Pending)
2616                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2617             return ret;
2618         }
2619
2620         internal Size2D GetCurrentSize()
2621         {
2622             Size ret = new Size(NDalicPINVOKE.Actor_GetCurrentSize(swigCPtr), true);
2623             if (NDalicPINVOKE.SWIGPendingException.Pending)
2624                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2625             Size2D size = new Size2D((int)ret.Width, (int)ret.Height);
2626             return size;
2627         }
2628
2629         internal Vector3 GetNaturalSize()
2630         {
2631             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
2632             if (NDalicPINVOKE.SWIGPendingException.Pending)
2633                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2634             return ret;
2635         }
2636
2637         internal void SetPosition(float x, float y)
2638         {
2639             NDalicPINVOKE.Actor_SetPosition__SWIG_0(swigCPtr, x, y);
2640             if (NDalicPINVOKE.SWIGPendingException.Pending)
2641                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2642         }
2643
2644         internal void SetPosition(float x, float y, float z)
2645         {
2646             NDalicPINVOKE.Actor_SetPosition__SWIG_1(swigCPtr, x, y, z);
2647             if (NDalicPINVOKE.SWIGPendingException.Pending)
2648                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2649         }
2650
2651         internal void SetPosition(Vector3 position)
2652         {
2653             NDalicPINVOKE.Actor_SetPosition__SWIG_2(swigCPtr, Vector3.getCPtr(position));
2654             if (NDalicPINVOKE.SWIGPendingException.Pending)
2655                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2656         }
2657
2658         internal void SetX(float x)
2659         {
2660             NDalicPINVOKE.Actor_SetX(swigCPtr, x);
2661             if (NDalicPINVOKE.SWIGPendingException.Pending)
2662                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2663         }
2664
2665         internal void SetY(float y)
2666         {
2667             NDalicPINVOKE.Actor_SetY(swigCPtr, y);
2668             if (NDalicPINVOKE.SWIGPendingException.Pending)
2669                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2670         }
2671
2672         internal void SetZ(float z)
2673         {
2674             NDalicPINVOKE.Actor_SetZ(swigCPtr, z);
2675             if (NDalicPINVOKE.SWIGPendingException.Pending)
2676                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2677         }
2678
2679         internal void TranslateBy(Vector3 distance)
2680         {
2681             NDalicPINVOKE.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));
2682             if (NDalicPINVOKE.SWIGPendingException.Pending)
2683                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2684         }
2685
2686         internal Position GetCurrentPosition()
2687         {
2688             Position ret = new Position(NDalicPINVOKE.Actor_GetCurrentPosition(swigCPtr), true);
2689             if (NDalicPINVOKE.SWIGPendingException.Pending)
2690                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2691             return ret;
2692         }
2693
2694         internal Vector3 GetCurrentWorldPosition()
2695         {
2696             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldPosition(swigCPtr), true);
2697             if (NDalicPINVOKE.SWIGPendingException.Pending)
2698                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2699             return ret;
2700         }
2701
2702         internal void SetInheritPosition(bool inherit)
2703         {
2704             NDalicPINVOKE.Actor_SetInheritPosition(swigCPtr, inherit);
2705             if (NDalicPINVOKE.SWIGPendingException.Pending)
2706                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2707         }
2708
2709         internal bool IsPositionInherited()
2710         {
2711             bool ret = NDalicPINVOKE.Actor_IsPositionInherited(swigCPtr);
2712             if (NDalicPINVOKE.SWIGPendingException.Pending)
2713                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2714             return ret;
2715         }
2716
2717         internal void SetOrientation(Degree angle, Vector3 axis)
2718         {
2719             NDalicPINVOKE.Actor_SetOrientation__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
2720             if (NDalicPINVOKE.SWIGPendingException.Pending)
2721                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2722         }
2723
2724         internal void SetOrientation(Radian angle, Vector3 axis)
2725         {
2726             NDalicPINVOKE.Actor_SetOrientation__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
2727             if (NDalicPINVOKE.SWIGPendingException.Pending)
2728                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2729         }
2730
2731         internal void SetOrientation(Rotation orientation)
2732         {
2733             NDalicPINVOKE.Actor_SetOrientation__SWIG_2(swigCPtr, Rotation.getCPtr(orientation));
2734             if (NDalicPINVOKE.SWIGPendingException.Pending)
2735                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2736         }
2737
2738         internal void RotateBy(Degree angle, Vector3 axis)
2739         {
2740             NDalicPINVOKE.Actor_RotateBy__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
2741             if (NDalicPINVOKE.SWIGPendingException.Pending)
2742                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2743         }
2744
2745         internal void RotateBy(Radian angle, Vector3 axis)
2746         {
2747             NDalicPINVOKE.Actor_RotateBy__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
2748             if (NDalicPINVOKE.SWIGPendingException.Pending)
2749                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2750         }
2751
2752         internal void RotateBy(Rotation relativeRotation)
2753         {
2754             NDalicPINVOKE.Actor_RotateBy__SWIG_2(swigCPtr, Rotation.getCPtr(relativeRotation));
2755             if (NDalicPINVOKE.SWIGPendingException.Pending)
2756                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2757         }
2758
2759         internal Rotation GetCurrentOrientation()
2760         {
2761             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentOrientation(swigCPtr), true);
2762             if (NDalicPINVOKE.SWIGPendingException.Pending)
2763                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2764             return ret;
2765         }
2766
2767         internal void SetInheritOrientation(bool inherit)
2768         {
2769             NDalicPINVOKE.Actor_SetInheritOrientation(swigCPtr, inherit);
2770             if (NDalicPINVOKE.SWIGPendingException.Pending)
2771                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2772         }
2773
2774         internal bool IsOrientationInherited()
2775         {
2776             bool ret = NDalicPINVOKE.Actor_IsOrientationInherited(swigCPtr);
2777             if (NDalicPINVOKE.SWIGPendingException.Pending)
2778                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2779             return ret;
2780         }
2781
2782         internal Rotation GetCurrentWorldOrientation()
2783         {
2784             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentWorldOrientation(swigCPtr), true);
2785             if (NDalicPINVOKE.SWIGPendingException.Pending)
2786                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2787             return ret;
2788         }
2789
2790         internal void SetScale(float scale)
2791         {
2792             NDalicPINVOKE.Actor_SetScale__SWIG_0(swigCPtr, scale);
2793             if (NDalicPINVOKE.SWIGPendingException.Pending)
2794                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2795         }
2796
2797         internal void SetScale(float scaleX, float scaleY, float scaleZ)
2798         {
2799             NDalicPINVOKE.Actor_SetScale__SWIG_1(swigCPtr, scaleX, scaleY, scaleZ);
2800             if (NDalicPINVOKE.SWIGPendingException.Pending)
2801                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2802         }
2803
2804         internal void SetScale(Vector3 scale)
2805         {
2806             NDalicPINVOKE.Actor_SetScale__SWIG_2(swigCPtr, Vector3.getCPtr(scale));
2807             if (NDalicPINVOKE.SWIGPendingException.Pending)
2808                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2809         }
2810
2811         internal void ScaleBy(Vector3 relativeScale)
2812         {
2813             NDalicPINVOKE.Actor_ScaleBy(swigCPtr, Vector3.getCPtr(relativeScale));
2814             if (NDalicPINVOKE.SWIGPendingException.Pending)
2815                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2816         }
2817
2818         internal Vector3 GetCurrentScale()
2819         {
2820             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentScale(swigCPtr), true);
2821             if (NDalicPINVOKE.SWIGPendingException.Pending)
2822                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2823             return ret;
2824         }
2825
2826         internal Vector3 GetCurrentWorldScale()
2827         {
2828             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldScale(swigCPtr), true);
2829             if (NDalicPINVOKE.SWIGPendingException.Pending)
2830                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2831             return ret;
2832         }
2833
2834         internal void SetInheritScale(bool inherit)
2835         {
2836             NDalicPINVOKE.Actor_SetInheritScale(swigCPtr, inherit);
2837             if (NDalicPINVOKE.SWIGPendingException.Pending)
2838                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2839         }
2840
2841         internal bool IsScaleInherited()
2842         {
2843             bool ret = NDalicPINVOKE.Actor_IsScaleInherited(swigCPtr);
2844             if (NDalicPINVOKE.SWIGPendingException.Pending)
2845                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2846             return ret;
2847         }
2848
2849         internal Matrix GetCurrentWorldMatrix()
2850         {
2851             Matrix ret = new Matrix(NDalicPINVOKE.Actor_GetCurrentWorldMatrix(swigCPtr), true);
2852             if (NDalicPINVOKE.SWIGPendingException.Pending)
2853                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2854             return ret;
2855         }
2856
2857         internal void SetVisible(bool visible)
2858         {
2859             NDalicPINVOKE.Actor_SetVisible(swigCPtr, visible);
2860             if (NDalicPINVOKE.SWIGPendingException.Pending)
2861                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2862         }
2863
2864         internal bool IsVisible()
2865         {
2866             bool ret = NDalicPINVOKE.Actor_IsVisible(swigCPtr);
2867             if (NDalicPINVOKE.SWIGPendingException.Pending)
2868                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2869             return ret;
2870         }
2871
2872         internal void SetOpacity(float opacity)
2873         {
2874             NDalicPINVOKE.Actor_SetOpacity(swigCPtr, opacity);
2875             if (NDalicPINVOKE.SWIGPendingException.Pending)
2876                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2877         }
2878
2879         internal float GetCurrentOpacity()
2880         {
2881             float ret = NDalicPINVOKE.Actor_GetCurrentOpacity(swigCPtr);
2882             if (NDalicPINVOKE.SWIGPendingException.Pending)
2883                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2884             return ret;
2885         }
2886
2887         internal void SetColor(Vector4 color)
2888         {
2889             NDalicPINVOKE.Actor_SetColor(swigCPtr, Vector4.getCPtr(color));
2890             if (NDalicPINVOKE.SWIGPendingException.Pending)
2891                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2892         }
2893
2894         internal Vector4 GetCurrentColor()
2895         {
2896             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentColor(swigCPtr), true);
2897             if (NDalicPINVOKE.SWIGPendingException.Pending)
2898                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2899             return ret;
2900         }
2901
2902         internal void SetColorMode(ColorMode colorMode)
2903         {
2904             NDalicPINVOKE.Actor_SetColorMode(swigCPtr, (int)colorMode);
2905             if (NDalicPINVOKE.SWIGPendingException.Pending)
2906                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2907         }
2908
2909         internal ColorMode GetColorMode()
2910         {
2911             ColorMode ret = (ColorMode)NDalicPINVOKE.Actor_GetColorMode(swigCPtr);
2912             if (NDalicPINVOKE.SWIGPendingException.Pending)
2913                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2914             return ret;
2915         }
2916
2917         internal Vector4 GetCurrentWorldColor()
2918         {
2919             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentWorldColor(swigCPtr), true);
2920             if (NDalicPINVOKE.SWIGPendingException.Pending)
2921                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2922             return ret;
2923         }
2924
2925         internal void SetDrawMode(DrawModeType drawMode)
2926         {
2927             NDalicPINVOKE.Actor_SetDrawMode(swigCPtr, (int)drawMode);
2928             if (NDalicPINVOKE.SWIGPendingException.Pending)
2929                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2930         }
2931
2932         internal DrawModeType GetDrawMode()
2933         {
2934             DrawModeType ret = (DrawModeType)NDalicPINVOKE.Actor_GetDrawMode(swigCPtr);
2935             if (NDalicPINVOKE.SWIGPendingException.Pending)
2936                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2937             return ret;
2938         }
2939
2940         /// <summary>
2941         /// Converts screen coordinates into the view's coordinate system using the default camera.
2942         /// </summary>
2943         /// <pre>The view has been initialized.</pre>
2944         /// <remarks>The view coordinates are relative to the top-left(0.0, 0.0, 0.5).</remarks>
2945         /// <param name="localX">On return, the X-coordinate relative to the view.</param>
2946         /// <param name="localY">On return, the Y-coordinate relative to the view.</param>
2947         /// <param name="screenX">The screen X-coordinate.</param>
2948         /// <param name="screenY">The screen Y-coordinate.</param>
2949         /// <returns>True if the conversion succeeded.</returns>
2950         /// <since_tizen> 3 </since_tizen>
2951         public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY)
2952         {
2953             bool ret = NDalicPINVOKE.Actor_ScreenToLocal(swigCPtr, out localX, out localY, screenX, screenY);
2954             if (NDalicPINVOKE.SWIGPendingException.Pending)
2955                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2956             return ret;
2957         }
2958
2959         internal void SetKeyboardFocusable(bool focusable)
2960         {
2961             NDalicPINVOKE.Actor_SetKeyboardFocusable(swigCPtr, focusable);
2962             if (NDalicPINVOKE.SWIGPendingException.Pending)
2963                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2964         }
2965
2966         internal bool IsKeyboardFocusable()
2967         {
2968             bool ret = NDalicPINVOKE.Actor_IsKeyboardFocusable(swigCPtr);
2969             if (NDalicPINVOKE.SWIGPendingException.Pending)
2970                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2971             return ret;
2972         }
2973
2974         internal void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)
2975         {
2976             NDalicPINVOKE.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
2977             if (NDalicPINVOKE.SWIGPendingException.Pending)
2978                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2979         }
2980
2981         internal ResizePolicyType GetResizePolicy(DimensionType dimension)
2982         {
2983             ResizePolicyType ret = (ResizePolicyType)NDalicPINVOKE.Actor_GetResizePolicy(swigCPtr, (int)dimension);
2984             if (NDalicPINVOKE.SWIGPendingException.Pending)
2985                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2986             return ret;
2987         }
2988
2989         /// <summary>
2990         /// Sets the relative to parent size factor of the view.<br />
2991         /// This factor is only used when ResizePolicy is set to either:
2992         /// ResizePolicy::SIZE_RELATIVE_TO_PARENT or ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT.<br />
2993         /// This view's size is set to the view's size multiplied by or added to this factor, depending on ResizePolicy.<br />
2994         /// </summary>
2995         /// <pre>The view has been initialized.</pre>
2996         /// <param name="factor">A Vector3 representing the relative factor to be applied to each axis.</param>
2997         /// <since_tizen> 3 </since_tizen>
2998         public void SetSizeModeFactor(Vector3 factor)
2999         {
3000             NDalicPINVOKE.Actor_SetSizeModeFactor(swigCPtr, Vector3.getCPtr(factor));
3001             if (NDalicPINVOKE.SWIGPendingException.Pending)
3002                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3003         }
3004
3005         internal Vector3 GetSizeModeFactor()
3006         {
3007             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetSizeModeFactor(swigCPtr), true);
3008             if (NDalicPINVOKE.SWIGPendingException.Pending)
3009                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3010             return ret;
3011         }
3012
3013         /// <summary>
3014         /// Calculates the height of the view given a width.<br />
3015         /// The natural size is used for default calculation.<br />
3016         /// Size 0 is treated as aspect ratio 1:1.<br />
3017         /// </summary>
3018         /// <param name="width">The width to use.</param>
3019         /// <returns>The height based on the width.</returns>
3020         /// <since_tizen> 3 </since_tizen>
3021         public float GetHeightForWidth(float width)
3022         {
3023             float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);
3024             if (NDalicPINVOKE.SWIGPendingException.Pending)
3025                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3026             return ret;
3027         }
3028
3029         /// <summary>
3030         /// Calculates the width of the view given a height.<br />
3031         /// The natural size is used for default calculation.<br />
3032         /// Size 0 is treated as aspect ratio 1:1.<br />
3033         /// </summary>
3034         /// <param name="height">The height to use.</param>
3035         /// <returns>The width based on the height.</returns>
3036         /// <since_tizen> 3 </since_tizen>
3037         public float GetWidthForHeight(float height)
3038         {
3039             float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);
3040             if (NDalicPINVOKE.SWIGPendingException.Pending)
3041                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3042             return ret;
3043         }
3044
3045         /// <summary>
3046         /// Return the amount of size allocated for relayout.
3047         /// </summary>
3048         /// <param name="dimension">The dimension to retrieve.</param>
3049         /// <returns>Return the size.</returns>
3050         /// <since_tizen> 3 </since_tizen>
3051         public float GetRelayoutSize(DimensionType dimension)
3052         {
3053             float ret = NDalicPINVOKE.Actor_GetRelayoutSize(swigCPtr, (int)dimension);
3054             if (NDalicPINVOKE.SWIGPendingException.Pending)
3055                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3056             return ret;
3057         }
3058
3059         /// <summary>
3060         /// Set the padding for the view.
3061         /// </summary>
3062         /// <param name="padding">Padding for the view.</param>
3063         /// <since_tizen> 3 </since_tizen>
3064         public void SetPadding(PaddingType padding)
3065         {
3066             NDalicPINVOKE.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));
3067             if (NDalicPINVOKE.SWIGPendingException.Pending)
3068                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3069         }
3070
3071         /// <summary>
3072         /// Return the value of padding for the view.
3073         /// </summary>
3074         /// <param name="paddingOut">the value of padding for the view</param>
3075         /// <since_tizen> 3 </since_tizen>
3076         public void GetPadding(PaddingType paddingOut)
3077         {
3078             NDalicPINVOKE.Actor_GetPadding(swigCPtr, PaddingType.getCPtr(paddingOut));
3079             if (NDalicPINVOKE.SWIGPendingException.Pending)
3080                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3081         }
3082
3083         internal void SetMinimumSize(Vector2 size)
3084         {
3085             NDalicPINVOKE.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));
3086             if (NDalicPINVOKE.SWIGPendingException.Pending)
3087                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3088         }
3089
3090         internal Vector2 GetMinimumSize()
3091         {
3092             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMinimumSize(swigCPtr), true);
3093             if (NDalicPINVOKE.SWIGPendingException.Pending)
3094                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3095             return ret;
3096         }
3097
3098         internal void SetMaximumSize(Vector2 size)
3099         {
3100             NDalicPINVOKE.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));
3101             if (NDalicPINVOKE.SWIGPendingException.Pending)
3102                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3103         }
3104
3105         internal Vector2 GetMaximumSize()
3106         {
3107             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMaximumSize(swigCPtr), true);
3108             if (NDalicPINVOKE.SWIGPendingException.Pending)
3109                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3110             return ret;
3111         }
3112
3113         internal int GetHierarchyDepth()
3114         {
3115             int ret = NDalicPINVOKE.Actor_GetHierarchyDepth(swigCPtr);
3116             if (NDalicPINVOKE.SWIGPendingException.Pending)
3117                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3118             return ret;
3119         }
3120
3121         /// <since_tizen> 4 </since_tizen>
3122         public uint AddRenderer(Renderer renderer)
3123         {
3124             uint ret = NDalicPINVOKE.Actor_AddRenderer(swigCPtr, Renderer.getCPtr(renderer));
3125             if (NDalicPINVOKE.SWIGPendingException.Pending)
3126                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3127             return ret;
3128         }
3129
3130         internal uint GetRendererCount()
3131         {
3132             uint ret = NDalicPINVOKE.Actor_GetRendererCount(swigCPtr);
3133             if (NDalicPINVOKE.SWIGPendingException.Pending)
3134                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3135             return ret;
3136         }
3137
3138         /// <since_tizen> 4 </since_tizen>
3139         public Renderer GetRendererAt(uint index)
3140         {
3141             IntPtr cPtr = NDalicPINVOKE.Actor_GetRendererAt(swigCPtr, index);
3142             Renderer ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as Renderer;
3143
3144             if (NDalicPINVOKE.SWIGPendingException.Pending)
3145                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3146             return ret;
3147         }
3148
3149         /// <since_tizen> 4 </since_tizen>
3150         public void RemoveRenderer(Renderer renderer)
3151         {
3152             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_0(swigCPtr, Renderer.getCPtr(renderer));
3153             if (NDalicPINVOKE.SWIGPendingException.Pending)
3154                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3155         }
3156
3157         /// <since_tizen> 4 </since_tizen>
3158         public void RemoveRenderer(uint index)
3159         {
3160             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_1(swigCPtr, index);
3161             if (NDalicPINVOKE.SWIGPendingException.Pending)
3162                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3163         }
3164
3165         internal TouchDataSignal TouchSignal()
3166         {
3167             TouchDataSignal ret = new TouchDataSignal(NDalicPINVOKE.Actor_TouchSignal(swigCPtr), false);
3168             if (NDalicPINVOKE.SWIGPendingException.Pending)
3169                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3170             return ret;
3171         }
3172
3173         internal HoverSignal HoveredSignal()
3174         {
3175             HoverSignal ret = new HoverSignal(NDalicPINVOKE.Actor_HoveredSignal(swigCPtr), false);
3176             if (NDalicPINVOKE.SWIGPendingException.Pending)
3177                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3178             return ret;
3179         }
3180
3181         internal WheelSignal WheelEventSignal()
3182         {
3183             WheelSignal ret = new WheelSignal(NDalicPINVOKE.Actor_WheelEventSignal(swigCPtr), false);
3184             if (NDalicPINVOKE.SWIGPendingException.Pending)
3185                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3186             return ret;
3187         }
3188
3189         internal ViewSignal OnWindowSignal()
3190         {
3191             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnStageSignal(swigCPtr), false);
3192             if (NDalicPINVOKE.SWIGPendingException.Pending)
3193                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3194             return ret;
3195         }
3196
3197         internal ViewSignal OffWindowSignal()
3198         {
3199             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OffStageSignal(swigCPtr), false);
3200             if (NDalicPINVOKE.SWIGPendingException.Pending)
3201                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3202             return ret;
3203         }
3204
3205         internal ViewSignal OnRelayoutSignal()
3206         {
3207             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnRelayoutSignal(swigCPtr), false);
3208             if (NDalicPINVOKE.SWIGPendingException.Pending)
3209                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3210             return ret;
3211         }
3212
3213         internal ViewVisibilityChangedSignal VisibilityChangedSignal(View view) {
3214             ViewVisibilityChangedSignal ret = new ViewVisibilityChangedSignal(NDalicPINVOKE.VisibilityChangedSignal(View.getCPtr(view)), false);
3215             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3216             return ret;
3217         }
3218
3219
3220         internal ViewLayoutDirectionChangedSignal LayoutDirectionChangedSignal(View view) {
3221             ViewLayoutDirectionChangedSignal ret = new ViewLayoutDirectionChangedSignal(NDalicManualPINVOKE.LayoutDirectionChangedSignal(View.getCPtr(view)), false);
3222             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3223             return ret;
3224         }
3225
3226
3227         internal ViewSignal ResourcesLoadedSignal()
3228         {
3229             ViewSignal ret = new ViewSignal(NDalicPINVOKE.ResourceReadySignal(swigCPtr), false);
3230             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3231             return ret;
3232         }
3233
3234         /// <summary>
3235         /// Gets or sets the origin of a view within its parent's area.<br />
3236         /// 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 />
3237         /// The default parent-origin is ParentOrigin.TopLeft (0.0, 0.0, 0.5).<br />
3238         /// A view's position is the distance between this origin and the view's anchor-point.<br />
3239         /// </summary>
3240         /// <pre>The view has been initialized.</pre>
3241         /// <since_tizen> 3 </since_tizen>
3242         public Position ParentOrigin
3243         {
3244             get
3245             {
3246                 Position temp = new Position(0.0f, 0.0f, 0.0f);
3247                 GetProperty(View.Property.PARENT_ORIGIN).Get(temp);
3248                 return temp;
3249             }
3250             set
3251             {
3252                 SetProperty(View.Property.PARENT_ORIGIN, new Tizen.NUI.PropertyValue(value));
3253             }
3254         }
3255
3256         internal float ParentOriginX
3257         {
3258             get
3259             {
3260                 float temp = 0.0f;
3261                 GetProperty(View.Property.PARENT_ORIGIN_X).Get(out temp);
3262                 return temp;
3263             }
3264             set
3265             {
3266                 SetProperty(View.Property.PARENT_ORIGIN_X, new Tizen.NUI.PropertyValue(value));
3267             }
3268         }
3269
3270         internal float ParentOriginY
3271         {
3272             get
3273             {
3274                 float temp = 0.0f;
3275                 GetProperty(View.Property.PARENT_ORIGIN_Y).Get(out temp);
3276                 return temp;
3277             }
3278             set
3279             {
3280                 SetProperty(View.Property.PARENT_ORIGIN_Y, new Tizen.NUI.PropertyValue(value));
3281             }
3282         }
3283
3284         internal float ParentOriginZ
3285         {
3286             get
3287             {
3288                 float temp = 0.0f;
3289                 GetProperty(View.Property.PARENT_ORIGIN_Z).Get(out temp);
3290                 return temp;
3291             }
3292             set
3293             {
3294                 SetProperty(View.Property.PARENT_ORIGIN_Z, new Tizen.NUI.PropertyValue(value));
3295             }
3296         }
3297
3298         /// <summary>
3299         /// Gets or sets the anchor-point of a view.<br />
3300         /// 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 />
3301         /// The default pivot point is PivotPoint.Center (0.5, 0.5, 0.5).<br />
3302         /// A view position is the distance between its parent-origin and this anchor-point.<br />
3303         /// A view's orientation is the rotation from its default orientation, the rotation is centered around its anchor-point.<br />
3304         /// <pre>The view has been initialized.</pre>
3305         /// </summary>
3306         /// <since_tizen> 3 </since_tizen>
3307         public Position PivotPoint
3308         {
3309             get
3310             {
3311                 Position temp = new Position(0.0f, 0.0f, 0.0f);
3312                 GetProperty(View.Property.ANCHOR_POINT).Get(temp);
3313                 return temp;
3314             }
3315             set
3316             {
3317                 SetProperty(View.Property.ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
3318             }
3319         }
3320
3321         internal float PivotPointX
3322         {
3323             get
3324             {
3325                 float temp = 0.0f;
3326                 GetProperty(View.Property.ANCHOR_POINT_X).Get(out temp);
3327                 return temp;
3328             }
3329             set
3330             {
3331                 SetProperty(View.Property.ANCHOR_POINT_X, new Tizen.NUI.PropertyValue(value));
3332             }
3333         }
3334
3335         internal float PivotPointY
3336         {
3337             get
3338             {
3339                 float temp = 0.0f;
3340                 GetProperty(View.Property.ANCHOR_POINT_Y).Get(out temp);
3341                 return temp;
3342             }
3343             set
3344             {
3345                 SetProperty(View.Property.ANCHOR_POINT_Y, new Tizen.NUI.PropertyValue(value));
3346             }
3347         }
3348
3349         internal float PivotPointZ
3350         {
3351             get
3352             {
3353                 float temp = 0.0f;
3354                 GetProperty(View.Property.ANCHOR_POINT_Z).Get(out temp);
3355                 return temp;
3356             }
3357             set
3358             {
3359                 SetProperty(View.Property.ANCHOR_POINT_Z, new Tizen.NUI.PropertyValue(value));
3360             }
3361         }
3362
3363         /// <summary>
3364         /// Gets or sets the size width of the view.
3365         /// </summary>
3366         /// <since_tizen> 3 </since_tizen>
3367         public float SizeWidth
3368         {
3369             get
3370             {
3371                 float temp = 0.0f;
3372                 GetProperty(View.Property.SIZE_WIDTH).Get(out temp);
3373                 return temp;
3374             }
3375             set
3376             {
3377                 SetProperty(View.Property.SIZE_WIDTH, new Tizen.NUI.PropertyValue(value));
3378             }
3379         }
3380
3381         /// <summary>
3382         /// Gets or sets the size height of the view.
3383         /// </summary>
3384         /// <since_tizen> 3 </since_tizen>
3385         public float SizeHeight
3386         {
3387             get
3388             {
3389                 float temp = 0.0f;
3390                 GetProperty(View.Property.SIZE_HEIGHT).Get(out temp);
3391                 return temp;
3392             }
3393             set
3394             {
3395                 SetProperty(View.Property.SIZE_HEIGHT, new Tizen.NUI.PropertyValue(value));
3396             }
3397         }
3398
3399         /// <summary>
3400         /// Gets or sets the position of the view.<br />
3401         /// By default, sets the position vector between the parent origin and pivot point (default).<br />
3402         /// If the position inheritance is disabled, sets the world position.<br />
3403         /// </summary>
3404         /// <since_tizen> 3 </since_tizen>
3405         public Position Position
3406         {
3407             get
3408             {
3409                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3410                 GetProperty(View.Property.POSITION).Get(temp);
3411                 return temp;
3412             }
3413             set
3414             {
3415                 SetProperty(View.Property.POSITION, new Tizen.NUI.PropertyValue(value));
3416             }
3417         }
3418
3419         /// <summary>
3420         /// Gets or sets the position X of the view.
3421         /// </summary>
3422         /// <since_tizen> 3 </since_tizen>
3423         public float PositionX
3424         {
3425             get
3426             {
3427                 float temp = 0.0f;
3428                 GetProperty(View.Property.POSITION_X).Get(out temp);
3429                 return temp;
3430             }
3431             set
3432             {
3433                 SetProperty(View.Property.POSITION_X, new Tizen.NUI.PropertyValue(value));
3434             }
3435         }
3436
3437         /// <summary>
3438         /// Gets or sets the position Y of the view.
3439         /// </summary>
3440         /// <since_tizen> 3 </since_tizen>
3441         public float PositionY
3442         {
3443             get
3444             {
3445                 float temp = 0.0f;
3446                 GetProperty(View.Property.POSITION_Y).Get(out temp);
3447                 return temp;
3448             }
3449             set
3450             {
3451                 SetProperty(View.Property.POSITION_Y, new Tizen.NUI.PropertyValue(value));
3452             }
3453         }
3454
3455         /// <summary>
3456         /// Gets or sets the position Z of the view.
3457         /// </summary>
3458         /// <since_tizen> 3 </since_tizen>
3459         public float PositionZ
3460         {
3461             get
3462             {
3463                 float temp = 0.0f;
3464                 GetProperty(View.Property.POSITION_Z).Get(out temp);
3465                 return temp;
3466             }
3467             set
3468             {
3469                 SetProperty(View.Property.POSITION_Z, new Tizen.NUI.PropertyValue(value));
3470             }
3471         }
3472
3473         /// <summary>
3474         /// Gets or sets the world position of the view.
3475         /// </summary>
3476         /// <since_tizen> 3 </since_tizen>
3477         public Vector3 WorldPosition
3478         {
3479             get
3480             {
3481                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3482                 GetProperty(View.Property.WORLD_POSITION).Get(temp);
3483                 return temp;
3484             }
3485         }
3486
3487         internal float WorldPositionX
3488         {
3489             get
3490             {
3491                 float temp = 0.0f;
3492                 GetProperty(View.Property.WORLD_POSITION_X).Get(out temp);
3493                 return temp;
3494             }
3495         }
3496
3497         internal float WorldPositionY
3498         {
3499             get
3500             {
3501                 float temp = 0.0f;
3502                 GetProperty(View.Property.WORLD_POSITION_Y).Get(out temp);
3503                 return temp;
3504             }
3505         }
3506
3507         internal float WorldPositionZ
3508         {
3509             get
3510             {
3511                 float temp = 0.0f;
3512                 GetProperty(View.Property.WORLD_POSITION_Z).Get(out temp);
3513                 return temp;
3514             }
3515         }
3516
3517         /// <summary>
3518         /// Gets or sets the orientation of the view.<br />
3519         /// The view's orientation is the rotation from its default orientation, and the rotation is centered around its anchor-point.<br />
3520         /// </summary>
3521         /// <remarks>This is an asynchronous method.</remarks>
3522         /// <since_tizen> 3 </since_tizen>
3523         public Rotation Orientation
3524         {
3525             get
3526             {
3527                 Rotation temp = new Rotation();
3528                 GetProperty(View.Property.ORIENTATION).Get(temp);
3529                 return temp;
3530             }
3531             set
3532             {
3533                 SetProperty(View.Property.ORIENTATION, new Tizen.NUI.PropertyValue(value));
3534             }
3535         }
3536
3537         /// <summary>
3538         /// Gets or sets the world orientation of the view.<br />
3539         /// </summary>
3540         /// <since_tizen> 3 </since_tizen>
3541         public Rotation WorldOrientation
3542         {
3543             get
3544             {
3545                 Rotation temp = new Rotation();
3546                 GetProperty(View.Property.WORLD_ORIENTATION).Get(temp);
3547                 return temp;
3548             }
3549         }
3550
3551         /// <summary>
3552         /// Gets or sets the scale factor applied to the view.<br />
3553         /// </summary>
3554         /// <since_tizen> 3 </since_tizen>
3555         public Vector3 Scale
3556         {
3557             get
3558             {
3559                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3560                 GetProperty(View.Property.SCALE).Get(temp);
3561                 return temp;
3562             }
3563             set
3564             {
3565                 SetProperty(View.Property.SCALE, new Tizen.NUI.PropertyValue(value));
3566             }
3567         }
3568
3569         /// <summary>
3570         /// Gets or sets the scale X factor applied to the view.
3571         /// </summary>
3572         /// <since_tizen> 3 </since_tizen>
3573         public float ScaleX
3574         {
3575             get
3576             {
3577                 float temp = 0.0f;
3578                 GetProperty(View.Property.SCALE_X).Get(out temp);
3579                 return temp;
3580             }
3581             set
3582             {
3583                 SetProperty(View.Property.SCALE_X, new Tizen.NUI.PropertyValue(value));
3584             }
3585         }
3586
3587         /// <summary>
3588         /// Gets or sets the scale Y factor applied to the view.
3589         /// </summary>
3590         /// <since_tizen> 3 </since_tizen>
3591         public float ScaleY
3592         {
3593             get
3594             {
3595                 float temp = 0.0f;
3596                 GetProperty(View.Property.SCALE_Y).Get(out temp);
3597                 return temp;
3598             }
3599             set
3600             {
3601                 SetProperty(View.Property.SCALE_Y, new Tizen.NUI.PropertyValue(value));
3602             }
3603         }
3604
3605         /// <summary>
3606         /// Gets or sets the scale Z factor applied to the view.
3607         /// </summary>
3608         /// <since_tizen> 3 </since_tizen>
3609         public float ScaleZ
3610         {
3611             get
3612             {
3613                 float temp = 0.0f;
3614                 GetProperty(View.Property.SCALE_Z).Get(out temp);
3615                 return temp;
3616             }
3617             set
3618             {
3619                 SetProperty(View.Property.SCALE_Z, new Tizen.NUI.PropertyValue(value));
3620             }
3621         }
3622
3623         /// <summary>
3624         /// Gets the world scale of the view.
3625         /// </summary>
3626         /// <since_tizen> 3 </since_tizen>
3627         public Vector3 WorldScale
3628         {
3629             get
3630             {
3631                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3632                 GetProperty(View.Property.WORLD_SCALE).Get(temp);
3633                 return temp;
3634             }
3635         }
3636
3637         /// <summary>
3638         /// Retrieves the visibility flag of the view.
3639         /// </summary>
3640         /// <remarks>
3641         /// If the view is not visible, then the view and its children will not be rendered.
3642         /// 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.
3643         /// </remarks>
3644         /// <since_tizen> 3 </since_tizen>
3645         public bool Visibility
3646         {
3647             get
3648             {
3649                 bool temp = false;
3650                 GetProperty(View.Property.VISIBLE).Get(out temp);
3651                 return temp;
3652             }
3653         }
3654
3655         /// <summary>
3656         /// Gets the view's world color.
3657         /// </summary>
3658         /// <since_tizen> 3 </since_tizen>
3659         public Vector4 WorldColor
3660         {
3661             get
3662             {
3663                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
3664                 GetProperty(View.Property.WORLD_COLOR).Get(temp);
3665                 return temp;
3666             }
3667         }
3668
3669         internal Matrix WorldMatrix
3670         {
3671             get
3672             {
3673                 Matrix temp = new Matrix();
3674                 GetProperty(View.Property.WORLD_MATRIX).Get(temp);
3675                 return temp;
3676             }
3677         }
3678
3679         /// <summary>
3680         /// Gets or sets the view's name.
3681         /// </summary>
3682         /// <since_tizen> 3 </since_tizen>
3683         public string Name
3684         {
3685             get
3686             {
3687                 string temp;
3688                 GetProperty(View.Property.NAME).Get(out temp);
3689                 return temp;
3690             }
3691             set
3692             {
3693                 SetProperty(View.Property.NAME, new Tizen.NUI.PropertyValue(value));
3694             }
3695         }
3696
3697         /// <summary>
3698         /// Get the number of children held by the view.
3699         /// </summary>
3700         /// <since_tizen> 3 </since_tizen>
3701         public new uint ChildCount
3702         {
3703             get
3704             {
3705                 return GetChildCount();
3706             }
3707         }
3708
3709         /// <summary>
3710         /// Gets the view's ID.
3711         /// Readonly
3712         /// </summary>
3713         /// <since_tizen> 3 </since_tizen>
3714         public uint ID
3715         {
3716             get
3717             {
3718                 return GetId();
3719             }
3720         }
3721
3722         /// <summary>
3723         /// Gets or sets the status of whether the view should emit touch or hover signals.
3724         /// </summary>
3725         /// <since_tizen> 3 </since_tizen>
3726         public bool Sensitive
3727         {
3728             get
3729             {
3730                 bool temp = false;
3731                 GetProperty(View.Property.SENSITIVE).Get(out temp);
3732                 return temp;
3733             }
3734             set
3735             {
3736                 SetProperty(View.Property.SENSITIVE, new Tizen.NUI.PropertyValue(value));
3737             }
3738         }
3739
3740         /// <summary>
3741         /// 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.
3742         /// </summary>
3743         /// <since_tizen> 3 </since_tizen>
3744         public bool LeaveRequired
3745         {
3746             get
3747             {
3748                 bool temp = false;
3749                 GetProperty(View.Property.LEAVE_REQUIRED).Get(out temp);
3750                 return temp;
3751             }
3752             set
3753             {
3754                 SetProperty(View.Property.LEAVE_REQUIRED, new Tizen.NUI.PropertyValue(value));
3755             }
3756         }
3757
3758         /// <summary>
3759         /// Gets or sets the status of whether a child view inherits it's parent's orientation.
3760         /// </summary>
3761         /// <since_tizen> 3 </since_tizen>
3762         public bool InheritOrientation
3763         {
3764             get
3765             {
3766                 bool temp = false;
3767                 GetProperty(View.Property.INHERIT_ORIENTATION).Get(out temp);
3768                 return temp;
3769             }
3770             set
3771             {
3772                 SetProperty(View.Property.INHERIT_ORIENTATION, new Tizen.NUI.PropertyValue(value));
3773             }
3774         }
3775
3776         /// <summary>
3777         /// Gets or sets the status of whether a child view inherits it's parent's scale.
3778         /// </summary>
3779         /// <since_tizen> 3 </since_tizen>
3780         public bool InheritScale
3781         {
3782             get
3783             {
3784                 bool temp = false;
3785                 GetProperty(View.Property.INHERIT_SCALE).Get(out temp);
3786                 return temp;
3787             }
3788             set
3789             {
3790                 SetProperty(View.Property.INHERIT_SCALE, new Tizen.NUI.PropertyValue(value));
3791             }
3792         }
3793
3794         /// <summary>
3795         /// Gets or sets the status of how the view and its children should be drawn.<br />
3796         /// Not all views are renderable, but DrawMode can be inherited from any view.<br />
3797         /// 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 />
3798         /// If DrawMode.Overlay2D is used, the view and its children will be drawn as a 2D overlay.<br />
3799         /// Overlay views are drawn in a separate pass, after all non-overlay views within the layer.<br />
3800         /// For overlay views, the drawing order is with respect to tree levels of views, and depth-testing will not be used.<br />
3801         /// </summary>
3802         /// <since_tizen> 3 </since_tizen>
3803         public DrawModeType DrawMode
3804         {
3805             get
3806             {
3807                 string temp;
3808                 if (GetProperty(View.Property.DRAW_MODE).Get(out temp) == false)
3809                 {
3810                     NUILog.Error("DrawMode get error!");
3811                 }
3812                 switch (temp)
3813                 {
3814                     case "NORMAL":
3815                     return DrawModeType.Normal;
3816                     case "OVERLAY_2D":
3817                     return DrawModeType.Overlay2D;
3818                     case "STENCIL":
3819                     return DrawModeType.Stencil;
3820                     default:
3821                     return DrawModeType.Normal;
3822                 }
3823             }
3824             set
3825             {
3826                 SetProperty(View.Property.DRAW_MODE, new Tizen.NUI.PropertyValue((int)value));
3827             }
3828         }
3829
3830         /// <summary>
3831         /// Gets or sets the relative to parent size factor of the view.<br />
3832         /// This factor is only used when ResizePolicyType is set to either: ResizePolicyType.SizeRelativeToParent or ResizePolicyType.SizeFixedOffsetFromParent.<br />
3833         /// This view's size is set to the view's size multiplied by or added to this factor, depending on ResizePolicyType.<br />
3834         /// </summary>
3835         /// <since_tizen> 3 </since_tizen>
3836         public Vector3 SizeModeFactor
3837         {
3838             get
3839             {
3840                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3841                 GetProperty(View.Property.SIZE_MODE_FACTOR).Get(temp);
3842                 return temp;
3843             }
3844             set
3845             {
3846                 SetProperty(View.Property.SIZE_MODE_FACTOR, new Tizen.NUI.PropertyValue(value));
3847             }
3848         }
3849
3850         /// <summary>
3851         /// Gets or sets the width resize policy to be used.
3852         /// </summary>
3853         /// <since_tizen> 3 </since_tizen>
3854         public ResizePolicyType WidthResizePolicy
3855         {
3856             get
3857             {
3858                 string temp;
3859                 if (GetProperty(View.Property.WIDTH_RESIZE_POLICY).Get(out temp) == false)
3860                 {
3861                     NUILog.Error("WidthResizePolicy get error!");
3862                 }
3863                 switch (temp)
3864                 {
3865                     case "FIXED":
3866                         return ResizePolicyType.Fixed;
3867                     case "USE_NATURAL_SIZE":
3868                         return ResizePolicyType.UseNaturalSize;
3869                     case "FILL_TO_PARENT":
3870                         return ResizePolicyType.FillToParent;
3871                     case "SIZE_RELATIVE_TO_PARENT":
3872                         return ResizePolicyType.SizeRelativeToParent;
3873                     case "SIZE_FIXED_OFFSET_FROM_PARENT":
3874                         return ResizePolicyType.SizeFixedOffsetFromParent;
3875                     case "FIT_TO_CHILDREN":
3876                         return ResizePolicyType.FitToChildren;
3877                     case "DIMENSION_DEPENDENCY":
3878                         return ResizePolicyType.DimensionDependency;
3879                     case "USE_ASSIGNED_SIZE":
3880                         return ResizePolicyType.UseAssignedSize;
3881                     default:
3882                         return ResizePolicyType.Fixed;
3883                 }
3884             }
3885             set
3886             {
3887                 SetProperty(View.Property.WIDTH_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));
3888             }
3889         }
3890
3891         /// <summary>
3892         /// Gets or sets the height resize policy to be used.
3893         /// </summary>
3894         /// <since_tizen> 3 </since_tizen>
3895         public ResizePolicyType HeightResizePolicy
3896         {
3897             get
3898             {
3899                 string temp;
3900                 if (GetProperty(View.Property.HEIGHT_RESIZE_POLICY).Get(out temp) == false)
3901                 {
3902                     NUILog.Error("HeightResizePolicy get error!");
3903                 }
3904                 switch (temp)
3905                 {
3906                     case "FIXED":
3907                         return ResizePolicyType.Fixed;
3908                     case "USE_NATURAL_SIZE":
3909                         return ResizePolicyType.UseNaturalSize;
3910                     case "FILL_TO_PARENT":
3911                         return ResizePolicyType.FillToParent;
3912                     case "SIZE_RELATIVE_TO_PARENT":
3913                         return ResizePolicyType.SizeRelativeToParent;
3914                     case "SIZE_FIXED_OFFSET_FROM_PARENT":
3915                         return ResizePolicyType.SizeFixedOffsetFromParent;
3916                     case "FIT_TO_CHILDREN":
3917                         return ResizePolicyType.FitToChildren;
3918                     case "DIMENSION_DEPENDENCY":
3919                         return ResizePolicyType.DimensionDependency;
3920                     case "USE_ASSIGNED_SIZE":
3921                         return ResizePolicyType.UseAssignedSize;
3922                     default:
3923                         return ResizePolicyType.Fixed;
3924                 }
3925             }
3926             set
3927             {
3928                 SetProperty(View.Property.HEIGHT_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));
3929             }
3930         }
3931
3932         /// <summary>
3933         /// Gets or sets the policy to use when setting size with size negotiation.<br />
3934         /// Defaults to SizeScalePolicyType.UseSizeSet.<br />
3935         /// </summary>
3936         /// <since_tizen> 3 </since_tizen>
3937         public SizeScalePolicyType SizeScalePolicy
3938         {
3939             get
3940             {
3941                 string temp;
3942                 if (GetProperty(View.Property.SIZE_SCALE_POLICY).Get(out temp) == false)
3943                 {
3944                     NUILog.Error("SizeScalePolicy get error!");
3945                 }
3946                 switch (temp)
3947                 {
3948                     case "USE_SIZE_SET":
3949                         return SizeScalePolicyType.UseSizeSet;
3950                     case "FIT_WITH_ASPECT_RATIO":
3951                         return SizeScalePolicyType.FitWithAspectRatio;
3952                     case "FILL_WITH_ASPECT_RATIO":
3953                         return SizeScalePolicyType.FillWithAspectRatio;
3954                     default:
3955                         return SizeScalePolicyType.UseSizeSet;
3956                 }
3957             }
3958             set
3959             {
3960                 string valueToString = "";
3961                 switch (value)
3962                 {
3963                     case SizeScalePolicyType.UseSizeSet:
3964                         {
3965                             valueToString = "USE_SIZE_SET";
3966                             break;
3967                         }
3968                     case SizeScalePolicyType.FitWithAspectRatio:
3969                         {
3970                             valueToString = "FIT_WITH_ASPECT_RATIO";
3971                             break;
3972                         }
3973                     case SizeScalePolicyType.FillWithAspectRatio:
3974                         {
3975                             valueToString = "FILL_WITH_ASPECT_RATIO";
3976                             break;
3977                         }
3978                     default:
3979                         {
3980                             valueToString = "USE_SIZE_SET";
3981                             break;
3982                         }
3983                 }
3984                 SetProperty(View.Property.SIZE_SCALE_POLICY, new Tizen.NUI.PropertyValue(valueToString));
3985             }
3986         }
3987
3988         /// <summary>
3989         ///  Gets or sets the status of whether the width size is dependent on the height size.
3990         /// </summary>
3991         /// <since_tizen> 3 </since_tizen>
3992         public bool WidthForHeight
3993         {
3994             get
3995             {
3996                 bool temp = false;
3997                 GetProperty(View.Property.WIDTH_FOR_HEIGHT).Get(out temp);
3998                 return temp;
3999             }
4000             set
4001             {
4002                 SetProperty(View.Property.WIDTH_FOR_HEIGHT, new Tizen.NUI.PropertyValue(value));
4003             }
4004         }
4005
4006         /// <summary>
4007         /// Gets or sets the status of whether the height size is dependent on the width size.
4008         /// </summary>
4009         /// <since_tizen> 3 </since_tizen>
4010         public bool HeightForWidth
4011         {
4012             get
4013             {
4014                 bool temp = false;
4015                 GetProperty(View.Property.HEIGHT_FOR_WIDTH).Get(out temp);
4016                 return temp;
4017             }
4018             set
4019             {
4020                 SetProperty(View.Property.HEIGHT_FOR_WIDTH, new Tizen.NUI.PropertyValue(value));
4021             }
4022         }
4023
4024         /// <summary>
4025         /// Gets or sets the padding for use in layout.
4026         /// </summary>
4027         /// <since_tizen> 3 </since_tizen>
4028         public Vector4 Padding
4029         {
4030             get
4031             {
4032                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
4033                 GetProperty(View.Property.PADDING).Get(temp);
4034                 return temp;
4035             }
4036             set
4037             {
4038                 SetProperty(View.Property.PADDING, new Tizen.NUI.PropertyValue(value));
4039             }
4040         }
4041
4042         /// <summary>
4043         /// Gets or sets the minimum size the view can be assigned in size negotiation.
4044         /// </summary>
4045         /// <since_tizen> 3 </since_tizen>
4046         public Size2D MinimumSize
4047         {
4048             get
4049             {
4050                 Size2D temp = new Size2D(0, 0);
4051                 GetProperty(View.Property.MINIMUM_SIZE).Get(temp);
4052                 return temp;
4053             }
4054             set
4055             {
4056                 SetProperty(View.Property.MINIMUM_SIZE, new Tizen.NUI.PropertyValue(value));
4057             }
4058         }
4059
4060         /// <summary>
4061         /// Gets or sets the maximum size the view can be assigned in size negotiation.
4062         /// </summary>
4063         /// <since_tizen> 3 </since_tizen>
4064         public Size2D MaximumSize
4065         {
4066             get
4067             {
4068                 Size2D temp = new Size2D(0, 0);
4069                 GetProperty(View.Property.MAXIMUM_SIZE).Get(temp);
4070                 return temp;
4071             }
4072             set
4073             {
4074                 SetProperty(View.Property.MAXIMUM_SIZE, new Tizen.NUI.PropertyValue(value));
4075             }
4076         }
4077
4078         /// <summary>
4079         /// Gets or sets whether a child view inherits it's parent's position.<br />
4080         /// Default is to inherit.<br />
4081         /// 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 />
4082         /// </summary>
4083         /// <since_tizen> 3 </since_tizen>
4084         public bool InheritPosition
4085         {
4086             get
4087             {
4088                 bool temp = false;
4089                 GetProperty(View.Property.INHERIT_POSITION).Get(out temp);
4090                 return temp;
4091             }
4092             set
4093             {
4094                 SetProperty(View.Property.INHERIT_POSITION, new Tizen.NUI.PropertyValue(value));
4095             }
4096         }
4097
4098         /// <summary>
4099         /// Gets or sets the clipping behavior (mode) of it's children.
4100         /// </summary>
4101         /// <since_tizen> 3 </since_tizen>
4102         public ClippingModeType ClippingMode
4103         {
4104             get
4105             {
4106                 string temp;
4107                 if (GetProperty(View.Property.CLIPPING_MODE).Get(out temp) == false)
4108                 {
4109                     NUILog.Error("ClippingMode get error!");
4110                 }
4111                 switch (temp)
4112                 {
4113                     case "DISABLED":
4114                     return ClippingModeType.Disabled;
4115                     case "CLIP_CHILDREN":
4116                     return ClippingModeType.ClipChildren;
4117                     case "CLIP_TO_BOUNDING_BOX":
4118                     return ClippingModeType.ClipToBoundingBox;
4119                     default:
4120                     return ClippingModeType.Disabled;
4121                 }
4122             }
4123             set
4124             {
4125                 SetProperty(View.Property.CLIPPING_MODE, new Tizen.NUI.PropertyValue((int)value));
4126             }
4127         }
4128
4129         /// <summary>
4130         /// Gets the number of renderers held by the view.
4131         /// </summary>
4132         /// <since_tizen> 4 </since_tizen>
4133         public uint RendererCount
4134         {
4135             get
4136             {
4137                 return GetRendererCount();
4138             }
4139         }
4140
4141
4142
4143         /// <summary>
4144         /// [Obsolete("Please do not use! this will be deprecated")]
4145         /// </summary>
4146         /// <since_tizen> 3 </since_tizen>
4147         [Obsolete("Please do not use! this will be deprecated")]
4148         public event EventHandlerWithReturnType<object, TouchEventArgs, bool> Touched
4149         {
4150             add
4151             {
4152                 if (_touchDataEventHandler == null)
4153                 {
4154                     _touchDataCallback = OnTouch;
4155                     this.TouchSignal().Connect(_touchDataCallback);
4156                 }
4157
4158                 _touchDataEventHandler += value;
4159             }
4160
4161             remove
4162             {
4163                 _touchDataEventHandler -= value;
4164
4165                 if (_touchDataEventHandler == null && TouchSignal().Empty() == false)
4166                 {
4167                     this.TouchSignal().Disconnect(_touchDataCallback);
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, HoverEventArgs, bool> Hovered
4179         {
4180             add
4181             {
4182                 if (_hoverEventHandler == null)
4183                 {
4184                     _hoverEventCallback = OnHoverEvent;
4185                     this.HoveredSignal().Connect(_hoverEventCallback);
4186                 }
4187
4188                 _hoverEventHandler += value;
4189             }
4190
4191             remove
4192             {
4193                 _hoverEventHandler -= value;
4194
4195                 if (_hoverEventHandler == null && HoveredSignal().Empty() == false)
4196                 {
4197                     this.HoveredSignal().Disconnect(_hoverEventCallback);
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, WheelEventArgs, bool> WheelMoved
4209         {
4210             add
4211             {
4212                 if (_wheelEventHandler == null)
4213                 {
4214                     _wheelEventCallback = OnWheelEvent;
4215                     this.WheelEventSignal().Connect(_wheelEventCallback);
4216                 }
4217
4218                 _wheelEventHandler += value;
4219             }
4220
4221             remove
4222             {
4223                 _wheelEventHandler -= value;
4224
4225                 if (_wheelEventHandler == null && WheelEventSignal().Empty() == false)
4226                 {
4227                     this.WheelEventSignal().Disconnect(_wheelEventCallback);
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 Position AnchorPoint
4239         {
4240             get
4241             {
4242                 Position temp = new Position(0.0f, 0.0f, 0.0f);
4243                 GetProperty(View.Property.ANCHOR_POINT).Get(temp);
4244                 return temp;
4245             }
4246             set
4247             {
4248                 SetProperty(View.Property.ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
4249             }
4250         }
4251
4252         /// <summary>
4253         /// [Obsolete("Please do not use! this will be deprecated")]
4254         /// </summary>
4255         /// <since_tizen> 3 </since_tizen>
4256         [Obsolete("Please do not use! this will be deprecated, please use Size2D instead")]
4257         public Size Size
4258         {
4259             get
4260             {
4261                 Size temp = new Size(0.0f, 0.0f, 0.0f);
4262                 GetProperty(View.Property.SIZE).Get(temp);
4263                 return temp;
4264             }
4265             set
4266             {
4267                 SetProperty(View.Property.SIZE, new Tizen.NUI.PropertyValue(value));
4268             }
4269         }
4270
4271         /// <summary>
4272         /// [Obsolete("Please do not use! this will be deprecated")]
4273         /// </summary>
4274         /// <since_tizen> 3 </since_tizen>
4275         [Obsolete("Please do not use! this will be deprecated")]
4276         public event EventHandler OnWindowEvent
4277         {
4278             add
4279             {
4280                 if (_onWindowEventHandler == null)
4281                 {
4282                     _onWindowEventCallback = OnWindow;
4283                     this.OnWindowSignal().Connect(_onWindowEventCallback);
4284                 }
4285
4286                 _onWindowEventHandler += value;
4287             }
4288
4289             remove
4290             {
4291                 _onWindowEventHandler -= value;
4292
4293                 if (_onWindowEventHandler == null && OnWindowSignal().Empty() == false)
4294                 {
4295                     this.OnWindowSignal().Disconnect(_onWindowEventCallback);
4296                 }
4297             }
4298         }
4299
4300         /// <summary>
4301         /// [Obsolete("Please do not use! this will be deprecated")]
4302         /// </summary>
4303         /// <since_tizen> 3 </since_tizen>
4304         [Obsolete("Please do not use! this will be deprecated")]
4305         public event EventHandler OffWindowEvent
4306         {
4307             add
4308             {
4309                 if (_offWindowEventHandler == null)
4310                 {
4311                     _offWindowEventCallback = OffWindow;
4312                     this.OffWindowSignal().Connect(_offWindowEventCallback);
4313                 }
4314
4315                 _offWindowEventHandler += value;
4316             }
4317
4318             remove
4319             {
4320                 _offWindowEventHandler -= value;
4321
4322                 if (_offWindowEventHandler == null && OffWindowSignal().Empty() == false)
4323                 {
4324                     this.OffWindowSignal().Disconnect(_offWindowEventCallback);
4325                 }
4326             }
4327         }
4328
4329         /// <summary>
4330         /// [Obsolete("Please do not use! this will be deprecated")]
4331         /// </summary>
4332         /// <since_tizen> 3 </since_tizen>
4333         [Obsolete("Please do not use! this will be deprecated")]
4334         public event EventHandler OnRelayoutEvent
4335         {
4336             add
4337             {
4338                 if (_onRelayoutEventHandler == null)
4339                 {
4340                     _onRelayoutEventCallback = OnRelayout;
4341                     this.OnRelayoutSignal().Connect(_onRelayoutEventCallback);
4342                 }
4343
4344                 _onRelayoutEventHandler += value;
4345             }
4346
4347             remove
4348             {
4349                 _onRelayoutEventHandler -= value;
4350
4351                 if (_onRelayoutEventHandler == null && OnRelayoutSignal().Empty() == false)
4352                 {
4353                     this.OnRelayoutSignal().Disconnect(_onRelayoutEventCallback);
4354                 }
4355
4356             }
4357         }
4358
4359         /// <summary>
4360         /// "Please DO NOT use! This will be deprecated! Please use 'Container GetParent() for derived class' instead!"
4361         /// </summary>
4362         /// <since_tizen> 3 </since_tizen>
4363         //"Please DO NOT use! This will be deprecated! Please use 'Container GetParent() for derived class' instead!"
4364         [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
4365         public new View Parent
4366         {
4367             get
4368             {
4369                 View ret;
4370                 IntPtr cPtr = NDalicPINVOKE.Actor_GetParent(swigCPtr);
4371
4372                 BaseHandle basehandle = Registry.GetManagedBaseHandleFromNativePtr(cPtr);
4373
4374                 if (basehandle is Layer)
4375                 {
4376                     ret = new View(cPtr, false);
4377                 }
4378                 else
4379                 {
4380                     ret = basehandle as View;
4381                 }
4382
4383                 if (NDalicPINVOKE.SWIGPendingException.Pending)
4384                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4385                 return ret;
4386             }
4387         }
4388
4389         /// <summary>
4390         /// Gets/Sets whether inherit parent's the layout Direction.
4391         /// </summary>
4392         /// <since_tizen> 4 </since_tizen>
4393         public bool InheritLayoutDirection
4394         {
4395             get
4396             {
4397                 bool temp = false;
4398                 GetProperty(View.Property.INHERIT_LAYOUT_DIRECTION).Get(out temp);
4399                 return temp;
4400             }
4401             set
4402             {
4403                 SetProperty(View.Property.INHERIT_LAYOUT_DIRECTION, new Tizen.NUI.PropertyValue(value));
4404             }
4405         }
4406
4407         /// <summary>
4408         /// Gets/Sets the layout Direction.
4409         /// </summary>
4410         /// <since_tizen> 4 </since_tizen>
4411         public ViewLayoutDirectionType LayoutDirection
4412         {
4413             get
4414             {
4415                 int temp;
4416                 if (GetProperty(View.Property.LAYOUT_DIRECTION).Get(out temp) == false)
4417                 {
4418                     NUILog.Error("LAYOUT_DIRECTION get error!");
4419                 }
4420                 return (ViewLayoutDirectionType)temp;
4421             }
4422             set
4423             {
4424                 SetProperty(View.Property.LAYOUT_DIRECTION, new Tizen.NUI.PropertyValue((int)value));
4425             }
4426         }
4427     }
4428
4429     /// <summary>
4430     /// The View layout Direction type.
4431     /// </summary>
4432     /// <since_tizen> 4 </since_tizen>
4433     public enum ViewLayoutDirectionType
4434     {
4435         /// <summary>
4436         /// Left to right.
4437         /// </summary>
4438         LTR,
4439         /// <summary>
4440         /// Right to left.
4441         /// </summary>
4442         RTL
4443     }
4444 }