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

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