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

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