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

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