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

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