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

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