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