plugins/dali-sharp/sharp/internal/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 Dali
  18 {
  19     using System;
  20     using System.Runtime.InteropServices;
  21
  22     public class View : Animatable
  23     {
  24         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  25
  26         internal View(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.View_SWIGUpcast(cPtr), cMemoryOwn)
  27         {
  28             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  29
  30             // Register this instance of view in the view registry.
  31             ViewRegistry.RegisterView(this);
  32
  33             // By default, we do not want the position to use the anchor point
  34             this.PositionUsesAnchorPoint = false;
  35         }
  36
  37         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(View obj)
  38         {
  39             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  40         }
  41
  42         ~View()
  43         {
  44             DisposeQueue.Instance.Add(this);
  45
  46             // Unregister this instance of view from the view registry.
  47             ViewRegistry.UnregisterView(this);
  48         }
  49
  50         public virtual void Dispose()
  51         {
  52             if (!Stage.IsInstalled())
  53             {
  54                 DisposeQueue.Instance.Add(this);
  55                 return;
  56             }
  57
  58             lock (this)
  59             {
  60                 if (swigCPtr.Handle != global::System.IntPtr.Zero)
  61                 {
  62                     if (swigCMemOwn)
  63                     {
  64                         swigCMemOwn = false;
  65                         NDalicPINVOKE.delete_View(swigCPtr);
  66                     }
  67                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  68                 }
  69                 global::System.GC.SuppressFinalize(this);
  70             }
  71         }
  72
  73         /**
  74          * @brief Event arguments that passed via KeyInputFocusGained signal
  75          *
  76          */
  77         public class KeyInputFocusGainedEventArgs : EventArgs
  78         {
  79             private View _view;
  80
  81             /**
  82              * @brief View - is the view that gets Key Input Focus
  83              *
  84              */
  85             public View View
  86             {
  87                 get
  88                 {
  89                     return _view;
  90                 }
  91                 set
  92                 {
  93                     _view = value;
  94                 }
  95             }
  96         }
  97
  98         /**
  99          * @brief Event arguments that passed via KeyInputFocusLost signal
 100          *
 101          */
 102         public class KeyInputFocusLostEventArgs : EventArgs
 103         {
 104             private View _view;
 105
 106             /**
 107              * @brief View - is the view that loses Key Input Focus
 108              *
 109              */
 110             public View View
 111             {
 112                 get
 113                 {
 114                     return _view;
 115                 }
 116                 set
 117                 {
 118                     _view = value;
 119                 }
 120             }
 121         }
 122
 123         /**
 124          * @brief Event arguments that passed via Key signal
 125          *
 126          */
 127         public class KeyEventArgs : EventArgs
 128         {
 129             private View _view;
 130             private Key _key;
 131
 132             /**
 133              * @brief View - is the view that recieves the key.
 134              *
 135              */
 136             public View View
 137             {
 138                 get
 139                 {
 140                     return _view;
 141                 }
 142                 set
 143                 {
 144                     _view = value;
 145                 }
 146             }
 147
 148             /**
 149              * @brief Key - is the key sent to the View.
 150              *
 151              */
 152             public Key Key
 153             {
 154                 get
 155                 {
 156                     return _key;
 157                 }
 158                 set
 159                 {
 160                     _key = value;
 161                 }
 162             }
 163         }
 164
 165         /**
 166          * @brief Event arguments that passed via OnRelayout signal
 167          *
 168          */
 169         public class OnRelayoutEventArgs : EventArgs
 170         {
 171             private View _view;
 172
 173             /**
 174              * @brief View - is the view that is being resized upon relayout
 175              *
 176              */
 177             public View View
 178             {
 179                 get
 180                 {
 181                     return _view;
 182                 }
 183                 set
 184                 {
 185                     _view = value;
 186                 }
 187             }
 188         }
 189
 190
 191         /**
 192          * @brief Event arguments that passed via Touch signal
 193          *
 194          */
 195         public class TouchEventArgs : EventArgs
 196         {
 197             private View _view;
 198             private Touch _touch;
 199
 200             /**
 201              * @brief View - is the view that is being touched
 202              *
 203              */
 204             public View View
 205             {
 206                 get
 207                 {
 208                     return _view;
 209                 }
 210                 set
 211                 {
 212                     _view = value;
 213                 }
 214             }
 215
 216             /**
 217              * @brief Touch - contains the information of touch points
 218              *
 219              */
 220             public Touch Touch
 221             {
 222                 get
 223                 {
 224                     return _touch;
 225                 }
 226                 set
 227                 {
 228                     _touch = value;
 229                 }
 230             }
 231         }
 232
 233         /**
 234          * @brief Event arguments that passed via Hover signal
 235          *
 236          */
 237         public class HoverEventArgs : EventArgs
 238         {
 239             private View _view;
 240             private Hover _hover;
 241
 242             /**
 243              * @brief View - is the view that is being hovered
 244              *
 245              */
 246             public View View
 247             {
 248                 get
 249                 {
 250                     return _view;
 251                 }
 252                 set
 253                 {
 254                     _view = value;
 255                 }
 256             }
 257
 258             /**
 259              * @brief Hover - contains touch points that represent the points
 260              * that are currently being hovered or the points where a hover has stopped
 261              *
 262              */
 263             public Hover Hover
 264             {
 265                 get
 266                 {
 267                     return _hover;
 268                 }
 269                 set
 270                 {
 271                     _hover = value;
 272                 }
 273             }
 274         }
 275
 276         /**
 277          * @brief Event arguments that passed via Wheel signal
 278          *
 279          */
 280         public class WheelEventArgs : EventArgs
 281         {
 282             private View _view;
 283             private Wheel _wheel;
 284
 285             /**
 286              * @brief View - is the view that is being wheeled
 287              *
 288              */
 289             public View View
 290             {
 291                 get
 292                 {
 293                     return _view;
 294                 }
 295                 set
 296                 {
 297                     _view = value;
 298                 }
 299             }
 300
 301             /**
 302              * @brief Wheel - store a wheel rolling type : MOUSE_WHEEL or CUSTOM_WHEEL
 303              *
 304              */
 305             public Wheel Wheel
 306             {
 307                 get
 308                 {
 309                     return _wheel;
 310                 }
 311                 set
 312                 {
 313                     _wheel = value;
 314                 }
 315             }
 316         }
 317
 318         /**
 319          * @brief Event arguments that passed via OnStage signal
 320          *
 321          */
 322         public class OnStageEventArgs : EventArgs
 323         {
 324             private View _view;
 325
 326             /**
 327              * @brief View - is the view that is being connected to the stage
 328              *
 329              */
 330             public View View
 331             {
 332                 get
 333                 {
 334                     return _view;
 335                 }
 336                 set
 337                 {
 338                     _view = value;
 339                 }
 340             }
 341         }
 342
 343         /**
 344          * @brief Event arguments that passed via OffStage signal
 345          *
 346          */
 347         public class OffStageEventArgs : EventArgs
 348         {
 349             private View _view;
 350
 351             /**
 352              * @brief View - is the view that is being disconnected from the stage
 353              *
 354              */
 355             public View View
 356             {
 357                 get
 358                 {
 359                     return _view;
 360                 }
 361                 set
 362                 {
 363                     _view = value;
 364                 }
 365             }
 366         }
 367
 368         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 369         private delegate void KeyInputFocusGainedCallbackDelegate(IntPtr control);
 370
 371         private DaliEventHandler<object,KeyInputFocusGainedEventArgs> _KeyInputFocusGainedEventHandler;
 372         private KeyInputFocusGainedCallbackDelegate _KeyInputFocusGainedCallbackDelegate;
 373
 374         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 375         private delegate void KeyInputFocusLostCallbackDelegate(IntPtr control);
 376
 377         private DaliEventHandler<object,KeyInputFocusLostEventArgs> _KeyInputFocusLostEventHandler;
 378         private KeyInputFocusLostCallbackDelegate _KeyInputFocusLostCallbackDelegate;
 379
 380         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 381         private delegate bool KeyCallbackDelegate(IntPtr control, IntPtr key);
 382
 383         private DaliEventHandlerWithReturnType<object,KeyEventArgs,bool> _KeyHandler;
 384         private KeyCallbackDelegate _KeyCallbackDelegate;
 385
 386         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 387         private delegate void OnRelayoutEventCallbackDelegate(IntPtr control);
 388
 389         private DaliEventHandler<object,OnRelayoutEventArgs> _viewOnRelayoutEventHandler;
 390         private OnRelayoutEventCallbackDelegate _viewOnRelayoutEventCallbackDelegate;
 391
 392         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 393         private delegate bool TouchCallbackDelegate(IntPtr view, IntPtr touch);
 394
 395         private DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> _viewTouchHandler;
 396         private TouchCallbackDelegate _viewTouchCallbackDelegate;
 397
 398         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 399         private delegate bool HoverCallbackDelegate(IntPtr view, IntPtr hover);
 400
 401         private DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> _viewHoverHandler;
 402         private HoverCallbackDelegate _viewHoverCallbackDelegate;
 403
 404         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 405         private delegate bool WheelCallbackDelegate(IntPtr view, IntPtr wheel);
 406
 407         private DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> _viewWheelHandler;
 408         private WheelCallbackDelegate _viewWheelCallbackDelegate;
 409
 410         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 411         private delegate void OnStageEventCallbackDelegate(IntPtr control);
 412
 413         private DaliEventHandler<object,OnStageEventArgs> _viewOnStageEventHandler;
 414         private OnStageEventCallbackDelegate _viewOnStageEventCallbackDelegate;
 415
 416         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 417         private delegate void OffStageEventCallbackDelegate(IntPtr control);
 418
 419         private DaliEventHandler<object,OffStageEventArgs> _viewOffStageEventHandler;
 420         private OffStageEventCallbackDelegate _viewOffStageEventCallbackDelegate;
 421
 422         /**
 423          * @brief Event for KeyInputFocusGained signal which can be used to subscribe/unsubscribe the event handler
 424          * (in the type of KeyInputFocusGainedEventHandler-DaliEventHandler<object,KeyInputFocusGainedEventArgs>)
 425          * provided by the user. KeyInputFocusGained signal is emitted when the control gets Key Input Focus.
 426          */
 427         public event DaliEventHandler<object,KeyInputFocusGainedEventArgs> KeyInputFocusGained
 428         {
 429             add
 430             {
 431                 lock (this)
 432                 {
 433                     // Restricted to only one listener
 434                     if (_KeyInputFocusGainedEventHandler == null)
 435                     {
 436                         _KeyInputFocusGainedEventHandler += value;
 437                         Console.WriteLine("View Key EVENT Locked....");
 438                         _KeyInputFocusGainedCallbackDelegate = new KeyInputFocusGainedCallbackDelegate(OnKeyInputFocusGained);
 439                         this.KeyInputFocusGainedSignal().Connect(_KeyInputFocusGainedCallbackDelegate);
 440                     }
 441                 }
 442             }
 443
 444             remove
 445             {
 446                 lock (this)
 447                 {
 448                     if (_KeyInputFocusGainedEventHandler != null)
 449                     {
 450                         this.KeyInputFocusGainedSignal().Disconnect(_KeyInputFocusGainedCallbackDelegate);
 451                     }
 452
 453                     _KeyInputFocusGainedEventHandler -= value;
 454                 }
 455             }
 456         }
 457
 458         private void OnKeyInputFocusGained(IntPtr view)
 459         {
 460             KeyInputFocusGainedEventArgs e = new KeyInputFocusGainedEventArgs();
 461             Console.WriteLine("View Key ....");
 462             // Populate all members of "e" (KeyInputFocusGainedEventArgs) with real data
 463             e.View = Dali.View.GetViewFromPtr(view);
 464
 465             if (_KeyInputFocusGainedEventHandler != null)
 466             {
 467                 //here we send all data to user event handlers
 468                 _KeyInputFocusGainedEventHandler(this, e);
 469             }
 470
 471         }
 472
 473         /**
 474          * @brief Event for KeyInputFocusLost signal which can be used to subscribe/unsubscribe the event handler
 475          * (in the type of KeyInputFocusLostEventHandler-DaliEventHandler<object,KeyInputFocusLostEventArgs>)
 476          * provided by the user. KeyInputFocusLost signal is emitted when the control loses Key Input Focus.
 477          */
 478         public event DaliEventHandler<object,KeyInputFocusLostEventArgs> KeyInputFocusLost
 479         {
 480             add
 481             {
 482                 lock (this)
 483                 {
 484                     // Restricted to only one listener
 485                     if (_KeyInputFocusLostEventHandler == null)
 486                     {
 487                         _KeyInputFocusLostEventHandler += value;
 488
 489                         _KeyInputFocusLostCallbackDelegate = new KeyInputFocusLostCallbackDelegate(OnKeyInputFocusLost);
 490                         this.KeyInputFocusLostSignal().Connect(_KeyInputFocusLostCallbackDelegate);
 491                     }
 492                 }
 493             }
 494
 495             remove
 496             {
 497                 lock (this)
 498                 {
 499                     if (_KeyInputFocusLostEventHandler != null)
 500                     {
 501                         this.KeyInputFocusLostSignal().Disconnect(_KeyInputFocusLostCallbackDelegate);
 502                     }
 503
 504                     _KeyInputFocusLostEventHandler -= value;
 505                 }
 506             }
 507         }
 508
 509         private void OnKeyInputFocusLost(IntPtr view)
 510         {
 511             KeyInputFocusLostEventArgs e = new KeyInputFocusLostEventArgs();
 512
 513             // Populate all members of "e" (KeyInputFocusLostEventArgs) with real data
 514             e.View = Dali.View.GetViewFromPtr(view);
 515
 516             if (_KeyInputFocusLostEventHandler != null)
 517             {
 518                 //here we send all data to user event handlers
 519                 _KeyInputFocusLostEventHandler(this, e);
 520             }
 521         }
 522
 523         /**
 524          * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
 525          * (in the type of KeyHandler-DaliEventHandlerWithReturnType<object,KeyEventArgs,bool>)
 526          * provided by the user. KeyPressed signal is emitted when key event is received.
 527          */
 528         public event DaliEventHandlerWithReturnType<object,KeyEventArgs,bool> KeyPressed
 529         {
 530             add
 531             {
 532                 lock (this)
 533                 {
 534                     // Restricted to only one listener
 535                     if (_KeyHandler == null)
 536                     {
 537                         _KeyHandler += value;
 538
 539                         _KeyCallbackDelegate = new KeyCallbackDelegate(OnKey);
 540                         this.KeyEventSignal().Connect(_KeyCallbackDelegate);
 541                     }
 542                 }
 543             }
 544
 545             remove
 546             {
 547                 lock (this)
 548                 {
 549                     if (_KeyHandler != null)
 550                     {
 551                         this.KeyEventSignal().Disconnect(_KeyCallbackDelegate);
 552                     }
 553
 554                     _KeyHandler -= value;
 555                 }
 556             }
 557         }
 558
 559         private bool OnKey(IntPtr view, IntPtr key)
 560         {
 561             KeyEventArgs e = new KeyEventArgs();
 562
 563             // Populate all members of "e" (KeyEventArgs) with real data
 564             e.View = Dali.View.GetViewFromPtr(view);
 565             e.Key = Dali.Key.GetKeyFromPtr(key);
 566
 567             if (_KeyHandler != null)
 568             {
 569                 //here we send all data to user event handlers
 570                 return _KeyHandler(this, e);
 571             }
 572             return false;
 573
 574         }
 575
 576         /**
 577          * @brief Event for OnRelayout signal which can be used to subscribe/unsubscribe the event handler
 578          * (in the type of OnRelayoutEventHandler) provided by the user.
 579          * OnRelayout signal is emitted after the size has been set on the view during relayout.
 580          */
 581         public event DaliEventHandler<object,OnRelayoutEventArgs> OnRelayoutEvent
 582         {
 583             add
 584             {
 585                 lock (this)
 586                 {
 587                     // Restricted to only one listener
 588                     if (_viewOnRelayoutEventHandler == null)
 589                     {
 590                         _viewOnRelayoutEventHandler += value;
 591                         Console.WriteLine("View OnRelayoutEventArgs Locked....");
 592                         _viewOnRelayoutEventCallbackDelegate = new OnRelayoutEventCallbackDelegate(OnRelayout);
 593                         this.OnRelayoutSignal().Connect(_viewOnRelayoutEventCallbackDelegate);
 594                     }
 595                 }
 596             }
 597
 598             remove
 599             {
 600                 lock (this)
 601                 {
 602                     if (_viewOnRelayoutEventHandler != null)
 603                     {
 604                         this.OnRelayoutSignal().Disconnect(_viewOnRelayoutEventCallbackDelegate);
 605                     }
 606
 607                     _viewOnRelayoutEventHandler -= value;
 608                 }
 609             }
 610         }
 611
 612         // Callback for View OnRelayout signal
 613         private void OnRelayout(IntPtr data)
 614         {
 615             OnRelayoutEventArgs e = new OnRelayoutEventArgs();
 616             Console.WriteLine("View OnRelayoutEventArgs....");
 617             // Populate all members of "e" (OnRelayoutEventArgs) with real data
 618             e.View = View.GetViewFromPtr(data);
 619
 620             if (_viewOnRelayoutEventHandler != null)
 621             {
 622                 //here we send all data to user event handlers
 623                 _viewOnRelayoutEventHandler(this, e);
 624             }
 625         }
 626
 627         /**
 628          * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler
 629          * (in the type of TouchHandler-DaliEventHandlerWithReturnType<object,TouchEventArgs,bool>)
 630          * provided by the user. Touched signal is emitted when touch input is received.
 631          */
 632         public event DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> Touched
 633         {
 634             add
 635             {
 636                 lock (this)
 637                 {
 638                     // Restricted to only one listener
 639                     if (_viewTouchHandler == null)
 640                     {
 641                         _viewTouchHandler += value;
 642                         Console.WriteLine("View Touch EVENT LOCKED....");
 643                         _viewTouchCallbackDelegate = new TouchCallbackDelegate(OnTouch);
 644                         this.TouchSignal().Connect(_viewTouchCallbackDelegate);
 645                     }
 646                 }
 647             }
 648
 649             remove
 650             {
 651                 lock (this)
 652                 {
 653                     if (_viewTouchHandler != null)
 654                     {
 655                         this.TouchSignal().Disconnect(_viewTouchCallbackDelegate);
 656                     }
 657
 658                     _viewTouchHandler -= value;
 659                 }
 660             }
 661         }
 662
 663         // Callback for View TouchSignal
 664         private bool OnTouch(IntPtr view, IntPtr touch)
 665         {
 666             TouchEventArgs e = new TouchEventArgs();
 667             Console.WriteLine("View Touch EVENT....");
 668             // Populate all members of "e" (TouchEventArgs) with real data
 669             e.View = View.GetViewFromPtr(view);
 670             e.Touch = Dali.Touch.GetTouchFromPtr(touch);
 671
 672             if (_viewTouchHandler != null)
 673             {
 674                 //here we send all data to user event handlers
 675                 return _viewTouchHandler(this, e);
 676             }
 677
 678             return false;
 679         }
 680
 681         /**
 682          * @brief Event for Hovered signal which can be used to subscribe/unsubscribe the event handler
 683          * (in the type of HoverHandler-DaliEventHandlerWithReturnType<object,HoverEventArgs,bool>)
 684          * provided by the user. Hovered signal is emitted when hover input is received.
 685          */
 686         public event DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> Hovered
 687         {
 688             add
 689             {
 690                 lock (this)
 691                 {
 692                     // Restricted to only one listener
 693                     if (_viewHoverHandler == null)
 694                     {
 695                         _viewHoverHandler += value;
 696
 697                         _viewHoverCallbackDelegate = new HoverCallbackDelegate(OnHover);
 698                         this.HoveredSignal().Connect(_viewHoverCallbackDelegate);
 699                     }
 700                 }
 701             }
 702
 703             remove
 704             {
 705                 lock (this)
 706                 {
 707                     if (_viewHoverHandler != null)
 708                     {
 709                         this.HoveredSignal().Disconnect(_viewHoverCallbackDelegate);
 710                     }
 711
 712                     _viewHoverHandler -= value;
 713                 }
 714             }
 715         }
 716
 717         // Callback for View Hover signal
 718         private bool OnHover(IntPtr view, IntPtr hover)
 719         {
 720             HoverEventArgs e = new HoverEventArgs();
 721
 722             // Populate all members of "e" (HoverEventArgs) with real data
 723             e.View = View.GetViewFromPtr(view);
 724             e.Hover = Dali.Hover.GetHoverFromPtr(hover);
 725
 726             if (_viewHoverHandler != null)
 727             {
 728                 //here we send all data to user event handlers
 729                 return _viewHoverHandler(this, e);
 730             }
 731
 732             return false;
 733         }
 734
 735         /**
 736          * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
 737          * (in the type of WheelHandler-DaliEventHandlerWithReturnType<object,WheelEventArgs,bool>)
 738          * provided by the user. WheelMoved signal is emitted when wheel event is received.
 739          */
 740         public event DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> WheelMoved
 741         {
 742             add
 743             {
 744                 lock (this)
 745                 {
 746                     // Restricted to only one listener
 747                     if (_viewWheelHandler == null)
 748                     {
 749                         _viewWheelHandler += value;
 750                         Console.WriteLine("View Wheel EVENT LOCKED....");
 751                         _viewWheelCallbackDelegate = new WheelCallbackDelegate(OnWheel);
 752                         this.WheelEventSignal().Connect(_viewWheelCallbackDelegate);
 753                     }
 754                 }
 755             }
 756
 757             remove
 758             {
 759                 lock (this)
 760                 {
 761                     if (_viewWheelHandler != null)
 762                     {
 763                         this.WheelEventSignal().Disconnect(_viewWheelCallbackDelegate);
 764                     }
 765
 766                     _viewWheelHandler -= value;
 767                 }
 768             }
 769         }
 770
 771         // Callback for View Wheel signal
 772         private bool OnWheel(IntPtr view, IntPtr wheel)
 773         {
 774             WheelEventArgs e = new WheelEventArgs();
 775             Console.WriteLine("View Wheel EVENT ....");
 776             // Populate all members of "e" (WheelEventArgs) with real data
 777             e.View = View.GetViewFromPtr(view);
 778             e.Wheel = Dali.Wheel.GetWheelFromPtr(wheel);
 779
 780             if (_viewWheelHandler != null)
 781             {
 782                 //here we send all data to user event handlers
 783                 return _viewWheelHandler(this, e);
 784             }
 785
 786             return false;
 787         }
 788
 789         /**
 790          * @brief Event for OnStage signal which can be used to subscribe/unsubscribe the event handler
 791          * (in the type of OnStageEventHandler) provided by the user.
 792          * OnStage signal is emitted after the view has been connected to the stage.
 793          */
 794         public event DaliEventHandler<object,OnStageEventArgs> OnStageEvent
 795         {
 796             add
 797             {
 798                 lock (this)
 799                 {
 800                     // Restricted to only one listener
 801                     if (_viewOnStageEventHandler == null)
 802                     {
 803                         _viewOnStageEventHandler += value;
 804
 805                         _viewOnStageEventCallbackDelegate = new OnStageEventCallbackDelegate(OnStage);
 806                         this.OnStageSignal().Connect(_viewOnStageEventCallbackDelegate);
 807                     }
 808                 }
 809             }
 810
 811             remove
 812             {
 813                 lock (this)
 814                 {
 815                     if (_viewOnStageEventHandler != null)
 816                     {
 817                         this.OnStageSignal().Disconnect(_viewOnStageEventCallbackDelegate);
 818                     }
 819
 820                     _viewOnStageEventHandler -= value;
 821                 }
 822             }
 823         }
 824
 825         // Callback for View OnStage signal
 826         private void OnStage(IntPtr data)
 827         {
 828             OnStageEventArgs e = new OnStageEventArgs();
 829
 830             // Populate all members of "e" (OnStageEventArgs) with real data
 831             e.View = View.GetViewFromPtr(data);
 832
 833             //Console.WriteLine("############# OnStage()! e.View.Name=" + e.View.Name);
 834
 835             if (_viewOnStageEventHandler != null)
 836             {
 837                 //here we send all data to user event handlers
 838                 _viewOnStageEventHandler(this, e);
 839             }
 840         }
 841
 842         /**
 843          * @brief Event for OffStage signal which can be used to subscribe/unsubscribe the event handler
 844          * (in the type of OffStageEventHandler) provided by the user.
 845          * OffStage signal is emitted after the view has been disconnected from the stage.
 846          */
 847         public event DaliEventHandler<object,OffStageEventArgs> OffStageEvent
 848         {
 849             add
 850             {
 851                 lock (this)
 852                 {
 853                     // Restricted to only one listener
 854                     if (_viewOffStageEventHandler == null)
 855                     {
 856                         _viewOffStageEventHandler += value;
 857
 858                         _viewOffStageEventCallbackDelegate = new OffStageEventCallbackDelegate(OffStage);
 859                         this.OnStageSignal().Connect(_viewOffStageEventCallbackDelegate);
 860                     }
 861                 }
 862             }
 863
 864             remove
 865             {
 866                 lock (this)
 867                 {
 868                     if (_viewOffStageEventHandler != null)
 869                     {
 870                         this.OnStageSignal().Disconnect(_viewOffStageEventCallbackDelegate);
 871                     }
 872
 873                     _viewOffStageEventHandler -= value;
 874                 }
 875             }
 876         }
 877
 878         // Callback for View OffStage signal
 879         private void OffStage(IntPtr data)
 880         {
 881             OffStageEventArgs e = new OffStageEventArgs();
 882
 883             // Populate all members of "e" (OffStageEventArgs) with real data
 884             e.View = View.GetViewFromPtr(data);
 885
 886             if (_viewOffStageEventHandler != null)
 887             {
 888                 //here we send all data to user event handlers
 889                 _viewOffStageEventHandler(this, e);
 890             }
 891         }
 892
 893         public static View GetViewFromPtr(global::System.IntPtr cPtr)
 894         {
 895             View ret = new View(cPtr, false);
 896             if (NDalicPINVOKE.SWIGPendingException.Pending)
 897                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 898             return ret;
 899         }
 900
 901         public IntPtr GetPtrfromView()
 902         {
 903             return (IntPtr)swigCPtr;
 904         }
 905
 906         public class Property : global::System.IDisposable
 907         {
 908             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 909             protected bool swigCMemOwn;
 910
 911             internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)
 912             {
 913                 swigCMemOwn = cMemoryOwn;
 914                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 915             }
 916
 917             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)
 918             {
 919                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 920             }
 921
 922             ~Property()
 923             {
 924                 Dispose();
 925             }
 926
 927             public virtual void Dispose()
 928             {
 929                 lock (this)
 930                 {
 931                     if (swigCPtr.Handle != global::System.IntPtr.Zero)
 932                     {
 933                         if (swigCMemOwn)
 934                         {
 935                             swigCMemOwn = false;
 936                             NDalicPINVOKE.delete_View_Property(swigCPtr);
 937                         }
 938                         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 939                     }
 940                     global::System.GC.SuppressFinalize(this);
 941                 }
 942             }
 943
 944             public static readonly int TOOLTIP = NDalicManualPINVOKE.View_Property_TOOLTIP_get();
 945             public static readonly int STATE = NDalicManualPINVOKE.View_Property_STATE_get();
 946             public static readonly int SUB_STATE = NDalicManualPINVOKE.View_Property_SUB_STATE_get();
 947             public static readonly int LEFT_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_LEFT_FOCUSABLE_ACTOR_ID_get();
 948             public static readonly int RIGHT_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_RIGHT_FOCUSABLE_ACTOR_ID_get();
 949             public static readonly int UP_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_UP_FOCUSABLE_ACTOR_ID_get();
 950             public static readonly int DOWN_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_DOWN_FOCUSABLE_ACTOR_ID_get();
 951
 952             public Property() : this(NDalicPINVOKE.new_View_Property(), true)
 953             {
 954                 if (NDalicPINVOKE.SWIGPendingException.Pending)
 955                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 956             }
 957
 958             public static readonly int STYLE_NAME = NDalicPINVOKE.View_Property_STYLE_NAME_get();
 959             public static readonly int BACKGROUND_COLOR = NDalicPINVOKE.View_Property_BACKGROUND_COLOR_get();
 960             public static readonly int BACKGROUND_IMAGE = NDalicPINVOKE.View_Property_BACKGROUND_IMAGE_get();
 961             public static readonly int KEY_INPUT_FOCUS = NDalicPINVOKE.View_Property_KEY_INPUT_FOCUS_get();
 962             public static readonly int BACKGROUND = NDalicPINVOKE.View_Property_BACKGROUND_get();
 963
 964
 965             public static readonly int SIBLING_ORDER = NDalicManualPINVOKE.Actor_Property_SIBLING_ORDER_get();
 966             public static readonly int OPACITY = NDalicManualPINVOKE.Actor_Property_OPACITY_get();
 967             public static readonly int SCREEN_POSITION = NDalicManualPINVOKE.Actor_Property_SCREEN_POSITION_get();
 968             public static readonly int POSITION_USES_ANCHOR_POINT = NDalicManualPINVOKE.Actor_Property_POSITION_USES_ANCHOR_POINT_get();
 969             public static readonly int PARENT_ORIGIN = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_get();
 970             public static readonly int PARENT_ORIGIN_X = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_X_get();
 971             public static readonly int PARENT_ORIGIN_Y = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Y_get();
 972             public static readonly int PARENT_ORIGIN_Z = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Z_get();
 973             public static readonly int ANCHOR_POINT = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_get();
 974             public static readonly int ANCHOR_POINT_X = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_X_get();
 975             public static readonly int ANCHOR_POINT_Y = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Y_get();
 976             public static readonly int ANCHOR_POINT_Z = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Z_get();
 977             public static readonly int SIZE = NDalicPINVOKE.Actor_Property_SIZE_get();
 978             public static readonly int SIZE_WIDTH = NDalicPINVOKE.Actor_Property_SIZE_WIDTH_get();
 979             public static readonly int SIZE_HEIGHT = NDalicPINVOKE.Actor_Property_SIZE_HEIGHT_get();
 980             public static readonly int SIZE_DEPTH = NDalicPINVOKE.Actor_Property_SIZE_DEPTH_get();
 981             public static readonly int POSITION = NDalicPINVOKE.Actor_Property_POSITION_get();
 982             public static readonly int POSITION_X = NDalicPINVOKE.Actor_Property_POSITION_X_get();
 983             public static readonly int POSITION_Y = NDalicPINVOKE.Actor_Property_POSITION_Y_get();
 984             public static readonly int POSITION_Z = NDalicPINVOKE.Actor_Property_POSITION_Z_get();
 985             public static readonly int WORLD_POSITION = NDalicPINVOKE.Actor_Property_WORLD_POSITION_get();
 986             public static readonly int WORLD_POSITION_X = NDalicPINVOKE.Actor_Property_WORLD_POSITION_X_get();
 987             public static readonly int WORLD_POSITION_Y = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Y_get();
 988             public static readonly int WORLD_POSITION_Z = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Z_get();
 989             public static readonly int ORIENTATION = NDalicPINVOKE.Actor_Property_ORIENTATION_get();
 990             public static readonly int WORLD_ORIENTATION = NDalicPINVOKE.Actor_Property_WORLD_ORIENTATION_get();
 991             public static readonly int SCALE = NDalicPINVOKE.Actor_Property_SCALE_get();
 992             public static readonly int SCALE_X = NDalicPINVOKE.Actor_Property_SCALE_X_get();
 993             public static readonly int SCALE_Y = NDalicPINVOKE.Actor_Property_SCALE_Y_get();
 994             public static readonly int SCALE_Z = NDalicPINVOKE.Actor_Property_SCALE_Z_get();
 995             public static readonly int WORLD_SCALE = NDalicPINVOKE.Actor_Property_WORLD_SCALE_get();
 996             public static readonly int VISIBLE = NDalicPINVOKE.Actor_Property_VISIBLE_get();
 997             public static readonly int COLOR = NDalicPINVOKE.Actor_Property_COLOR_get();
 998             public static readonly int COLOR_RED = NDalicPINVOKE.Actor_Property_COLOR_RED_get();
 999             public static readonly int COLOR_GREEN = NDalicPINVOKE.Actor_Property_COLOR_GREEN_get();
1000             public static readonly int COLOR_BLUE = NDalicPINVOKE.Actor_Property_COLOR_BLUE_get();
1001             public static readonly int COLOR_ALPHA = NDalicPINVOKE.Actor_Property_COLOR_ALPHA_get();
1002             public static readonly int WORLD_COLOR = NDalicPINVOKE.Actor_Property_WORLD_COLOR_get();
1003             public static readonly int WORLD_MATRIX = NDalicPINVOKE.Actor_Property_WORLD_MATRIX_get();
1004             public static readonly int NAME = NDalicPINVOKE.Actor_Property_NAME_get();
1005             public static readonly int SENSITIVE = NDalicPINVOKE.Actor_Property_SENSITIVE_get();
1006             public static readonly int LEAVE_REQUIRED = NDalicPINVOKE.Actor_Property_LEAVE_REQUIRED_get();
1007             public static readonly int INHERIT_ORIENTATION = NDalicPINVOKE.Actor_Property_INHERIT_ORIENTATION_get();
1008             public static readonly int INHERIT_SCALE = NDalicPINVOKE.Actor_Property_INHERIT_SCALE_get();
1009             public static readonly int COLOR_MODE = NDalicPINVOKE.Actor_Property_COLOR_MODE_get();
1010             public static readonly int POSITION_INHERITANCE = NDalicPINVOKE.Actor_Property_POSITION_INHERITANCE_get();
1011             public static readonly int DRAW_MODE = NDalicPINVOKE.Actor_Property_DRAW_MODE_get();
1012             public static readonly int SIZE_MODE_FACTOR = NDalicPINVOKE.Actor_Property_SIZE_MODE_FACTOR_get();
1013             public static readonly int WIDTH_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_WIDTH_RESIZE_POLICY_get();
1014             public static readonly int HEIGHT_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_HEIGHT_RESIZE_POLICY_get();
1015             public static readonly int SIZE_SCALE_POLICY = NDalicPINVOKE.Actor_Property_SIZE_SCALE_POLICY_get();
1016             public static readonly int WIDTH_FOR_HEIGHT = NDalicPINVOKE.Actor_Property_WIDTH_FOR_HEIGHT_get();
1017             public static readonly int HEIGHT_FOR_WIDTH = NDalicPINVOKE.Actor_Property_HEIGHT_FOR_WIDTH_get();
1018             public static readonly int PADDING = NDalicPINVOKE.Actor_Property_PADDING_get();
1019             public static readonly int MINIMUM_SIZE = NDalicPINVOKE.Actor_Property_MINIMUM_SIZE_get();
1020             public static readonly int MAXIMUM_SIZE = NDalicPINVOKE.Actor_Property_MAXIMUM_SIZE_get();
1021             public static readonly int INHERIT_POSITION = NDalicPINVOKE.Actor_Property_INHERIT_POSITION_get();
1022             public static readonly int CLIPPING_MODE = NDalicPINVOKE.Actor_Property_CLIPPING_MODE_get();
1023
1024         }
1025
1026         public class KeyboardFocus : global::System.IDisposable
1027         {
1028             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
1029             protected bool swigCMemOwn;
1030
1031             internal KeyboardFocus(global::System.IntPtr cPtr, bool cMemoryOwn)
1032             {
1033                 swigCMemOwn = cMemoryOwn;
1034                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
1035             }
1036
1037             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(KeyboardFocus obj)
1038             {
1039                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
1040             }
1041
1042             ~KeyboardFocus()
1043             {
1044                 Dispose();
1045             }
1046
1047             public virtual void Dispose()
1048             {
1049                 lock (this)
1050                 {
1051                     if (swigCPtr.Handle != global::System.IntPtr.Zero)
1052                     {
1053                         if (swigCMemOwn)
1054                         {
1055                             swigCMemOwn = false;
1056                             NDalicPINVOKE.delete_View_KeyboardFocus(swigCPtr);
1057                         }
1058                         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
1059                     }
1060                     global::System.GC.SuppressFinalize(this);
1061                 }
1062             }
1063
1064             public KeyboardFocus() : this(NDalicPINVOKE.new_View_KeyboardFocus(), true)
1065             {
1066                 if (NDalicPINVOKE.SWIGPendingException.Pending)
1067                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1068             }
1069
1070             public enum Direction
1071             {
1072                 LEFT,
1073                 RIGHT,
1074                 UP,
1075                 DOWN,
1076                 PAGE_UP,
1077                 PAGE_DOWN
1078             }
1079         }
1080
1081         public View() : this(NDalicPINVOKE.View_New(), true)
1082         {
1083             if (NDalicPINVOKE.SWIGPendingException.Pending)
1084                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1085
1086         }
1087
1088         public View(View uiControl) : this(NDalicPINVOKE.new_View__SWIG_1(View.getCPtr(uiControl)), true)
1089         {
1090             if (NDalicPINVOKE.SWIGPendingException.Pending)
1091                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1092         }
1093
1094         public View Assign(View handle)
1095         {
1096             View ret = new View(NDalicPINVOKE.View_Assign(swigCPtr, View.getCPtr(handle)), false);
1097             if (NDalicPINVOKE.SWIGPendingException.Pending)
1098                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1099             return ret;
1100         }
1101
1102         private new static View DownCast(BaseHandle handle)
1103         {
1104             View ret = new View(NDalicPINVOKE.View_DownCast(BaseHandle.getCPtr(handle)), true);
1105             if (NDalicPINVOKE.SWIGPendingException.Pending)
1106                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1107             return ret;
1108         }
1109
1110         public static T DownCast<T>(View view) where T : View
1111         {
1112             return (T)(ViewRegistry.GetViewFromActor(view));
1113         }
1114
1115         private View ConvertIdToView(uint id)
1116         {
1117             View view = null;
1118
1119             if (Parent)
1120             {
1121                 view = Parent.FindChildById(id);
1122             }
1123
1124             if (!view)
1125             {
1126                 view = Stage.Instance.GetRootLayer().FindChildById(id);
1127             }
1128
1129             return view;
1130         }
1131
1132         public void SetKeyInputFocus()
1133         {
1134             NDalicPINVOKE.View_SetKeyInputFocus(swigCPtr);
1135             if (NDalicPINVOKE.SWIGPendingException.Pending)
1136                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1137         }
1138
1139         public bool HasKeyInputFocus()
1140         {
1141             bool ret = NDalicPINVOKE.View_HasKeyInputFocus(swigCPtr);
1142             if (NDalicPINVOKE.SWIGPendingException.Pending)
1143                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1144             return ret;
1145         }
1146
1147         public void ClearKeyInputFocus()
1148         {
1149             NDalicPINVOKE.View_ClearKeyInputFocus(swigCPtr);
1150             if (NDalicPINVOKE.SWIGPendingException.Pending)
1151                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1152         }
1153
1154         public PinchGestureDetector GetPinchGestureDetector()
1155         {
1156             PinchGestureDetector ret = new PinchGestureDetector(NDalicPINVOKE.View_GetPinchGestureDetector(swigCPtr), true);
1157             if (NDalicPINVOKE.SWIGPendingException.Pending)
1158                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1159             return ret;
1160         }
1161
1162         public PanGestureDetector GetPanGestureDetector()
1163         {
1164             PanGestureDetector ret = new PanGestureDetector(NDalicPINVOKE.View_GetPanGestureDetector(swigCPtr), true);
1165             if (NDalicPINVOKE.SWIGPendingException.Pending)
1166                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1167             return ret;
1168         }
1169
1170         public TapGestureDetector GetTapGestureDetector()
1171         {
1172             TapGestureDetector ret = new TapGestureDetector(NDalicPINVOKE.View_GetTapGestureDetector(swigCPtr), true);
1173             if (NDalicPINVOKE.SWIGPendingException.Pending)
1174                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1175             return ret;
1176         }
1177
1178         public LongPressGestureDetector GetLongPressGestureDetector()
1179         {
1180             LongPressGestureDetector ret = new LongPressGestureDetector(NDalicPINVOKE.View_GetLongPressGestureDetector(swigCPtr), true);
1181             if (NDalicPINVOKE.SWIGPendingException.Pending)
1182                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1183             return ret;
1184         }
1185
1186         public void SetStyleName(string styleName)
1187         {
1188             NDalicPINVOKE.View_SetStyleName(swigCPtr, styleName);
1189             if (NDalicPINVOKE.SWIGPendingException.Pending)
1190                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1191         }
1192
1193         public string GetStyleName()
1194         {
1195             string ret = NDalicPINVOKE.View_GetStyleName(swigCPtr);
1196             if (NDalicPINVOKE.SWIGPendingException.Pending)
1197                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1198             return ret;
1199         }
1200
1201         public void SetBackgroundColor(Vector4 color)
1202         {
1203             NDalicPINVOKE.View_SetBackgroundColor(swigCPtr, Vector4.getCPtr(color));
1204             if (NDalicPINVOKE.SWIGPendingException.Pending)
1205                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1206         }
1207
1208         public Vector4 GetBackgroundColor()
1209         {
1210             Vector4 ret = new Vector4(NDalicPINVOKE.View_GetBackgroundColor(swigCPtr), true);
1211             if (NDalicPINVOKE.SWIGPendingException.Pending)
1212                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1213             return ret;
1214         }
1215
1216         public void SetBackgroundImage(Image image)
1217         {
1218             NDalicPINVOKE.View_SetBackgroundImage(swigCPtr, Image.getCPtr(image));
1219             if (NDalicPINVOKE.SWIGPendingException.Pending)
1220                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1221         }
1222
1223         public void ClearBackground()
1224         {
1225             NDalicPINVOKE.View_ClearBackground(swigCPtr);
1226             if (NDalicPINVOKE.SWIGPendingException.Pending)
1227                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1228         }
1229
1230         public ControlKeySignal KeyEventSignal()
1231         {
1232             ControlKeySignal ret = new ControlKeySignal(NDalicPINVOKE.View_KeyEventSignal(swigCPtr), false);
1233             if (NDalicPINVOKE.SWIGPendingException.Pending)
1234                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1235             return ret;
1236         }
1237
1238         public KeyInputFocusSignal KeyInputFocusGainedSignal()
1239         {
1240             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusGainedSignal(swigCPtr), false);
1241             if (NDalicPINVOKE.SWIGPendingException.Pending)
1242                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1243             return ret;
1244         }
1245
1246         public KeyInputFocusSignal KeyInputFocusLostSignal()
1247         {
1248             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusLostSignal(swigCPtr), false);
1249             if (NDalicPINVOKE.SWIGPendingException.Pending)
1250                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1251             return ret;
1252         }
1253
1254         public View(ViewImpl implementation) : this(NDalicPINVOKE.new_View__SWIG_2(ViewImpl.getCPtr(implementation)), true)
1255         {
1256             if (NDalicPINVOKE.SWIGPendingException.Pending)
1257                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1258         }
1259
1260         public enum PropertyRange
1261         {
1262             PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX,
1263             CONTROL_PROPERTY_START_INDEX = PROPERTY_START_INDEX,
1264             CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX + 1000
1265         }
1266
1267         public string StyleName
1268         {
1269             get
1270             {
1271                 string temp;
1272                 GetProperty(View.Property.STYLE_NAME).Get(out temp);
1273                 return temp;
1274             }
1275             set
1276             {
1277                 SetProperty(View.Property.STYLE_NAME, new Dali.Property.Value(value));
1278             }
1279         }
1280
1281         public Vector4 BackgroundColor
1282         {
1283             get
1284             {
1285                 Vector4 backgroundColor = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
1286
1287                 Dali.Property.Map background = Background;
1288                 int visualType = 0;
1289                 background.Find(Dali.Constants.Visual.Property.Type).Get(ref visualType);
1290                 if (visualType == (int)Dali.Constants.Visual.Type.Color)
1291                 {
1292                     background.Find(Dali.Constants.ColorVisualProperty.MixColor).Get(backgroundColor);
1293                 }
1294
1295                 return backgroundColor;
1296             }
1297             set
1298             {
1299                 SetProperty(View.Property.BACKGROUND, new Dali.Property.Value(value));
1300             }
1301         }
1302
1303         public string BackgroundImage
1304         {
1305             get
1306             {
1307                 string backgroundImage = "";
1308
1309                 Dali.Property.Map background = Background;
1310                 int visualType = 0;
1311                 background.Find(Dali.Constants.Visual.Property.Type).Get(ref visualType);
1312                 if (visualType == (int)Dali.Constants.Visual.Type.Image)
1313                 {
1314                     background.Find(Dali.Constants.ImageVisualProperty.URL).Get(out backgroundImage);
1315                 }
1316
1317                 return backgroundImage;
1318             }
1319             set
1320             {
1321                 SetProperty(View.Property.BACKGROUND, new Dali.Property.Value(value));
1322             }
1323         }
1324
1325         public bool KeyInputFocus
1326         {
1327             get
1328             {
1329                 bool temp = false;
1330                 GetProperty(View.Property.KEY_INPUT_FOCUS).Get(ref temp);
1331                 return temp;
1332             }
1333             set
1334             {
1335                 SetProperty(View.Property.KEY_INPUT_FOCUS, new Dali.Property.Value(value));
1336             }
1337         }
1338
1339         public Dali.Property.Map Background
1340         {
1341             get
1342             {
1343                 Dali.Property.Map temp = new Dali.Property.Map();
1344                 GetProperty(View.Property.BACKGROUND).Get(temp);
1345                 return temp;
1346             }
1347             set
1348             {
1349                 SetProperty(View.Property.BACKGROUND, new Dali.Property.Value(value));
1350             }
1351         }
1352
1353         public string State
1354         {
1355             get
1356             {
1357                 string temp;
1358                 GetProperty(View.Property.STATE).Get(out temp);
1359                 return temp;
1360             }
1361             set
1362             {
1363                 SetProperty(View.Property.STATE, new Dali.Property.Value(value));
1364             }
1365         }
1366
1367         public string SubState
1368         {
1369             get
1370             {
1371                 string temp;
1372                 GetProperty(View.Property.SUB_STATE).Get(out temp);
1373                 return temp;
1374             }
1375             set
1376             {
1377                 SetProperty(View.Property.SUB_STATE, new Dali.Property.Value(value));
1378             }
1379         }
1380
1381         public Dali.Property.Map Tooltip
1382         {
1383             get
1384             {
1385                 Dali.Property.Map temp = new Dali.Property.Map();
1386                 GetProperty(View.Property.TOOLTIP).Get(temp);
1387                 return temp;
1388             }
1389             set
1390             {
1391                 SetProperty(View.Property.TOOLTIP, new Dali.Property.Value(value));
1392             }
1393         }
1394
1395         public string TooltipText
1396         {
1397             set
1398             {
1399                 SetProperty(View.Property.TOOLTIP, new Dali.Property.Value(value));
1400             }
1401         }
1402
1403         private int LeftFocusableViewId
1404         {
1405             get
1406             {
1407                 int temp = 0;
1408                 GetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID).Get(ref temp);
1409                 return temp;
1410             }
1411             set
1412             {
1413                 SetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID, new Dali.Property.Value(value));
1414             }
1415         }
1416
1417         private int RightFocusableViewId
1418         {
1419             get
1420             {
1421                 int temp = 0;
1422                 GetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID).Get(ref temp);
1423                 return temp;
1424             }
1425             set
1426             {
1427                 SetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID, new Dali.Property.Value(value));
1428             }
1429         }
1430
1431         private int UpFocusableViewId
1432         {
1433             get
1434             {
1435                 int temp = 0;
1436                 GetProperty(View.Property.UP_FOCUSABLE_VIEW_ID).Get(ref temp);
1437                 return temp;
1438             }
1439             set
1440             {
1441                 SetProperty(View.Property.UP_FOCUSABLE_VIEW_ID, new Dali.Property.Value(value));
1442             }
1443         }
1444
1445         private int DownFocusableViewId
1446         {
1447             get
1448             {
1449                 int temp = 0;
1450                 GetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID).Get(ref temp);
1451                 return temp;
1452             }
1453             set
1454             {
1455                 SetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID, new Dali.Property.Value(value));
1456             }
1457         }
1458
1459         public float Flex
1460         {
1461             get
1462             {
1463                 float temp = 0.0f;
1464                 GetProperty(FlexContainer.ChildProperty.FLEX).Get(ref temp);
1465                 return temp;
1466             }
1467             set
1468             {
1469                 SetProperty(FlexContainer.ChildProperty.FLEX, new Dali.Property.Value(value));
1470             }
1471         }
1472
1473         public int AlignSelf
1474         {
1475             get
1476             {
1477                 int temp = 0;
1478                 GetProperty(FlexContainer.ChildProperty.ALIGN_SELF).Get(ref temp);
1479                 return temp;
1480             }
1481             set
1482             {
1483                 SetProperty(FlexContainer.ChildProperty.ALIGN_SELF, new Dali.Property.Value(value));
1484             }
1485         }
1486
1487         public Vector4 FlexMargin
1488         {
1489             get
1490             {
1491                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
1492                 GetProperty(FlexContainer.ChildProperty.FLEX_MARGIN).Get(temp);
1493                 return temp;
1494             }
1495             set
1496             {
1497                 SetProperty(FlexContainer.ChildProperty.FLEX_MARGIN, new Dali.Property.Value(value));
1498             }
1499         }
1500
1501         public Vector2 CellIndex
1502         {
1503             get
1504             {
1505                 Vector2 temp = new Vector2(0.0f, 0.0f);
1506                 GetProperty(TableView.ChildProperty.CELL_INDEX).Get(temp);
1507                 return temp;
1508             }
1509             set
1510             {
1511                 SetProperty(TableView.ChildProperty.CELL_INDEX, new Dali.Property.Value(value));
1512             }
1513         }
1514
1515         public float RowSpan
1516         {
1517             get
1518             {
1519                 float temp = 0.0f;
1520                 GetProperty(TableView.ChildProperty.ROW_SPAN).Get(ref temp);
1521                 return temp;
1522             }
1523             set
1524             {
1525                 SetProperty(TableView.ChildProperty.ROW_SPAN, new Dali.Property.Value(value));
1526             }
1527         }
1528
1529         public float ColumnSpan
1530         {
1531             get
1532             {
1533                 float temp = 0.0f;
1534                 GetProperty(TableView.ChildProperty.COLUMN_SPAN).Get(ref temp);
1535                 return temp;
1536             }
1537             set
1538             {
1539                 SetProperty(TableView.ChildProperty.COLUMN_SPAN, new Dali.Property.Value(value));
1540             }
1541         }
1542
1543         public string CellHorizontalAlignment
1544         {
1545             get
1546             {
1547                 string temp;
1548                 GetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT).Get(out temp);
1549                 return temp;
1550             }
1551             set
1552             {
1553                 SetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT, new Dali.Property.Value(value));
1554             }
1555         }
1556
1557         public string CellVerticalAlignment
1558         {
1559             get
1560             {
1561                 string temp;
1562                 GetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT).Get(out temp);
1563                 return temp;
1564             }
1565             set
1566             {
1567                 SetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT, new Dali.Property.Value(value));
1568             }
1569         }
1570
1571         /**
1572          * @brief The left focusable view.
1573          * @note This will return NULL if not set.
1574          * This will also return NULL if the specified left focusable view is not on stage.
1575          *
1576          */
1577         public View LeftFocusableView
1578         {
1579             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1580             get
1581             {
1582                 if (LeftFocusableViewId >= 0)
1583                 {
1584                     return ConvertIdToView((uint)LeftFocusableViewId);
1585                 }
1586                 return null;
1587             }
1588             set
1589             {
1590                 LeftFocusableViewId = (int)value.GetId();
1591             }
1592         }
1593
1594         /**
1595          * @brief The right focusable view.
1596          * @note This will return NULL if not set.
1597          * This will also return NULL if the specified right focusable view is not on stage.
1598          *
1599          */
1600         public View RightFocusableView
1601         {
1602             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1603             get
1604             {
1605                 if (RightFocusableViewId >= 0)
1606                 {
1607                     return ConvertIdToView((uint)RightFocusableViewId);
1608                 }
1609                 return null;
1610             }
1611             set
1612             {
1613                 RightFocusableViewId = (int)value.GetId();
1614             }
1615         }
1616
1617         /**
1618          * @brief The up focusable view.
1619          * @note This will return NULL if not set.
1620          * This will also return NULL if the specified up focusable view is not on stage.
1621          *
1622          */
1623         public View UpFocusableView
1624         {
1625             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1626             get
1627             {
1628                 if (UpFocusableViewId >= 0)
1629                 {
1630                     return ConvertIdToView((uint)UpFocusableViewId);
1631                 }
1632                 return null;
1633             }
1634             set
1635             {
1636                 UpFocusableViewId = (int)value.GetId();
1637             }
1638         }
1639
1640         /**
1641          * @brief The down focusable view.
1642          * @note This will return NULL if not set.
1643          * This will also return NULL if the specified down focusable view is not on stage.
1644          *
1645          */
1646         public View DownFocusableView
1647         {
1648             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1649             get
1650             {
1651                 if (DownFocusableViewId >= 0)
1652                 {
1653                     return ConvertIdToView((uint)DownFocusableViewId);
1654                 }
1655                 return null;
1656             }
1657             set
1658             {
1659                 DownFocusableViewId = (int)value.GetId();
1660             }
1661         }
1662
1663         public Position CurrentPosition
1664         {
1665             get
1666             {
1667                 return GetCurrentPosition();
1668             }
1669         }
1670
1671         public Size2D Size2D
1672         {
1673             get
1674             {
1675                 Size temp = new Size(0.0f, 0.0f, 0.0f);
1676                 GetProperty(View.Property.SIZE).Get(temp);
1677                 return new Size2D(temp);
1678             }
1679             set
1680             {
1681                 SetProperty(View.Property.SIZE, new Dali.Property.Value(new Size(value)));
1682             }
1683         }
1684
1685         public Size CurrentSize
1686         {
1687             get
1688             {
1689                 return GetCurrentSize();
1690             }
1691         }
1692
1693         public View Parent
1694         {
1695             get
1696             {
1697                 return GetParent();
1698             }
1699         }
1700
1701         public bool Visibility
1702         {
1703             get
1704             {
1705                 return IsVisible();
1706             }
1707         }
1708
1709         public float Opacity
1710         {
1711             get
1712             {
1713                 float temp = 0;
1714                 GetProperty(View.Property.OPACITY).Get(ref temp);
1715                 return temp;
1716             }
1717             set
1718             {
1719                 SetProperty(View.Property.OPACITY, new Dali.Property.Value(value));
1720             }
1721         }
1722
1723         public Position2D Position2D
1724         {
1725             get
1726             {
1727                 Position temp = new Position(0.0f, 0.0f, 0.0f);
1728                 GetProperty(View.Property.POSITION).Get(temp);
1729                 return new Position2D(temp);
1730             }
1731             set
1732             {
1733                 SetProperty(View.Property.POSITION, new Dali.Property.Value(new Position(value)));
1734             }
1735         }
1736
1737         public Vector2 ScreenPosition
1738         {
1739             get
1740             {
1741                 Vector2 temp = new Vector2(0.0f, 0.0f);
1742                 GetProperty(View.Property.SCREEN_POSITION).Get(temp);
1743                 return temp;
1744             }
1745         }
1746
1747         protected bool PositionUsesAnchorPoint
1748         {
1749             get
1750             {
1751                 bool temp = false;
1752                 GetProperty(View.Property.POSITION_USES_ANCHOR_POINT).Get(ref temp);
1753                 return temp;
1754             }
1755             set
1756             {
1757                 SetProperty(View.Property.POSITION_USES_ANCHOR_POINT, new Dali.Property.Value(value));
1758             }
1759         }
1760
1761         public bool StateFocusEnable
1762         {
1763             get
1764             {
1765                 return IsKeyboardFocusable();
1766             }
1767             set
1768             {
1769                 SetKeyboardFocusable(value);
1770             }
1771         }
1772
1773         public bool IsOnStage
1774         {
1775             get
1776             {
1777                 return OnStage();
1778             }
1779         }
1780
1781         public int SiblingOrder
1782         {
1783             get
1784             {
1785                 int temp = 0;
1786                 GetProperty(View.Property.SIBLING_ORDER).Get(ref temp);
1787                 return temp;
1788             }
1789             set
1790             {
1791                 SetProperty(View.Property.SIBLING_ORDER, new Dali.Property.Value(value));
1792             }
1793         }
1794
1795         public void Show()
1796         {
1797             SetVisible(true);
1798         }
1799
1800         public void Hide()
1801         {
1802             SetVisible(false);
1803         }
1804
1805         public void Raise()
1806         {
1807             NDalicPINVOKE.Raise(swigCPtr);
1808             if (NDalicPINVOKE.SWIGPendingException.Pending)
1809                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1810         }
1811
1812         public void Lower()
1813         {
1814             NDalicPINVOKE.Lower(swigCPtr);
1815             if (NDalicPINVOKE.SWIGPendingException.Pending)
1816                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1817         }
1818
1819         public void RaiseToTop()
1820         {
1821             NDalicPINVOKE.RaiseToTop(swigCPtr);
1822             if (NDalicPINVOKE.SWIGPendingException.Pending)
1823                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1824         }
1825
1826         public void LowerToBottom()
1827         {
1828             NDalicPINVOKE.LowerToBottom(swigCPtr);
1829             if (NDalicPINVOKE.SWIGPendingException.Pending)
1830                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1831         }
1832
1833         public void RaiseAbove(View target)
1834         {
1835             NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
1836             if (NDalicPINVOKE.SWIGPendingException.Pending)
1837                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1838         }
1839
1840         public void LowerBelow(View target)
1841         {
1842             NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
1843             if (NDalicPINVOKE.SWIGPendingException.Pending)
1844                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1845         }
1846
1847         public string GetName()
1848         {
1849             string ret = NDalicPINVOKE.Actor_GetName(swigCPtr);
1850             if (NDalicPINVOKE.SWIGPendingException.Pending)
1851                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1852             return ret;
1853         }
1854
1855         public void SetName(string name)
1856         {
1857             NDalicPINVOKE.Actor_SetName(swigCPtr, name);
1858             if (NDalicPINVOKE.SWIGPendingException.Pending)
1859                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1860         }
1861
1862         public uint GetId()
1863         {
1864             uint ret = NDalicPINVOKE.Actor_GetId(swigCPtr);
1865             if (NDalicPINVOKE.SWIGPendingException.Pending)
1866                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1867             return ret;
1868         }
1869
1870         public bool OnStage()
1871         {
1872             bool ret = NDalicPINVOKE.Actor_OnStage(swigCPtr);
1873             if (NDalicPINVOKE.SWIGPendingException.Pending)
1874                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1875             return ret;
1876         }
1877
1878         public Layer GetLayer()
1879         {
1880             Layer ret = new Layer(NDalicPINVOKE.Actor_GetLayer(swigCPtr), true);
1881             if (NDalicPINVOKE.SWIGPendingException.Pending)
1882                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1883             return ret;
1884         }
1885
1886         public void Add(View child)
1887         {
1888             NDalicPINVOKE.Actor_Add(swigCPtr, View.getCPtr(child));
1889             if (NDalicPINVOKE.SWIGPendingException.Pending)
1890                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1891         }
1892
1893         public void Remove(View child)
1894         {
1895             NDalicPINVOKE.Actor_Remove(swigCPtr, View.getCPtr(child));
1896             if (NDalicPINVOKE.SWIGPendingException.Pending)
1897                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1898         }
1899
1900         public void Unparent()
1901         {
1902             NDalicPINVOKE.Actor_Unparent(swigCPtr);
1903             if (NDalicPINVOKE.SWIGPendingException.Pending)
1904                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1905         }
1906
1907         public uint GetChildCount()
1908         {
1909             uint ret = NDalicPINVOKE.Actor_GetChildCount(swigCPtr);
1910             if (NDalicPINVOKE.SWIGPendingException.Pending)
1911                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1912             return ret;
1913         }
1914
1915         public View GetChildAt(uint index)
1916         {
1917             View ret = new View(NDalicPINVOKE.Actor_GetChildAt(swigCPtr, index), true);
1918             if (NDalicPINVOKE.SWIGPendingException.Pending)
1919                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1920             return ret;
1921         }
1922
1923         public View FindChildByName(string actorName)
1924         {
1925             View ret = new View(NDalicPINVOKE.Actor_FindChildByName(swigCPtr, actorName), true);
1926             if (NDalicPINVOKE.SWIGPendingException.Pending)
1927                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1928             return ret;
1929         }
1930
1931         public View FindChildById(uint id)
1932         {
1933             View ret = new View(NDalicPINVOKE.Actor_FindChildById(swigCPtr, id), true);
1934             if (NDalicPINVOKE.SWIGPendingException.Pending)
1935                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1936             return ret;
1937         }
1938
1939         public View GetParent()
1940         {
1941             View ret = new View(NDalicPINVOKE.Actor_GetParent(swigCPtr), true);
1942             if (NDalicPINVOKE.SWIGPendingException.Pending)
1943                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1944             return ret;
1945         }
1946
1947         public void SetParentOrigin(Vector3 origin)
1948         {
1949             NDalicPINVOKE.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));
1950             if (NDalicPINVOKE.SWIGPendingException.Pending)
1951                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1952         }
1953
1954         public Vector3 GetCurrentParentOrigin()
1955         {
1956             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentParentOrigin(swigCPtr), true);
1957             if (NDalicPINVOKE.SWIGPendingException.Pending)
1958                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1959             return ret;
1960         }
1961
1962         public void SetAnchorPoint(Vector3 anchorPoint)
1963         {
1964             NDalicPINVOKE.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
1965             if (NDalicPINVOKE.SWIGPendingException.Pending)
1966                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1967         }
1968
1969         public Vector3 GetCurrentAnchorPoint()
1970         {
1971             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentAnchorPoint(swigCPtr), true);
1972             if (NDalicPINVOKE.SWIGPendingException.Pending)
1973                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1974             return ret;
1975         }
1976
1977         public void SetSize(float width, float height)
1978         {
1979             NDalicPINVOKE.Actor_SetSize__SWIG_0(swigCPtr, width, height);
1980             if (NDalicPINVOKE.SWIGPendingException.Pending)
1981                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1982         }
1983
1984         public void SetSize(float width, float height, float depth)
1985         {
1986             NDalicPINVOKE.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);
1987             if (NDalicPINVOKE.SWIGPendingException.Pending)
1988                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1989         }
1990
1991         public void SetSize(Vector2 size)
1992         {
1993             NDalicPINVOKE.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));
1994             if (NDalicPINVOKE.SWIGPendingException.Pending)
1995                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1996         }
1997
1998         public void SetSize(Vector3 size)
1999         {
2000             NDalicPINVOKE.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));
2001             if (NDalicPINVOKE.SWIGPendingException.Pending)
2002                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2003         }
2004
2005         public Vector3 GetTargetSize()
2006         {
2007             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetTargetSize(swigCPtr), true);
2008             if (NDalicPINVOKE.SWIGPendingException.Pending)
2009                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2010             return ret;
2011         }
2012
2013         public Vector3 GetCurrentSize()
2014         {
2015             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentSize(swigCPtr), true);
2016             if (NDalicPINVOKE.SWIGPendingException.Pending)
2017                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2018             return ret;
2019         }
2020
2021         public Vector3 GetNaturalSize()
2022         {
2023             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
2024             if (NDalicPINVOKE.SWIGPendingException.Pending)
2025                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2026             return ret;
2027         }
2028
2029         public void SetPosition(float x, float y)
2030         {
2031             NDalicPINVOKE.Actor_SetPosition__SWIG_0(swigCPtr, x, y);
2032             if (NDalicPINVOKE.SWIGPendingException.Pending)
2033                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2034         }
2035
2036         public void SetPosition(float x, float y, float z)
2037         {
2038             NDalicPINVOKE.Actor_SetPosition__SWIG_1(swigCPtr, x, y, z);
2039             if (NDalicPINVOKE.SWIGPendingException.Pending)
2040                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2041         }
2042
2043         public void SetPosition(Vector3 position)
2044         {
2045             NDalicPINVOKE.Actor_SetPosition__SWIG_2(swigCPtr, Vector3.getCPtr(position));
2046             if (NDalicPINVOKE.SWIGPendingException.Pending)
2047                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2048         }
2049
2050         public void SetX(float x)
2051         {
2052             NDalicPINVOKE.Actor_SetX(swigCPtr, x);
2053             if (NDalicPINVOKE.SWIGPendingException.Pending)
2054                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2055         }
2056
2057         public void SetY(float y)
2058         {
2059             NDalicPINVOKE.Actor_SetY(swigCPtr, y);
2060             if (NDalicPINVOKE.SWIGPendingException.Pending)
2061                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2062         }
2063
2064         public void SetZ(float z)
2065         {
2066             NDalicPINVOKE.Actor_SetZ(swigCPtr, z);
2067             if (NDalicPINVOKE.SWIGPendingException.Pending)
2068                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2069         }
2070
2071         public void TranslateBy(Vector3 distance)
2072         {
2073             NDalicPINVOKE.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));
2074             if (NDalicPINVOKE.SWIGPendingException.Pending)
2075                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2076         }
2077
2078         public Vector3 GetCurrentPosition()
2079         {
2080             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentPosition(swigCPtr), true);
2081             if (NDalicPINVOKE.SWIGPendingException.Pending)
2082                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2083             return ret;
2084         }
2085
2086         public Vector3 GetCurrentWorldPosition()
2087         {
2088             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldPosition(swigCPtr), true);
2089             if (NDalicPINVOKE.SWIGPendingException.Pending)
2090                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2091             return ret;
2092         }
2093
2094         public void SetInheritPosition(bool inherit)
2095         {
2096             NDalicPINVOKE.Actor_SetInheritPosition(swigCPtr, inherit);
2097             if (NDalicPINVOKE.SWIGPendingException.Pending)
2098                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2099         }
2100
2101         public PositionInheritanceMode GetPositionInheritanceMode()
2102         {
2103             PositionInheritanceMode ret = (PositionInheritanceMode)NDalicPINVOKE.Actor_GetPositionInheritanceMode(swigCPtr);
2104             if (NDalicPINVOKE.SWIGPendingException.Pending)
2105                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2106             return ret;
2107         }
2108
2109         public bool IsPositionInherited()
2110         {
2111             bool ret = NDalicPINVOKE.Actor_IsPositionInherited(swigCPtr);
2112             if (NDalicPINVOKE.SWIGPendingException.Pending)
2113                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2114             return ret;
2115         }
2116
2117         public void SetOrientation(Degree angle, Vector3 axis)
2118         {
2119             NDalicPINVOKE.Actor_SetOrientation__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
2120             if (NDalicPINVOKE.SWIGPendingException.Pending)
2121                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2122         }
2123
2124         public void SetOrientation(Radian angle, Vector3 axis)
2125         {
2126             NDalicPINVOKE.Actor_SetOrientation__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
2127             if (NDalicPINVOKE.SWIGPendingException.Pending)
2128                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2129         }
2130
2131         public void SetOrientation(Rotation orientation)
2132         {
2133             NDalicPINVOKE.Actor_SetOrientation__SWIG_2(swigCPtr, Rotation.getCPtr(orientation));
2134             if (NDalicPINVOKE.SWIGPendingException.Pending)
2135                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2136         }
2137
2138         public void RotateBy(Degree angle, Vector3 axis)
2139         {
2140             NDalicPINVOKE.Actor_RotateBy__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
2141             if (NDalicPINVOKE.SWIGPendingException.Pending)
2142                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2143         }
2144
2145         public void RotateBy(Radian angle, Vector3 axis)
2146         {
2147             NDalicPINVOKE.Actor_RotateBy__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
2148             if (NDalicPINVOKE.SWIGPendingException.Pending)
2149                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2150         }
2151
2152         public void RotateBy(Rotation relativeRotation)
2153         {
2154             NDalicPINVOKE.Actor_RotateBy__SWIG_2(swigCPtr, Rotation.getCPtr(relativeRotation));
2155             if (NDalicPINVOKE.SWIGPendingException.Pending)
2156                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2157         }
2158
2159         public Rotation GetCurrentOrientation()
2160         {
2161             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentOrientation(swigCPtr), true);
2162             if (NDalicPINVOKE.SWIGPendingException.Pending)
2163                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2164             return ret;
2165         }
2166
2167         public void SetInheritOrientation(bool inherit)
2168         {
2169             NDalicPINVOKE.Actor_SetInheritOrientation(swigCPtr, inherit);
2170             if (NDalicPINVOKE.SWIGPendingException.Pending)
2171                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2172         }
2173
2174         public bool IsOrientationInherited()
2175         {
2176             bool ret = NDalicPINVOKE.Actor_IsOrientationInherited(swigCPtr);
2177             if (NDalicPINVOKE.SWIGPendingException.Pending)
2178                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2179             return ret;
2180         }
2181
2182         public Rotation GetCurrentWorldOrientation()
2183         {
2184             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentWorldOrientation(swigCPtr), true);
2185             if (NDalicPINVOKE.SWIGPendingException.Pending)
2186                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2187             return ret;
2188         }
2189
2190         public void SetScale(float scale)
2191         {
2192             NDalicPINVOKE.Actor_SetScale__SWIG_0(swigCPtr, scale);
2193             if (NDalicPINVOKE.SWIGPendingException.Pending)
2194                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2195         }
2196
2197         public void SetScale(float scaleX, float scaleY, float scaleZ)
2198         {
2199             NDalicPINVOKE.Actor_SetScale__SWIG_1(swigCPtr, scaleX, scaleY, scaleZ);
2200             if (NDalicPINVOKE.SWIGPendingException.Pending)
2201                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2202         }
2203
2204         public void SetScale(Vector3 scale)
2205         {
2206             NDalicPINVOKE.Actor_SetScale__SWIG_2(swigCPtr, Vector3.getCPtr(scale));
2207             if (NDalicPINVOKE.SWIGPendingException.Pending)
2208                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2209         }
2210
2211         public void ScaleBy(Vector3 relativeScale)
2212         {
2213             NDalicPINVOKE.Actor_ScaleBy(swigCPtr, Vector3.getCPtr(relativeScale));
2214             if (NDalicPINVOKE.SWIGPendingException.Pending)
2215                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2216         }
2217
2218         public Vector3 GetCurrentScale()
2219         {
2220             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentScale(swigCPtr), true);
2221             if (NDalicPINVOKE.SWIGPendingException.Pending)
2222                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2223             return ret;
2224         }
2225
2226         public Vector3 GetCurrentWorldScale()
2227         {
2228             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldScale(swigCPtr), true);
2229             if (NDalicPINVOKE.SWIGPendingException.Pending)
2230                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2231             return ret;
2232         }
2233
2234         public void SetInheritScale(bool inherit)
2235         {
2236             NDalicPINVOKE.Actor_SetInheritScale(swigCPtr, inherit);
2237             if (NDalicPINVOKE.SWIGPendingException.Pending)
2238                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2239         }
2240
2241         public bool IsScaleInherited()
2242         {
2243             bool ret = NDalicPINVOKE.Actor_IsScaleInherited(swigCPtr);
2244             if (NDalicPINVOKE.SWIGPendingException.Pending)
2245                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2246             return ret;
2247         }
2248
2249         public Matrix GetCurrentWorldMatrix()
2250         {
2251             Matrix ret = new Matrix(NDalicPINVOKE.Actor_GetCurrentWorldMatrix(swigCPtr), true);
2252             if (NDalicPINVOKE.SWIGPendingException.Pending)
2253                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2254             return ret;
2255         }
2256
2257         public void SetVisible(bool visible)
2258         {
2259             NDalicPINVOKE.Actor_SetVisible(swigCPtr, visible);
2260             if (NDalicPINVOKE.SWIGPendingException.Pending)
2261                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2262         }
2263
2264         public bool IsVisible()
2265         {
2266             bool ret = NDalicPINVOKE.Actor_IsVisible(swigCPtr);
2267             if (NDalicPINVOKE.SWIGPendingException.Pending)
2268                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2269             return ret;
2270         }
2271
2272         public void SetOpacity(float opacity)
2273         {
2274             NDalicPINVOKE.Actor_SetOpacity(swigCPtr, opacity);
2275             if (NDalicPINVOKE.SWIGPendingException.Pending)
2276                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2277         }
2278
2279         public float GetCurrentOpacity()
2280         {
2281             float ret = NDalicPINVOKE.Actor_GetCurrentOpacity(swigCPtr);
2282             if (NDalicPINVOKE.SWIGPendingException.Pending)
2283                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2284             return ret;
2285         }
2286
2287         public void SetColor(Vector4 color)
2288         {
2289             NDalicPINVOKE.Actor_SetColor(swigCPtr, Vector4.getCPtr(color));
2290             if (NDalicPINVOKE.SWIGPendingException.Pending)
2291                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2292         }
2293
2294         public Vector4 GetCurrentColor()
2295         {
2296             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentColor(swigCPtr), true);
2297             if (NDalicPINVOKE.SWIGPendingException.Pending)
2298                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2299             return ret;
2300         }
2301
2302         public void SetColorMode(ColorMode colorMode)
2303         {
2304             NDalicPINVOKE.Actor_SetColorMode(swigCPtr, (int)colorMode);
2305             if (NDalicPINVOKE.SWIGPendingException.Pending)
2306                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2307         }
2308
2309         public ColorMode GetColorMode()
2310         {
2311             ColorMode ret = (ColorMode)NDalicPINVOKE.Actor_GetColorMode(swigCPtr);
2312             if (NDalicPINVOKE.SWIGPendingException.Pending)
2313                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2314             return ret;
2315         }
2316
2317         public Vector4 GetCurrentWorldColor()
2318         {
2319             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentWorldColor(swigCPtr), true);
2320             if (NDalicPINVOKE.SWIGPendingException.Pending)
2321                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2322             return ret;
2323         }
2324
2325         public void SetDrawMode(DrawModeType drawMode)
2326         {
2327             NDalicPINVOKE.Actor_SetDrawMode(swigCPtr, (int)drawMode);
2328             if (NDalicPINVOKE.SWIGPendingException.Pending)
2329                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2330         }
2331
2332         public DrawModeType GetDrawMode()
2333         {
2334             DrawModeType ret = (DrawModeType)NDalicPINVOKE.Actor_GetDrawMode(swigCPtr);
2335             if (NDalicPINVOKE.SWIGPendingException.Pending)
2336                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2337             return ret;
2338         }
2339
2340         public void SetSensitive(bool sensitive)
2341         {
2342             NDalicPINVOKE.Actor_SetSensitive(swigCPtr, sensitive);
2343             if (NDalicPINVOKE.SWIGPendingException.Pending)
2344                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2345         }
2346
2347         public bool IsSensitive()
2348         {
2349             bool ret = NDalicPINVOKE.Actor_IsSensitive(swigCPtr);
2350             if (NDalicPINVOKE.SWIGPendingException.Pending)
2351                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2352             return ret;
2353         }
2354
2355         public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY)
2356         {
2357             bool ret = NDalicPINVOKE.Actor_ScreenToLocal(swigCPtr, out localX, out localY, screenX, screenY);
2358             if (NDalicPINVOKE.SWIGPendingException.Pending)
2359                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2360             return ret;
2361         }
2362
2363         public void SetLeaveRequired(bool required)
2364         {
2365             NDalicPINVOKE.Actor_SetLeaveRequired(swigCPtr, required);
2366             if (NDalicPINVOKE.SWIGPendingException.Pending)
2367                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2368         }
2369
2370         public bool GetLeaveRequired()
2371         {
2372             bool ret = NDalicPINVOKE.Actor_GetLeaveRequired(swigCPtr);
2373             if (NDalicPINVOKE.SWIGPendingException.Pending)
2374                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2375             return ret;
2376         }
2377
2378         public void SetKeyboardFocusable(bool focusable)
2379         {
2380             NDalicPINVOKE.Actor_SetKeyboardFocusable(swigCPtr, focusable);
2381             if (NDalicPINVOKE.SWIGPendingException.Pending)
2382                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2383         }
2384
2385         public bool IsKeyboardFocusable()
2386         {
2387             bool ret = NDalicPINVOKE.Actor_IsKeyboardFocusable(swigCPtr);
2388             if (NDalicPINVOKE.SWIGPendingException.Pending)
2389                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2390             return ret;
2391         }
2392
2393         public void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)
2394         {
2395             NDalicPINVOKE.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
2396             if (NDalicPINVOKE.SWIGPendingException.Pending)
2397                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2398         }
2399
2400         public ResizePolicyType GetResizePolicy(DimensionType dimension)
2401         {
2402             ResizePolicyType ret = (ResizePolicyType)NDalicPINVOKE.Actor_GetResizePolicy(swigCPtr, (int)dimension);
2403             if (NDalicPINVOKE.SWIGPendingException.Pending)
2404                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2405             return ret;
2406         }
2407
2408         public void SetSizeScalePolicy(SizeScalePolicyType policy)
2409         {
2410             NDalicPINVOKE.Actor_SetSizeScalePolicy(swigCPtr, (int)policy);
2411             if (NDalicPINVOKE.SWIGPendingException.Pending)
2412                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2413         }
2414
2415         public SizeScalePolicyType GetSizeScalePolicy()
2416         {
2417             SizeScalePolicyType ret = (SizeScalePolicyType)NDalicPINVOKE.Actor_GetSizeScalePolicy(swigCPtr);
2418             if (NDalicPINVOKE.SWIGPendingException.Pending)
2419                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2420             return ret;
2421         }
2422
2423         public void SetSizeModeFactor(Vector3 factor)
2424         {
2425             NDalicPINVOKE.Actor_SetSizeModeFactor(swigCPtr, Vector3.getCPtr(factor));
2426             if (NDalicPINVOKE.SWIGPendingException.Pending)
2427                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2428         }
2429
2430         public Vector3 GetSizeModeFactor()
2431         {
2432             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetSizeModeFactor(swigCPtr), true);
2433             if (NDalicPINVOKE.SWIGPendingException.Pending)
2434                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2435             return ret;
2436         }
2437
2438         public float GetHeightForWidth(float width)
2439         {
2440             float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);
2441             if (NDalicPINVOKE.SWIGPendingException.Pending)
2442                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2443             return ret;
2444         }
2445
2446         public float GetWidthForHeight(float height)
2447         {
2448             float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);
2449             if (NDalicPINVOKE.SWIGPendingException.Pending)
2450                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2451             return ret;
2452         }
2453
2454         public float GetRelayoutSize(DimensionType dimension)
2455         {
2456             float ret = NDalicPINVOKE.Actor_GetRelayoutSize(swigCPtr, (int)dimension);
2457             if (NDalicPINVOKE.SWIGPendingException.Pending)
2458                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2459             return ret;
2460         }
2461
2462         public void SetPadding(PaddingType padding)
2463         {
2464             NDalicPINVOKE.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));
2465             if (NDalicPINVOKE.SWIGPendingException.Pending)
2466                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2467         }
2468
2469         public void GetPadding(PaddingType paddingOut)
2470         {
2471             NDalicPINVOKE.Actor_GetPadding(swigCPtr, PaddingType.getCPtr(paddingOut));
2472             if (NDalicPINVOKE.SWIGPendingException.Pending)
2473                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2474         }
2475
2476         public void SetMinimumSize(Vector2 size)
2477         {
2478             NDalicPINVOKE.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));
2479             if (NDalicPINVOKE.SWIGPendingException.Pending)
2480                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2481         }
2482
2483         public Vector2 GetMinimumSize()
2484         {
2485             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMinimumSize(swigCPtr), true);
2486             if (NDalicPINVOKE.SWIGPendingException.Pending)
2487                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2488             return ret;
2489         }
2490
2491         public void SetMaximumSize(Vector2 size)
2492         {
2493             NDalicPINVOKE.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));
2494             if (NDalicPINVOKE.SWIGPendingException.Pending)
2495                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2496         }
2497
2498         public Vector2 GetMaximumSize()
2499         {
2500             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMaximumSize(swigCPtr), true);
2501             if (NDalicPINVOKE.SWIGPendingException.Pending)
2502                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2503             return ret;
2504         }
2505
2506         public int GetHierarchyDepth()
2507         {
2508             int ret = NDalicPINVOKE.Actor_GetHierarchyDepth(swigCPtr);
2509             if (NDalicPINVOKE.SWIGPendingException.Pending)
2510                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2511             return ret;
2512         }
2513
2514         public uint AddRenderer(Renderer renderer)
2515         {
2516             uint ret = NDalicPINVOKE.Actor_AddRenderer(swigCPtr, Renderer.getCPtr(renderer));
2517             if (NDalicPINVOKE.SWIGPendingException.Pending)
2518                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2519             return ret;
2520         }
2521
2522         public uint GetRendererCount()
2523         {
2524             uint ret = NDalicPINVOKE.Actor_GetRendererCount(swigCPtr);
2525             if (NDalicPINVOKE.SWIGPendingException.Pending)
2526                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2527             return ret;
2528         }
2529
2530         public Renderer GetRendererAt(uint index)
2531         {
2532             Renderer ret = new Renderer(NDalicPINVOKE.Actor_GetRendererAt(swigCPtr, index), true);
2533             if (NDalicPINVOKE.SWIGPendingException.Pending)
2534                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2535             return ret;
2536         }
2537
2538         public void RemoveRenderer(Renderer renderer)
2539         {
2540             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_0(swigCPtr, Renderer.getCPtr(renderer));
2541             if (NDalicPINVOKE.SWIGPendingException.Pending)
2542                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2543         }
2544
2545         public void RemoveRenderer(uint index)
2546         {
2547             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_1(swigCPtr, index);
2548             if (NDalicPINVOKE.SWIGPendingException.Pending)
2549                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2550         }
2551
2552         internal TouchDataSignal TouchSignal()
2553         {
2554             TouchDataSignal ret = new TouchDataSignal(NDalicPINVOKE.Actor_TouchSignal(swigCPtr), false);
2555             if (NDalicPINVOKE.SWIGPendingException.Pending)
2556                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2557             return ret;
2558         }
2559
2560         internal HoverSignal HoveredSignal()
2561         {
2562             HoverSignal ret = new HoverSignal(NDalicPINVOKE.Actor_HoveredSignal(swigCPtr), false);
2563             if (NDalicPINVOKE.SWIGPendingException.Pending)
2564                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2565             return ret;
2566         }
2567
2568         internal WheelSignal WheelEventSignal()
2569         {
2570             WheelSignal ret = new WheelSignal(NDalicPINVOKE.Actor_WheelEventSignal(swigCPtr), false);
2571             if (NDalicPINVOKE.SWIGPendingException.Pending)
2572                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2573             return ret;
2574         }
2575
2576         public ViewSignal OnStageSignal()
2577         {
2578             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnStageSignal(swigCPtr), false);
2579             if (NDalicPINVOKE.SWIGPendingException.Pending)
2580                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2581             return ret;
2582         }
2583
2584         public ViewSignal OffStageSignal()
2585         {
2586             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OffStageSignal(swigCPtr), false);
2587             if (NDalicPINVOKE.SWIGPendingException.Pending)
2588                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2589             return ret;
2590         }
2591
2592         public ViewSignal OnRelayoutSignal()
2593         {
2594             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnRelayoutSignal(swigCPtr), false);
2595             if (NDalicPINVOKE.SWIGPendingException.Pending)
2596                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2597             return ret;
2598         }
2599
2600         public Vector3 ParentOrigin
2601         {
2602             get
2603             {
2604                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2605                 GetProperty(View.Property.PARENT_ORIGIN).Get(temp);
2606                 return temp;
2607             }
2608             set
2609             {
2610                 SetProperty(View.Property.PARENT_ORIGIN, new Dali.Property.Value(value));
2611             }
2612         }
2613
2614         public float ParentOriginX
2615         {
2616             get
2617             {
2618                 float temp = 0.0f;
2619                 GetProperty(View.Property.PARENT_ORIGIN_X).Get(ref temp);
2620                 return temp;
2621             }
2622             set
2623             {
2624                 SetProperty(View.Property.PARENT_ORIGIN_X, new Dali.Property.Value(value));
2625             }
2626         }
2627
2628         public float ParentOriginY
2629         {
2630             get
2631             {
2632                 float temp = 0.0f;
2633                 GetProperty(View.Property.PARENT_ORIGIN_Y).Get(ref temp);
2634                 return temp;
2635             }
2636             set
2637             {
2638                 SetProperty(View.Property.PARENT_ORIGIN_Y, new Dali.Property.Value(value));
2639             }
2640         }
2641
2642         public float ParentOriginZ
2643         {
2644             get
2645             {
2646                 float temp = 0.0f;
2647                 GetProperty(View.Property.PARENT_ORIGIN_Z).Get(ref temp);
2648                 return temp;
2649             }
2650             set
2651             {
2652                 SetProperty(View.Property.PARENT_ORIGIN_Z, new Dali.Property.Value(value));
2653             }
2654         }
2655
2656         public Vector3 AnchorPoint
2657         {
2658             get
2659             {
2660                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2661                 GetProperty(View.Property.ANCHOR_POINT).Get(temp);
2662                 return temp;
2663             }
2664             set
2665             {
2666                 SetProperty(View.Property.ANCHOR_POINT, new Dali.Property.Value(value));
2667             }
2668         }
2669
2670         public float AnchorPointX
2671         {
2672             get
2673             {
2674                 float temp = 0.0f;
2675                 GetProperty(View.Property.ANCHOR_POINT_X).Get(ref temp);
2676                 return temp;
2677             }
2678             set
2679             {
2680                 SetProperty(View.Property.ANCHOR_POINT_X, new Dali.Property.Value(value));
2681             }
2682         }
2683
2684         public float AnchorPointY
2685         {
2686             get
2687             {
2688                 float temp = 0.0f;
2689                 GetProperty(View.Property.ANCHOR_POINT_Y).Get(ref temp);
2690                 return temp;
2691             }
2692             set
2693             {
2694                 SetProperty(View.Property.ANCHOR_POINT_Y, new Dali.Property.Value(value));
2695             }
2696         }
2697
2698         public float AnchorPointZ
2699         {
2700             get
2701             {
2702                 float temp = 0.0f;
2703                 GetProperty(View.Property.ANCHOR_POINT_Z).Get(ref temp);
2704                 return temp;
2705             }
2706             set
2707             {
2708                 SetProperty(View.Property.ANCHOR_POINT_Z, new Dali.Property.Value(value));
2709             }
2710         }
2711
2712         public Vector3 Size
2713         {
2714             get
2715             {
2716                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2717                 GetProperty(View.Property.SIZE).Get(temp);
2718                 return temp;
2719             }
2720             set
2721             {
2722                 SetProperty(View.Property.SIZE, new Dali.Property.Value(value));
2723             }
2724         }
2725
2726         public float SizeWidth
2727         {
2728             get
2729             {
2730                 float temp = 0.0f;
2731                 GetProperty(View.Property.SIZE_WIDTH).Get(ref temp);
2732                 return temp;
2733             }
2734             set
2735             {
2736                 SetProperty(View.Property.SIZE_WIDTH, new Dali.Property.Value(value));
2737             }
2738         }
2739
2740         public float SizeHeight
2741         {
2742             get
2743             {
2744                 float temp = 0.0f;
2745                 GetProperty(View.Property.SIZE_HEIGHT).Get(ref temp);
2746                 return temp;
2747             }
2748             set
2749             {
2750                 SetProperty(View.Property.SIZE_HEIGHT, new Dali.Property.Value(value));
2751             }
2752         }
2753
2754         public float SizeDepth
2755         {
2756             get
2757             {
2758                 float temp = 0.0f;
2759                 GetProperty(View.Property.SIZE_DEPTH).Get(ref temp);
2760                 return temp;
2761             }
2762             set
2763             {
2764                 SetProperty(View.Property.SIZE_DEPTH, new Dali.Property.Value(value));
2765             }
2766         }
2767
2768         public Vector3 Position
2769         {
2770             get
2771             {
2772                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2773                 GetProperty(View.Property.POSITION).Get(temp);
2774                 return temp;
2775             }
2776             set
2777             {
2778                 SetProperty(View.Property.POSITION, new Dali.Property.Value(value));
2779             }
2780         }
2781
2782         public float PositionX
2783         {
2784             get
2785             {
2786                 float temp = 0.0f;
2787                 GetProperty(View.Property.POSITION_X).Get(ref temp);
2788                 return temp;
2789             }
2790             set
2791             {
2792                 SetProperty(View.Property.POSITION_X, new Dali.Property.Value(value));
2793             }
2794         }
2795
2796         public float PositionY
2797         {
2798             get
2799             {
2800                 float temp = 0.0f;
2801                 GetProperty(View.Property.POSITION_Y).Get(ref temp);
2802                 return temp;
2803             }
2804             set
2805             {
2806                 SetProperty(View.Property.POSITION_Y, new Dali.Property.Value(value));
2807             }
2808         }
2809
2810         public float PositionZ
2811         {
2812             get
2813             {
2814                 float temp = 0.0f;
2815                 GetProperty(View.Property.POSITION_Z).Get(ref temp);
2816                 return temp;
2817             }
2818             set
2819             {
2820                 SetProperty(View.Property.POSITION_Z, new Dali.Property.Value(value));
2821             }
2822         }
2823
2824         public Vector3 WorldPosition
2825         {
2826             get
2827             {
2828                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2829                 GetProperty(View.Property.WORLD_POSITION).Get(temp);
2830                 return temp;
2831             }
2832         }
2833
2834         public float WorldPositionX
2835         {
2836             get
2837             {
2838                 float temp = 0.0f;
2839                 GetProperty(View.Property.WORLD_POSITION_X).Get(ref temp);
2840                 return temp;
2841             }
2842         }
2843
2844         public float WorldPositionY
2845         {
2846             get
2847             {
2848                 float temp = 0.0f;
2849                 GetProperty(View.Property.WORLD_POSITION_Y).Get(ref temp);
2850                 return temp;
2851             }
2852         }
2853
2854         public float WorldPositionZ
2855         {
2856             get
2857             {
2858                 float temp = 0.0f;
2859                 GetProperty(View.Property.WORLD_POSITION_Z).Get(ref temp);
2860                 return temp;
2861             }
2862         }
2863
2864         public Rotation Orientation
2865         {
2866             get
2867             {
2868                 Rotation temp = new Rotation();
2869                 GetProperty(View.Property.ORIENTATION).Get(temp);
2870                 return temp;
2871             }
2872             set
2873             {
2874                 SetProperty(View.Property.ORIENTATION, new Dali.Property.Value(value));
2875             }
2876         }
2877
2878         public Rotation WorldOrientation
2879         {
2880             get
2881             {
2882                 Rotation temp = new Rotation();
2883                 GetProperty(View.Property.WORLD_ORIENTATION).Get(temp);
2884                 return temp;
2885             }
2886         }
2887
2888         public Vector3 Scale
2889         {
2890             get
2891             {
2892                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2893                 GetProperty(View.Property.SCALE).Get(temp);
2894                 return temp;
2895             }
2896             set
2897             {
2898                 SetProperty(View.Property.SCALE, new Dali.Property.Value(value));
2899             }
2900         }
2901
2902         public float ScaleX
2903         {
2904             get
2905             {
2906                 float temp = 0.0f;
2907                 GetProperty(View.Property.SCALE_X).Get(ref temp);
2908                 return temp;
2909             }
2910             set
2911             {
2912                 SetProperty(View.Property.SCALE_X, new Dali.Property.Value(value));
2913             }
2914         }
2915
2916         public float ScaleY
2917         {
2918             get
2919             {
2920                 float temp = 0.0f;
2921                 GetProperty(View.Property.SCALE_Y).Get(ref temp);
2922                 return temp;
2923             }
2924             set
2925             {
2926                 SetProperty(View.Property.SCALE_Y, new Dali.Property.Value(value));
2927             }
2928         }
2929
2930         public float ScaleZ
2931         {
2932             get
2933             {
2934                 float temp = 0.0f;
2935                 GetProperty(View.Property.SCALE_Z).Get(ref temp);
2936                 return temp;
2937             }
2938             set
2939             {
2940                 SetProperty(View.Property.SCALE_Z, new Dali.Property.Value(value));
2941             }
2942         }
2943
2944         public Vector3 WorldScale
2945         {
2946             get
2947             {
2948                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2949                 GetProperty(View.Property.WORLD_SCALE).Get(temp);
2950                 return temp;
2951             }
2952         }
2953
2954         public bool Visible
2955         {
2956             get
2957             {
2958                 bool temp = false;
2959                 GetProperty(View.Property.VISIBLE).Get(ref temp);
2960                 return temp;
2961             }
2962             set
2963             {
2964                 SetProperty(View.Property.VISIBLE, new Dali.Property.Value(value));
2965             }
2966         }
2967
2968         public float ColorRed
2969         {
2970             get
2971             {
2972                 float temp = 0.0f;
2973                 GetProperty(View.Property.COLOR_RED).Get(ref temp);
2974                 return temp;
2975             }
2976             set
2977             {
2978                 SetProperty(View.Property.COLOR_RED, new Dali.Property.Value(value));
2979             }
2980         }
2981
2982         public float ColorGreen
2983         {
2984             get
2985             {
2986                 float temp = 0.0f;
2987                 GetProperty(View.Property.COLOR_GREEN).Get(ref temp);
2988                 return temp;
2989             }
2990             set
2991             {
2992                 SetProperty(View.Property.COLOR_GREEN, new Dali.Property.Value(value));
2993             }
2994         }
2995
2996         public float ColorBlue
2997         {
2998             get
2999             {
3000                 float temp = 0.0f;
3001                 GetProperty(View.Property.COLOR_BLUE).Get(ref temp);
3002                 return temp;
3003             }
3004             set
3005             {
3006                 SetProperty(View.Property.COLOR_BLUE, new Dali.Property.Value(value));
3007             }
3008         }
3009
3010         public float ColorAlpha
3011         {
3012             get
3013             {
3014                 float temp = 0.0f;
3015                 GetProperty(View.Property.COLOR_ALPHA).Get(ref temp);
3016                 return temp;
3017             }
3018             set
3019             {
3020                 SetProperty(View.Property.COLOR_ALPHA, new Dali.Property.Value(value));
3021             }
3022         }
3023
3024         public Vector4 WorldColor
3025         {
3026             get
3027             {
3028                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
3029                 GetProperty(View.Property.WORLD_COLOR).Get(temp);
3030                 return temp;
3031             }
3032         }
3033
3034         public Matrix WorldMatrix
3035         {
3036             get
3037             {
3038                 Matrix temp = new Matrix();
3039                 GetProperty(View.Property.WORLD_MATRIX).Get(temp);
3040                 return temp;
3041             }
3042         }
3043
3044         public string Name
3045         {
3046             get
3047             {
3048                 string temp;
3049                 GetProperty(View.Property.NAME).Get(out temp);
3050                 return temp;
3051             }
3052             set
3053             {
3054                 SetProperty(View.Property.NAME, new Dali.Property.Value(value));
3055             }
3056         }
3057
3058         public bool Sensitive
3059         {
3060             get
3061             {
3062                 bool temp = false;
3063                 GetProperty(View.Property.SENSITIVE).Get(ref temp);
3064                 return temp;
3065             }
3066             set
3067             {
3068                 SetProperty(View.Property.SENSITIVE, new Dali.Property.Value(value));
3069             }
3070         }
3071
3072         public bool LeaveRequired
3073         {
3074             get
3075             {
3076                 bool temp = false;
3077                 GetProperty(View.Property.LEAVE_REQUIRED).Get(ref temp);
3078                 return temp;
3079             }
3080             set
3081             {
3082                 SetProperty(View.Property.LEAVE_REQUIRED, new Dali.Property.Value(value));
3083             }
3084         }
3085
3086         public bool InheritOrientation
3087         {
3088             get
3089             {
3090                 bool temp = false;
3091                 GetProperty(View.Property.INHERIT_ORIENTATION).Get(ref temp);
3092                 return temp;
3093             }
3094             set
3095             {
3096                 SetProperty(View.Property.INHERIT_ORIENTATION, new Dali.Property.Value(value));
3097             }
3098         }
3099
3100         public bool InheritScale
3101         {
3102             get
3103             {
3104                 bool temp = false;
3105                 GetProperty(View.Property.INHERIT_SCALE).Get(ref temp);
3106                 return temp;
3107             }
3108             set
3109             {
3110                 SetProperty(View.Property.INHERIT_SCALE, new Dali.Property.Value(value));
3111             }
3112         }
3113
3114         public string ColorMode
3115         {
3116             get
3117             {
3118                 string temp;
3119                 GetProperty(View.Property.COLOR_MODE).Get(out temp);
3120                 return temp;
3121             }
3122             set
3123             {
3124                 SetProperty(View.Property.COLOR_MODE, new Dali.Property.Value(value));
3125             }
3126         }
3127
3128         public string PositionInheritance
3129         {
3130             get
3131             {
3132                 string temp;
3133                 GetProperty(View.Property.POSITION_INHERITANCE).Get(out temp);
3134                 return temp;
3135             }
3136             set
3137             {
3138                 SetProperty(View.Property.POSITION_INHERITANCE, new Dali.Property.Value(value));
3139             }
3140         }
3141
3142         public string DrawMode
3143         {
3144             get
3145             {
3146                 string temp;
3147                 GetProperty(View.Property.DRAW_MODE).Get(out temp);
3148                 return temp;
3149             }
3150             set
3151             {
3152                 SetProperty(View.Property.DRAW_MODE, new Dali.Property.Value(value));
3153             }
3154         }
3155
3156         public Vector3 SizeModeFactor
3157         {
3158             get
3159             {
3160                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3161                 GetProperty(View.Property.SIZE_MODE_FACTOR).Get(temp);
3162                 return temp;
3163             }
3164             set
3165             {
3166                 SetProperty(View.Property.SIZE_MODE_FACTOR, new Dali.Property.Value(value));
3167             }
3168         }
3169
3170         public string WidthResizePolicy
3171         {
3172             get
3173             {
3174                 string temp;
3175                 GetProperty(View.Property.WIDTH_RESIZE_POLICY).Get(out temp);
3176                 return temp;
3177             }
3178             set
3179             {
3180                 SetProperty(View.Property.WIDTH_RESIZE_POLICY, new Dali.Property.Value(value));
3181             }
3182         }
3183
3184         public string HeightResizePolicy
3185         {
3186             get
3187             {
3188                 string temp;
3189                 GetProperty(View.Property.HEIGHT_RESIZE_POLICY).Get(out temp);
3190                 return temp;
3191             }
3192             set
3193             {
3194                 SetProperty(View.Property.HEIGHT_RESIZE_POLICY, new Dali.Property.Value(value));
3195             }
3196         }
3197
3198         public string SizeScalePolicy
3199         {
3200             get
3201             {
3202                 string temp;
3203                 GetProperty(View.Property.SIZE_SCALE_POLICY).Get(out temp);
3204                 return temp;
3205             }
3206             set
3207             {
3208                 SetProperty(View.Property.SIZE_SCALE_POLICY, new Dali.Property.Value(value));
3209             }
3210         }
3211
3212         public bool WidthForHeight
3213         {
3214             get
3215             {
3216                 bool temp = false;
3217                 GetProperty(View.Property.WIDTH_FOR_HEIGHT).Get(ref temp);
3218                 return temp;
3219             }
3220             set
3221             {
3222                 SetProperty(View.Property.WIDTH_FOR_HEIGHT, new Dali.Property.Value(value));
3223             }
3224         }
3225
3226         public bool HeightForWidth
3227         {
3228             get
3229             {
3230                 bool temp = false;
3231                 GetProperty(View.Property.HEIGHT_FOR_WIDTH).Get(ref temp);
3232                 return temp;
3233             }
3234             set
3235             {
3236                 SetProperty(View.Property.HEIGHT_FOR_WIDTH, new Dali.Property.Value(value));
3237             }
3238         }
3239
3240         public Vector4 Padding
3241         {
3242             get
3243             {
3244                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
3245                 GetProperty(View.Property.PADDING).Get(temp);
3246                 return temp;
3247             }
3248             set
3249             {
3250                 SetProperty(View.Property.PADDING, new Dali.Property.Value(value));
3251             }
3252         }
3253
3254         public Vector2 MinimumSize
3255         {
3256             get
3257             {
3258                 Vector2 temp = new Vector2(0.0f, 0.0f);
3259                 GetProperty(View.Property.MINIMUM_SIZE).Get(temp);
3260                 return temp;
3261             }
3262             set
3263             {
3264                 SetProperty(View.Property.MINIMUM_SIZE, new Dali.Property.Value(value));
3265             }
3266         }
3267
3268         public Vector2 MaximumSize
3269         {
3270             get
3271             {
3272                 Vector2 temp = new Vector2(0.0f, 0.0f);
3273                 GetProperty(View.Property.MAXIMUM_SIZE).Get(temp);
3274                 return temp;
3275             }
3276             set
3277             {
3278                 SetProperty(View.Property.MAXIMUM_SIZE, new Dali.Property.Value(value));
3279             }
3280         }
3281
3282         public bool InheritPosition
3283         {
3284             get
3285             {
3286                 bool temp = false;
3287                 GetProperty(View.Property.INHERIT_POSITION).Get(ref temp);
3288                 return temp;
3289             }
3290             set
3291             {
3292                 SetProperty(View.Property.INHERIT_POSITION, new Dali.Property.Value(value));
3293             }
3294         }
3295
3296         public string ClippingMode
3297         {
3298             get
3299             {
3300                 string temp;
3301                 GetProperty(View.Property.CLIPPING_MODE).Get(out temp);
3302                 return temp;
3303             }
3304             set
3305             {
3306                 SetProperty(View.Property.CLIPPING_MODE, new Dali.Property.Value(value));
3307             }
3308         }
3309     }
3310 }