plugins/dali-sharp/sharp/public/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 (!Window.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 OnWindow signal
 320          *
 321          */
 322         public class OnWindowEventArgs : EventArgs
 323         {
 324             private View _view;
 325
 326             /**
 327              * @brief View - is the view that is being connected to the window
 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 OffWindow signal
 345          *
 346          */
 347         public class OffWindowEventArgs : EventArgs
 348         {
 349             private View _view;
 350
 351             /**
 352              * @brief View - is the view that is being disconnected from the window
 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 OnWindowEventCallbackDelegate(IntPtr control);
 412
 413         private DaliEventHandler<object,OnWindowEventArgs> _viewOnWindowEventHandler;
 414         private OnWindowEventCallbackDelegate _viewOnWindowEventCallbackDelegate;
 415
 416         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 417         private delegate void OffWindowEventCallbackDelegate(IntPtr control);
 418
 419         private DaliEventHandler<object,OffWindowEventArgs> _viewOffWindowEventHandler;
 420         private OffWindowEventCallbackDelegate _viewOffWindowEventCallbackDelegate;
 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> FocusGained
 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(OnFocusGained);
 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 OnFocusGained(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> FocusLost
 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(OnFocusLost);
 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 OnFocusLost(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> Relayout
 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> WheelRolled
 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 OnWindow signal which can be used to subscribe/unsubscribe the event handler
 791          * (in the type of OnWindowEventHandler) provided by the user.
 792          * OnWindow signal is emitted after the view has been connected to the window.
 793          */
 794         public event DaliEventHandler<object,OnWindowEventArgs> AddedToWindow
 795         {
 796             add
 797             {
 798                 lock (this)
 799                 {
 800                     // Restricted to only one listener
 801                     if (_viewOnWindowEventHandler == null)
 802                     {
 803                         _viewOnWindowEventHandler += value;
 804
 805                         _viewOnWindowEventCallbackDelegate = new OnWindowEventCallbackDelegate(OnWindow);
 806                         this.OnWindowSignal().Connect(_viewOnWindowEventCallbackDelegate);
 807                     }
 808                 }
 809             }
 810
 811             remove
 812             {
 813                 lock (this)
 814                 {
 815                     if (_viewOnWindowEventHandler != null)
 816                     {
 817                         this.OnWindowSignal().Disconnect(_viewOnWindowEventCallbackDelegate);
 818                     }
 819
 820                     _viewOnWindowEventHandler -= value;
 821                 }
 822             }
 823         }
 824
 825         // Callback for View OnWindow signal
 826         private void OnWindow(IntPtr data)
 827         {
 828             OnWindowEventArgs e = new OnWindowEventArgs();
 829
 830             // Populate all members of "e" (OnWindowEventArgs) with real data
 831             e.View = View.GetViewFromPtr(data);
 832
 833             //Console.WriteLine("############# OnWindow()! e.View.Name=" + e.View.Name);
 834
 835             if (_viewOnWindowEventHandler != null)
 836             {
 837                 //here we send all data to user event handlers
 838                 _viewOnWindowEventHandler(this, e);
 839             }
 840         }
 841
 842         /**
 843          * @brief Event for OffWindow signal which can be used to subscribe/unsubscribe the event handler
 844          * (in the type of OffWindowEventHandler) provided by the user.
 845          * OffWindow signal is emitted after the view has been disconnected from the window.
 846          */
 847         public event DaliEventHandler<object,OffWindowEventArgs> RemovedFromWindow
 848         {
 849             add
 850             {
 851                 lock (this)
 852                 {
 853                     // Restricted to only one listener
 854                     if (_viewOffWindowEventHandler == null)
 855                     {
 856                         _viewOffWindowEventHandler += value;
 857
 858                         _viewOffWindowEventCallbackDelegate = new OffWindowEventCallbackDelegate(OffWindow);
 859                         this.OnWindowSignal().Connect(_viewOffWindowEventCallbackDelegate);
 860                     }
 861                 }
 862             }
 863
 864             remove
 865             {
 866                 lock (this)
 867                 {
 868                     if (_viewOffWindowEventHandler != null)
 869                     {
 870                         this.OnWindowSignal().Disconnect(_viewOffWindowEventCallbackDelegate);
 871                     }
 872
 873                     _viewOffWindowEventHandler -= value;
 874                 }
 875             }
 876         }
 877
 878         // Callback for View OffWindow signal
 879         private void OffWindow(IntPtr data)
 880         {
 881             OffWindowEventArgs e = new OffWindowEventArgs();
 882
 883             // Populate all members of "e" (OffWindowEventArgs) with real data
 884             e.View = View.GetViewFromPtr(data);
 885
 886             if (_viewOffWindowEventHandler != null)
 887             {
 888                 //here we send all data to user event handlers
 889                 _viewOffWindowEventHandler(this, e);
 890             }
 891         }
 892
 893         internal 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         internal IntPtr GetPtrfromView()
 902         {
 903             return (IntPtr)swigCPtr;
 904         }
 905
 906         public class Property
 907         {
 908             internal static readonly int TOOLTIP = NDalicManualPINVOKE.View_Property_TOOLTIP_get();
 909             internal static readonly int STATE = NDalicManualPINVOKE.View_Property_STATE_get();
 910             internal static readonly int SUB_STATE = NDalicManualPINVOKE.View_Property_SUB_STATE_get();
 911             internal static readonly int LEFT_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_LEFT_FOCUSABLE_ACTOR_ID_get();
 912             internal static readonly int RIGHT_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_RIGHT_FOCUSABLE_ACTOR_ID_get();
 913             internal static readonly int UP_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_UP_FOCUSABLE_ACTOR_ID_get();
 914             internal static readonly int DOWN_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_DOWN_FOCUSABLE_ACTOR_ID_get();
 915             internal static readonly int KEY_INPUT_FOCUS = NDalicPINVOKE.View_Property_KEY_INPUT_FOCUS_get();
 916             internal static readonly int STYLE_NAME = NDalicPINVOKE.View_Property_STYLE_NAME_get();
 917             internal static readonly int BACKGROUND = NDalicPINVOKE.View_Property_BACKGROUND_get();
 918
 919
 920             internal static readonly int SIBLING_ORDER = NDalicManualPINVOKE.Actor_Property_SIBLING_ORDER_get();
 921             public static readonly int OPACITY = NDalicManualPINVOKE.Actor_Property_OPACITY_get();
 922             internal static readonly int SCREEN_POSITION = NDalicManualPINVOKE.Actor_Property_SCREEN_POSITION_get();
 923             internal static readonly int POSITION_USES_ANCHOR_POINT = NDalicManualPINVOKE.Actor_Property_POSITION_USES_ANCHOR_POINT_get();
 924             internal static readonly int PARENT_ORIGIN = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_get();
 925             internal static readonly int PARENT_ORIGIN_X = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_X_get();
 926             internal static readonly int PARENT_ORIGIN_Y = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Y_get();
 927             internal static readonly int PARENT_ORIGIN_Z = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Z_get();
 928             internal static readonly int ANCHOR_POINT = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_get();
 929             internal static readonly int ANCHOR_POINT_X = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_X_get();
 930             internal static readonly int ANCHOR_POINT_Y = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Y_get();
 931             internal static readonly int ANCHOR_POINT_Z = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Z_get();
 932             public static readonly int SIZE = NDalicPINVOKE.Actor_Property_SIZE_get();
 933             public static readonly int SIZE_WIDTH = NDalicPINVOKE.Actor_Property_SIZE_WIDTH_get();
 934             public static readonly int SIZE_HEIGHT = NDalicPINVOKE.Actor_Property_SIZE_HEIGHT_get();
 935             internal static readonly int SIZE_DEPTH = NDalicPINVOKE.Actor_Property_SIZE_DEPTH_get();
 936             public static readonly int POSITION = NDalicPINVOKE.Actor_Property_POSITION_get();
 937             public static readonly int POSITION_X = NDalicPINVOKE.Actor_Property_POSITION_X_get();
 938             public static readonly int POSITION_Y = NDalicPINVOKE.Actor_Property_POSITION_Y_get();
 939             public static readonly int POSITION_Z = NDalicPINVOKE.Actor_Property_POSITION_Z_get();
 940             internal static readonly int WORLD_POSITION = NDalicPINVOKE.Actor_Property_WORLD_POSITION_get();
 941             internal static readonly int WORLD_POSITION_X = NDalicPINVOKE.Actor_Property_WORLD_POSITION_X_get();
 942             internal static readonly int WORLD_POSITION_Y = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Y_get();
 943             internal static readonly int WORLD_POSITION_Z = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Z_get();
 944             public static readonly int ORIENTATION = NDalicPINVOKE.Actor_Property_ORIENTATION_get();
 945             internal static readonly int WORLD_ORIENTATION = NDalicPINVOKE.Actor_Property_WORLD_ORIENTATION_get();
 946             public static readonly int SCALE = NDalicPINVOKE.Actor_Property_SCALE_get();
 947             public static readonly int SCALE_X = NDalicPINVOKE.Actor_Property_SCALE_X_get();
 948             public static readonly int SCALE_Y = NDalicPINVOKE.Actor_Property_SCALE_Y_get();
 949             public static readonly int SCALE_Z = NDalicPINVOKE.Actor_Property_SCALE_Z_get();
 950             internal static readonly int WORLD_SCALE = NDalicPINVOKE.Actor_Property_WORLD_SCALE_get();
 951             public static readonly int VISIBLE = NDalicPINVOKE.Actor_Property_VISIBLE_get();
 952             public static readonly int COLOR = NDalicPINVOKE.Actor_Property_COLOR_get();
 953             public static readonly int COLOR_RED = NDalicPINVOKE.Actor_Property_COLOR_RED_get();
 954             public static readonly int COLOR_GREEN = NDalicPINVOKE.Actor_Property_COLOR_GREEN_get();
 955             public static readonly int COLOR_BLUE = NDalicPINVOKE.Actor_Property_COLOR_BLUE_get();
 956             public static readonly int COLOR_ALPHA = NDalicPINVOKE.Actor_Property_COLOR_ALPHA_get();
 957             internal static readonly int WORLD_COLOR = NDalicPINVOKE.Actor_Property_WORLD_COLOR_get();
 958             internal static readonly int WORLD_MATRIX = NDalicPINVOKE.Actor_Property_WORLD_MATRIX_get();
 959             internal static readonly int NAME = NDalicPINVOKE.Actor_Property_NAME_get();
 960             internal static readonly int SENSITIVE = NDalicPINVOKE.Actor_Property_SENSITIVE_get();
 961             internal static readonly int LEAVE_REQUIRED = NDalicPINVOKE.Actor_Property_LEAVE_REQUIRED_get();
 962             internal static readonly int INHERIT_ORIENTATION = NDalicPINVOKE.Actor_Property_INHERIT_ORIENTATION_get();
 963             internal static readonly int INHERIT_SCALE = NDalicPINVOKE.Actor_Property_INHERIT_SCALE_get();
 964             internal static readonly int DRAW_MODE = NDalicPINVOKE.Actor_Property_DRAW_MODE_get();
 965             internal static readonly int SIZE_MODE_FACTOR = NDalicPINVOKE.Actor_Property_SIZE_MODE_FACTOR_get();
 966             internal static readonly int WIDTH_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_WIDTH_RESIZE_POLICY_get();
 967             internal static readonly int HEIGHT_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_HEIGHT_RESIZE_POLICY_get();
 968             internal static readonly int SIZE_SCALE_POLICY = NDalicPINVOKE.Actor_Property_SIZE_SCALE_POLICY_get();
 969             internal static readonly int WIDTH_FOR_HEIGHT = NDalicPINVOKE.Actor_Property_WIDTH_FOR_HEIGHT_get();
 970             internal static readonly int HEIGHT_FOR_WIDTH = NDalicPINVOKE.Actor_Property_HEIGHT_FOR_WIDTH_get();
 971             internal static readonly int PADDING = NDalicPINVOKE.Actor_Property_PADDING_get();
 972             internal static readonly int MINIMUM_SIZE = NDalicPINVOKE.Actor_Property_MINIMUM_SIZE_get();
 973             internal static readonly int MAXIMUM_SIZE = NDalicPINVOKE.Actor_Property_MAXIMUM_SIZE_get();
 974             internal static readonly int INHERIT_POSITION = NDalicPINVOKE.Actor_Property_INHERIT_POSITION_get();
 975             internal static readonly int CLIPPING_MODE = NDalicPINVOKE.Actor_Property_CLIPPING_MODE_get();
 976         }
 977
 978         public class Focus
 979         {
 980             public enum Direction
 981             {
 982                 LEFT,
 983                 RIGHT,
 984                 UP,
 985                 DOWN,
 986                 PAGE_UP,
 987                 PAGE_DOWN
 988             }
 989         }
 990
 991         public View() : this(NDalicPINVOKE.View_New(), true)
 992         {
 993             if (NDalicPINVOKE.SWIGPendingException.Pending)
 994                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 995
 996         }
 997
 998         public View(View uiControl) : this(NDalicPINVOKE.new_View__SWIG_1(View.getCPtr(uiControl)), true)
 999         {
1000             if (NDalicPINVOKE.SWIGPendingException.Pending)
1001                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1002         }
1003
1004         private new static View DownCast(BaseHandle handle)
1005         {
1006             View ret = new View(NDalicPINVOKE.View_DownCast(BaseHandle.getCPtr(handle)), true);
1007             if (NDalicPINVOKE.SWIGPendingException.Pending)
1008                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1009             return ret;
1010         }
1011
1012         public static T DownCast<T>(View view) where T : View
1013         {
1014             return (T)(ViewRegistry.GetViewFromActor(view));
1015         }
1016
1017         private View ConvertIdToView(uint id)
1018         {
1019             View view = null;
1020
1021             if (Parent)
1022             {
1023                 view = Parent.FindChildById(id);
1024             }
1025
1026             if (!view)
1027             {
1028                 view = Window.Instance.GetRootLayer().FindChildById(id);
1029             }
1030
1031             return view;
1032         }
1033
1034         internal void SetFocus()
1035         {
1036             NDalicPINVOKE.View_SetKeyInputFocus(swigCPtr);
1037             if (NDalicPINVOKE.SWIGPendingException.Pending)
1038                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1039         }
1040
1041         internal bool HasFocus()
1042         {
1043             bool ret = NDalicPINVOKE.View_HasKeyInputFocus(swigCPtr);
1044             if (NDalicPINVOKE.SWIGPendingException.Pending)
1045                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1046             return ret;
1047         }
1048
1049         internal void ClearFocus()
1050         {
1051             NDalicPINVOKE.View_ClearKeyInputFocus(swigCPtr);
1052             if (NDalicPINVOKE.SWIGPendingException.Pending)
1053                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1054         }
1055
1056         internal PinchGestureDetector GetPinchGestureDetector()
1057         {
1058             PinchGestureDetector ret = new PinchGestureDetector(NDalicPINVOKE.View_GetPinchGestureDetector(swigCPtr), true);
1059             if (NDalicPINVOKE.SWIGPendingException.Pending)
1060                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1061             return ret;
1062         }
1063
1064         internal PanGestureDetector GetPanGestureDetector()
1065         {
1066             PanGestureDetector ret = new PanGestureDetector(NDalicPINVOKE.View_GetPanGestureDetector(swigCPtr), true);
1067             if (NDalicPINVOKE.SWIGPendingException.Pending)
1068                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1069             return ret;
1070         }
1071
1072         internal TapGestureDetector GetTapGestureDetector()
1073         {
1074             TapGestureDetector ret = new TapGestureDetector(NDalicPINVOKE.View_GetTapGestureDetector(swigCPtr), true);
1075             if (NDalicPINVOKE.SWIGPendingException.Pending)
1076                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1077             return ret;
1078         }
1079
1080         internal LongPressGestureDetector GetLongPressGestureDetector()
1081         {
1082             LongPressGestureDetector ret = new LongPressGestureDetector(NDalicPINVOKE.View_GetLongPressGestureDetector(swigCPtr), true);
1083             if (NDalicPINVOKE.SWIGPendingException.Pending)
1084                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1085             return ret;
1086         }
1087
1088         internal void SetStyleName(string styleName)
1089         {
1090             NDalicPINVOKE.View_SetStyleName(swigCPtr, styleName);
1091             if (NDalicPINVOKE.SWIGPendingException.Pending)
1092                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1093         }
1094
1095         internal string GetStyleName()
1096         {
1097             string ret = NDalicPINVOKE.View_GetStyleName(swigCPtr);
1098             if (NDalicPINVOKE.SWIGPendingException.Pending)
1099                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1100             return ret;
1101         }
1102
1103         public void ClearBackground()
1104         {
1105             NDalicPINVOKE.View_ClearBackground(swigCPtr);
1106             if (NDalicPINVOKE.SWIGPendingException.Pending)
1107                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1108         }
1109
1110         internal ControlKeySignal KeyEventSignal()
1111         {
1112             ControlKeySignal ret = new ControlKeySignal(NDalicPINVOKE.View_KeyEventSignal(swigCPtr), false);
1113             if (NDalicPINVOKE.SWIGPendingException.Pending)
1114                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1115             return ret;
1116         }
1117
1118         internal KeyInputFocusSignal KeyInputFocusGainedSignal()
1119         {
1120             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusGainedSignal(swigCPtr), false);
1121             if (NDalicPINVOKE.SWIGPendingException.Pending)
1122                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1123             return ret;
1124         }
1125
1126         internal KeyInputFocusSignal KeyInputFocusLostSignal()
1127         {
1128             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusLostSignal(swigCPtr), false);
1129             if (NDalicPINVOKE.SWIGPendingException.Pending)
1130                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1131             return ret;
1132         }
1133
1134         internal View(ViewImpl implementation) : this(NDalicPINVOKE.new_View__SWIG_2(ViewImpl.getCPtr(implementation)), true)
1135         {
1136             if (NDalicPINVOKE.SWIGPendingException.Pending)
1137                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1138         }
1139
1140         public enum PropertyRange
1141         {
1142             PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX,
1143             CONTROL_PROPERTY_START_INDEX = PROPERTY_START_INDEX,
1144             CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX + 1000
1145         }
1146
1147         public string StyleName
1148         {
1149             get
1150             {
1151                 string temp;
1152                 GetProperty(View.Property.STYLE_NAME).Get(out temp);
1153                 return temp;
1154             }
1155             set
1156             {
1157                 SetProperty(View.Property.STYLE_NAME, new Dali.Property.Value(value));
1158             }
1159         }
1160
1161         public Vector4 BackgroundColor
1162         {
1163             get
1164             {
1165                 Vector4 backgroundColor = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
1166
1167                 Dali.Property.Map background = Background;
1168                 int visualType = 0;
1169                 background.Find(Dali.Constants.Visual.Property.Type).Get(out visualType);
1170                 if (visualType == (int)Dali.Constants.Visual.Type.Color)
1171                 {
1172                     background.Find(Dali.Constants.ColorVisualProperty.MixColor).Get(backgroundColor);
1173                 }
1174
1175                 return backgroundColor;
1176             }
1177             set
1178             {
1179                 SetProperty(View.Property.BACKGROUND, new Dali.Property.Value(value));
1180             }
1181         }
1182
1183         public string BackgroundImage
1184         {
1185             get
1186             {
1187                 string backgroundImage = "";
1188
1189                 Dali.Property.Map background = Background;
1190                 int visualType = 0;
1191                 background.Find(Dali.Constants.Visual.Property.Type).Get(out visualType);
1192                 if (visualType == (int)Dali.Constants.Visual.Type.Image)
1193                 {
1194                     background.Find(Dali.Constants.ImageVisualProperty.URL).Get(out backgroundImage);
1195                 }
1196
1197                 return backgroundImage;
1198             }
1199             set
1200             {
1201                 SetProperty(View.Property.BACKGROUND, new Dali.Property.Value(value));
1202             }
1203         }
1204
1205         public bool KeyFocusable
1206         {
1207             get
1208             {
1209                 bool temp = false;
1210                 GetProperty(View.Property.KEY_INPUT_FOCUS).Get(out temp);
1211                 return temp;
1212             }
1213             set
1214             {
1215                 SetProperty(View.Property.KEY_INPUT_FOCUS, new Dali.Property.Value(value));
1216             }
1217         }
1218
1219         public Dali.Property.Map Background
1220         {
1221             get
1222             {
1223                 Dali.Property.Map temp = new Dali.Property.Map();
1224                 GetProperty(View.Property.BACKGROUND).Get(temp);
1225                 return temp;
1226             }
1227             set
1228             {
1229                 SetProperty(View.Property.BACKGROUND, new Dali.Property.Value(value));
1230             }
1231         }
1232
1233         public string State
1234         {
1235             get
1236             {
1237                 string temp;
1238                 GetProperty(View.Property.STATE).Get(out temp);
1239                 return temp;
1240             }
1241             set
1242             {
1243                 SetProperty(View.Property.STATE, new Dali.Property.Value(value));
1244             }
1245         }
1246
1247         public string SubState
1248         {
1249             get
1250             {
1251                 string temp;
1252                 GetProperty(View.Property.SUB_STATE).Get(out temp);
1253                 return temp;
1254             }
1255             set
1256             {
1257                 SetProperty(View.Property.SUB_STATE, new Dali.Property.Value(value));
1258             }
1259         }
1260
1261         public Dali.Property.Map Tooltip
1262         {
1263             get
1264             {
1265                 Dali.Property.Map temp = new Dali.Property.Map();
1266                 GetProperty(View.Property.TOOLTIP).Get(temp);
1267                 return temp;
1268             }
1269             set
1270             {
1271                 SetProperty(View.Property.TOOLTIP, new Dali.Property.Value(value));
1272             }
1273         }
1274
1275         public string TooltipText
1276         {
1277             set
1278             {
1279                 SetProperty(View.Property.TOOLTIP, new Dali.Property.Value(value));
1280             }
1281         }
1282
1283         private int LeftFocusableViewId
1284         {
1285             get
1286             {
1287                 int temp = 0;
1288                 GetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID).Get(out temp);
1289                 return temp;
1290             }
1291             set
1292             {
1293                 SetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID, new Dali.Property.Value(value));
1294             }
1295         }
1296
1297         private int RightFocusableViewId
1298         {
1299             get
1300             {
1301                 int temp = 0;
1302                 GetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID).Get(out temp);
1303                 return temp;
1304             }
1305             set
1306             {
1307                 SetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID, new Dali.Property.Value(value));
1308             }
1309         }
1310
1311         private int UpFocusableViewId
1312         {
1313             get
1314             {
1315                 int temp = 0;
1316                 GetProperty(View.Property.UP_FOCUSABLE_VIEW_ID).Get(out temp);
1317                 return temp;
1318             }
1319             set
1320             {
1321                 SetProperty(View.Property.UP_FOCUSABLE_VIEW_ID, new Dali.Property.Value(value));
1322             }
1323         }
1324
1325         private int DownFocusableViewId
1326         {
1327             get
1328             {
1329                 int temp = 0;
1330                 GetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID).Get(out temp);
1331                 return temp;
1332             }
1333             set
1334             {
1335                 SetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID, new Dali.Property.Value(value));
1336             }
1337         }
1338
1339         public float Flex
1340         {
1341             get
1342             {
1343                 float temp = 0.0f;
1344                 GetProperty(FlexContainer.ChildProperty.FLEX).Get(out temp);
1345                 return temp;
1346             }
1347             set
1348             {
1349                 SetProperty(FlexContainer.ChildProperty.FLEX, new Dali.Property.Value(value));
1350             }
1351         }
1352
1353         public int AlignSelf
1354         {
1355             get
1356             {
1357                 int temp = 0;
1358                 GetProperty(FlexContainer.ChildProperty.ALIGN_SELF).Get(out temp);
1359                 return temp;
1360             }
1361             set
1362             {
1363                 SetProperty(FlexContainer.ChildProperty.ALIGN_SELF, new Dali.Property.Value(value));
1364             }
1365         }
1366
1367         public Vector4 FlexMargin
1368         {
1369             get
1370             {
1371                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
1372                 GetProperty(FlexContainer.ChildProperty.FLEX_MARGIN).Get(temp);
1373                 return temp;
1374             }
1375             set
1376             {
1377                 SetProperty(FlexContainer.ChildProperty.FLEX_MARGIN, new Dali.Property.Value(value));
1378             }
1379         }
1380
1381         public Vector2 CellIndex
1382         {
1383             get
1384             {
1385                 Vector2 temp = new Vector2(0.0f, 0.0f);
1386                 GetProperty(TableView.ChildProperty.CELL_INDEX).Get(temp);
1387                 return temp;
1388             }
1389             set
1390             {
1391                 SetProperty(TableView.ChildProperty.CELL_INDEX, new Dali.Property.Value(value));
1392             }
1393         }
1394
1395         public float RowSpan
1396         {
1397             get
1398             {
1399                 float temp = 0.0f;
1400                 GetProperty(TableView.ChildProperty.ROW_SPAN).Get(out temp);
1401                 return temp;
1402             }
1403             set
1404             {
1405                 SetProperty(TableView.ChildProperty.ROW_SPAN, new Dali.Property.Value(value));
1406             }
1407         }
1408
1409         public float ColumnSpan
1410         {
1411             get
1412             {
1413                 float temp = 0.0f;
1414                 GetProperty(TableView.ChildProperty.COLUMN_SPAN).Get(out temp);
1415                 return temp;
1416             }
1417             set
1418             {
1419                 SetProperty(TableView.ChildProperty.COLUMN_SPAN, new Dali.Property.Value(value));
1420             }
1421         }
1422
1423         public string CellHorizontalAlignment
1424         {
1425             get
1426             {
1427                 string temp;
1428                 GetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT).Get(out temp);
1429                 return temp;
1430             }
1431             set
1432             {
1433                 SetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT, new Dali.Property.Value(value));
1434             }
1435         }
1436
1437         public string CellVerticalAlignment
1438         {
1439             get
1440             {
1441                 string temp;
1442                 GetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT).Get(out temp);
1443                 return temp;
1444             }
1445             set
1446             {
1447                 SetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT, new Dali.Property.Value(value));
1448             }
1449         }
1450
1451         /**
1452          * @brief The left focusable view.
1453          * @note This will return NULL if not set.
1454          * This will also return NULL if the specified left focusable view is not on window.
1455          *
1456          */
1457         public View LeftFocusableView
1458         {
1459             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1460             get
1461             {
1462                 if (LeftFocusableViewId >= 0)
1463                 {
1464                     return ConvertIdToView((uint)LeftFocusableViewId);
1465                 }
1466                 return null;
1467             }
1468             set
1469             {
1470                 LeftFocusableViewId = (int)value.GetId();
1471             }
1472         }
1473
1474         /**
1475          * @brief The right focusable view.
1476          * @note This will return NULL if not set.
1477          * This will also return NULL if the specified right focusable view is not on window.
1478          *
1479          */
1480         public View RightFocusableView
1481         {
1482             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1483             get
1484             {
1485                 if (RightFocusableViewId >= 0)
1486                 {
1487                     return ConvertIdToView((uint)RightFocusableViewId);
1488                 }
1489                 return null;
1490             }
1491             set
1492             {
1493                 RightFocusableViewId = (int)value.GetId();
1494             }
1495         }
1496
1497         /**
1498          * @brief The up focusable view.
1499          * @note This will return NULL if not set.
1500          * This will also return NULL if the specified up focusable view is not on window.
1501          *
1502          */
1503         public View UpFocusableView
1504         {
1505             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1506             get
1507             {
1508                 if (UpFocusableViewId >= 0)
1509                 {
1510                     return ConvertIdToView((uint)UpFocusableViewId);
1511                 }
1512                 return null;
1513             }
1514             set
1515             {
1516                 UpFocusableViewId = (int)value.GetId();
1517             }
1518         }
1519
1520         /**
1521          * @brief The down focusable view.
1522          * @note This will return NULL if not set.
1523          * This will also return NULL if the specified down focusable view is not on window.
1524          *
1525          */
1526         public View DownFocusableView
1527         {
1528             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1529             get
1530             {
1531                 if (DownFocusableViewId >= 0)
1532                 {
1533                     return ConvertIdToView((uint)DownFocusableViewId);
1534                 }
1535                 return null;
1536             }
1537             set
1538             {
1539                 DownFocusableViewId = (int)value.GetId();
1540             }
1541         }
1542
1543         public Position CurrentPosition
1544         {
1545             get
1546             {
1547                 return GetCurrentPosition();
1548             }
1549         }
1550
1551         public Size2D Size2D
1552         {
1553             get
1554             {
1555                 Size temp = new Size(0.0f, 0.0f, 0.0f);
1556                 GetProperty(View.Property.SIZE).Get(temp);
1557                 return new Size2D(temp);
1558             }
1559             set
1560             {
1561                 SetProperty(View.Property.SIZE, new Dali.Property.Value(new Size(value)));
1562             }
1563         }
1564
1565         public Size CurrentSize
1566         {
1567             get
1568             {
1569                 return GetCurrentSize();
1570             }
1571         }
1572
1573         public View Parent
1574         {
1575             get
1576             {
1577                 return GetParent();
1578             }
1579         }
1580
1581         public bool Visibility
1582         {
1583             get
1584             {
1585                 return Visible;
1586             }
1587         }
1588
1589         public float Opacity
1590         {
1591             get
1592             {
1593                 float temp = 0;
1594                 GetProperty(View.Property.OPACITY).Get(out temp);
1595                 return temp;
1596             }
1597             set
1598             {
1599                 SetProperty(View.Property.OPACITY, new Dali.Property.Value(value));
1600             }
1601         }
1602
1603         public Position2D Position2D
1604         {
1605             get
1606             {
1607                 Position temp = new Position(0.0f, 0.0f, 0.0f);
1608                 GetProperty(View.Property.POSITION).Get(temp);
1609                 return new Position2D(temp);
1610             }
1611             set
1612             {
1613                 SetProperty(View.Property.POSITION, new Dali.Property.Value(new Position(value)));
1614             }
1615         }
1616
1617         public Vector2 ScreenPosition
1618         {
1619             get
1620             {
1621                 Vector2 temp = new Vector2(0.0f, 0.0f);
1622                 GetProperty(View.Property.SCREEN_POSITION).Get(temp);
1623                 return temp;
1624             }
1625         }
1626
1627         internal bool PositionUsesAnchorPoint
1628         {
1629             get
1630             {
1631                 bool temp = false;
1632                 GetProperty(View.Property.POSITION_USES_ANCHOR_POINT).Get(out temp);
1633                 return temp;
1634             }
1635             set
1636             {
1637                 SetProperty(View.Property.POSITION_USES_ANCHOR_POINT, new Dali.Property.Value(value));
1638             }
1639         }
1640
1641         internal bool FocusState
1642         {
1643             get
1644             {
1645                 return IsFocusable();
1646             }
1647             set
1648             {
1649                 SetFocusable(value);
1650             }
1651         }
1652
1653         public bool IsOnWindow
1654         {
1655             get
1656             {
1657                 return OnWindow();
1658             }
1659         }
1660
1661         public int SiblingOrder
1662         {
1663             get
1664             {
1665                 int temp = 0;
1666                 GetProperty(View.Property.SIBLING_ORDER).Get(out temp);
1667                 return temp;
1668             }
1669             set
1670             {
1671                 SetProperty(View.Property.SIBLING_ORDER, new Dali.Property.Value(value));
1672             }
1673         }
1674
1675         public void Show()
1676         {
1677             Visible = true;
1678         }
1679
1680         public void Hide()
1681         {
1682             Visible = false;
1683         }
1684
1685         public void Raise()
1686         {
1687             NDalicPINVOKE.Raise(swigCPtr);
1688             if (NDalicPINVOKE.SWIGPendingException.Pending)
1689                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1690         }
1691
1692         public void Lower()
1693         {
1694             NDalicPINVOKE.Lower(swigCPtr);
1695             if (NDalicPINVOKE.SWIGPendingException.Pending)
1696                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1697         }
1698
1699         public void RaiseToTop()
1700         {
1701             NDalicPINVOKE.RaiseToTop(swigCPtr);
1702             if (NDalicPINVOKE.SWIGPendingException.Pending)
1703                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1704         }
1705
1706         public void LowerToBottom()
1707         {
1708             NDalicPINVOKE.LowerToBottom(swigCPtr);
1709             if (NDalicPINVOKE.SWIGPendingException.Pending)
1710                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1711         }
1712
1713         public void RaiseAbove(View target)
1714         {
1715             NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
1716             if (NDalicPINVOKE.SWIGPendingException.Pending)
1717                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1718         }
1719
1720         public void LowerBelow(View target)
1721         {
1722             NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
1723             if (NDalicPINVOKE.SWIGPendingException.Pending)
1724                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1725         }
1726
1727         private uint GetId()
1728         {
1729             uint ret = NDalicPINVOKE.Actor_GetId(swigCPtr);
1730             if (NDalicPINVOKE.SWIGPendingException.Pending)
1731                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1732             return ret;
1733         }
1734
1735         private bool OnWindow()
1736         {
1737             bool ret = NDalicPINVOKE.Actor_OnStage(swigCPtr);
1738             if (NDalicPINVOKE.SWIGPendingException.Pending)
1739                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1740             return ret;
1741         }
1742
1743         public Layer GetLayer()
1744         {
1745             Layer ret = new Layer(NDalicPINVOKE.Actor_GetLayer(swigCPtr), true);
1746             if (NDalicPINVOKE.SWIGPendingException.Pending)
1747                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1748             return ret;
1749         }
1750
1751         public void Add(View child)
1752         {
1753             NDalicPINVOKE.Actor_Add(swigCPtr, View.getCPtr(child));
1754             if (NDalicPINVOKE.SWIGPendingException.Pending)
1755                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1756         }
1757
1758         public void Remove(View child)
1759         {
1760             NDalicPINVOKE.Actor_Remove(swigCPtr, View.getCPtr(child));
1761             if (NDalicPINVOKE.SWIGPendingException.Pending)
1762                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1763         }
1764
1765         public void Unparent()
1766         {
1767             NDalicPINVOKE.Actor_Unparent(swigCPtr);
1768             if (NDalicPINVOKE.SWIGPendingException.Pending)
1769                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1770         }
1771
1772         public uint GetChildCount()
1773         {
1774             uint ret = NDalicPINVOKE.Actor_GetChildCount(swigCPtr);
1775             if (NDalicPINVOKE.SWIGPendingException.Pending)
1776                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1777             return ret;
1778         }
1779
1780         public View GetChildAt(uint index)
1781         {
1782             View ret = new View(NDalicPINVOKE.Actor_GetChildAt(swigCPtr, index), true);
1783             if (NDalicPINVOKE.SWIGPendingException.Pending)
1784                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1785             return ret;
1786         }
1787
1788         public View FindChildByName(string actorName)
1789         {
1790             View ret = new View(NDalicPINVOKE.Actor_FindChildByName(swigCPtr, actorName), true);
1791             if (NDalicPINVOKE.SWIGPendingException.Pending)
1792                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1793             return ret;
1794         }
1795
1796         public View FindChildById(uint id)
1797         {
1798             View ret = new View(NDalicPINVOKE.Actor_FindChildById(swigCPtr, id), true);
1799             if (NDalicPINVOKE.SWIGPendingException.Pending)
1800                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1801             return ret;
1802         }
1803
1804         private View GetParent()
1805         {
1806             View ret = new View(NDalicPINVOKE.Actor_GetParent(swigCPtr), true);
1807             if (NDalicPINVOKE.SWIGPendingException.Pending)
1808                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1809             return ret;
1810         }
1811
1812         private void SetParentOrigin(Vector3 origin)
1813         {
1814             NDalicPINVOKE.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));
1815             if (NDalicPINVOKE.SWIGPendingException.Pending)
1816                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1817         }
1818
1819         private Vector3 GetCurrentParentOrigin()
1820         {
1821             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentParentOrigin(swigCPtr), true);
1822             if (NDalicPINVOKE.SWIGPendingException.Pending)
1823                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1824             return ret;
1825         }
1826
1827         private void SetAnchorPoint(Vector3 anchorPoint)
1828         {
1829             NDalicPINVOKE.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
1830             if (NDalicPINVOKE.SWIGPendingException.Pending)
1831                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1832         }
1833
1834         private Vector3 GetCurrentAnchorPoint()
1835         {
1836             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentAnchorPoint(swigCPtr), true);
1837             if (NDalicPINVOKE.SWIGPendingException.Pending)
1838                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1839             return ret;
1840         }
1841
1842         public void SetSize(float width, float height)
1843         {
1844             NDalicPINVOKE.Actor_SetSize__SWIG_0(swigCPtr, width, height);
1845             if (NDalicPINVOKE.SWIGPendingException.Pending)
1846                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1847         }
1848
1849         public void SetSize(float width, float height, float depth)
1850         {
1851             NDalicPINVOKE.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);
1852             if (NDalicPINVOKE.SWIGPendingException.Pending)
1853                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1854         }
1855
1856         public void SetSize(Vector2 size)
1857         {
1858             NDalicPINVOKE.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));
1859             if (NDalicPINVOKE.SWIGPendingException.Pending)
1860                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1861         }
1862
1863         public void SetSize(Vector3 size)
1864         {
1865             NDalicPINVOKE.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));
1866             if (NDalicPINVOKE.SWIGPendingException.Pending)
1867                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1868         }
1869
1870         public Vector3 GetTargetSize()
1871         {
1872             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetTargetSize(swigCPtr), true);
1873             if (NDalicPINVOKE.SWIGPendingException.Pending)
1874                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1875             return ret;
1876         }
1877
1878         private Vector3 GetCurrentSize()
1879         {
1880             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentSize(swigCPtr), true);
1881             if (NDalicPINVOKE.SWIGPendingException.Pending)
1882                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1883             return ret;
1884         }
1885
1886         internal Vector3 GetNaturalSize()
1887         {
1888             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
1889             if (NDalicPINVOKE.SWIGPendingException.Pending)
1890                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1891             return ret;
1892         }
1893
1894         public void TranslateBy(Vector3 distance)
1895         {
1896             NDalicPINVOKE.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));
1897             if (NDalicPINVOKE.SWIGPendingException.Pending)
1898                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1899         }
1900
1901         private Vector3 GetCurrentPosition()
1902         {
1903             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentPosition(swigCPtr), true);
1904             if (NDalicPINVOKE.SWIGPendingException.Pending)
1905                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1906             return ret;
1907         }
1908
1909         public void RotateBy(Degree angle, Vector3 axis)
1910         {
1911             NDalicPINVOKE.Actor_RotateBy__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
1912             if (NDalicPINVOKE.SWIGPendingException.Pending)
1913                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1914         }
1915
1916         public void RotateBy(Radian angle, Vector3 axis)
1917         {
1918             NDalicPINVOKE.Actor_RotateBy__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
1919             if (NDalicPINVOKE.SWIGPendingException.Pending)
1920                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1921         }
1922
1923         public void RotateBy(Rotation relativeRotation)
1924         {
1925             NDalicPINVOKE.Actor_RotateBy__SWIG_2(swigCPtr, Rotation.getCPtr(relativeRotation));
1926             if (NDalicPINVOKE.SWIGPendingException.Pending)
1927                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1928         }
1929
1930         public void ScaleBy(Vector3 relativeScale)
1931         {
1932             NDalicPINVOKE.Actor_ScaleBy(swigCPtr, Vector3.getCPtr(relativeScale));
1933             if (NDalicPINVOKE.SWIGPendingException.Pending)
1934                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1935         }
1936
1937         public Vector4 GetCurrentWorldColor()
1938         {
1939             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentWorldColor(swigCPtr), true);
1940             if (NDalicPINVOKE.SWIGPendingException.Pending)
1941                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1942             return ret;
1943         }
1944
1945         public void SetDrawMode(DrawModeType drawMode)
1946         {
1947             NDalicPINVOKE.Actor_SetDrawMode(swigCPtr, (int)drawMode);
1948             if (NDalicPINVOKE.SWIGPendingException.Pending)
1949                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1950         }
1951
1952         public DrawModeType GetDrawMode()
1953         {
1954             DrawModeType ret = (DrawModeType)NDalicPINVOKE.Actor_GetDrawMode(swigCPtr);
1955             if (NDalicPINVOKE.SWIGPendingException.Pending)
1956                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1957             return ret;
1958         }
1959
1960         public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY)
1961         {
1962             bool ret = NDalicPINVOKE.Actor_ScreenToLocal(swigCPtr, out localX, out localY, screenX, screenY);
1963             if (NDalicPINVOKE.SWIGPendingException.Pending)
1964                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1965             return ret;
1966         }
1967
1968         public void SetFocusable(bool focusable)
1969         {
1970             NDalicPINVOKE.Actor_SetKeyboardFocusable(swigCPtr, focusable);
1971             if (NDalicPINVOKE.SWIGPendingException.Pending)
1972                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1973         }
1974
1975         public bool IsFocusable()
1976         {
1977             bool ret = NDalicPINVOKE.Actor_IsKeyboardFocusable(swigCPtr);
1978             if (NDalicPINVOKE.SWIGPendingException.Pending)
1979                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1980             return ret;
1981         }
1982
1983         public void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)
1984         {
1985             NDalicPINVOKE.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
1986             if (NDalicPINVOKE.SWIGPendingException.Pending)
1987                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1988         }
1989
1990         public ResizePolicyType GetResizePolicy(DimensionType dimension)
1991         {
1992             ResizePolicyType ret = (ResizePolicyType)NDalicPINVOKE.Actor_GetResizePolicy(swigCPtr, (int)dimension);
1993             if (NDalicPINVOKE.SWIGPendingException.Pending)
1994                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1995             return ret;
1996         }
1997
1998         public void SetSizeModeFactor(Vector3 factor)
1999         {
2000             NDalicPINVOKE.Actor_SetSizeModeFactor(swigCPtr, Vector3.getCPtr(factor));
2001             if (NDalicPINVOKE.SWIGPendingException.Pending)
2002                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2003         }
2004
2005         public Vector3 GetSizeModeFactor()
2006         {
2007             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetSizeModeFactor(swigCPtr), true);
2008             if (NDalicPINVOKE.SWIGPendingException.Pending)
2009                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2010             return ret;
2011         }
2012
2013         public float GetHeightForWidth(float width)
2014         {
2015             float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);
2016             if (NDalicPINVOKE.SWIGPendingException.Pending)
2017                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2018             return ret;
2019         }
2020
2021         public float GetWidthForHeight(float height)
2022         {
2023             float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);
2024             if (NDalicPINVOKE.SWIGPendingException.Pending)
2025                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2026             return ret;
2027         }
2028
2029         public float GetRelayoutSize(DimensionType dimension)
2030         {
2031             float ret = NDalicPINVOKE.Actor_GetRelayoutSize(swigCPtr, (int)dimension);
2032             if (NDalicPINVOKE.SWIGPendingException.Pending)
2033                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2034             return ret;
2035         }
2036
2037         public void SetPadding(PaddingType padding)
2038         {
2039             NDalicPINVOKE.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));
2040             if (NDalicPINVOKE.SWIGPendingException.Pending)
2041                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2042         }
2043
2044         public void GetPadding(PaddingType paddingOut)
2045         {
2046             NDalicPINVOKE.Actor_GetPadding(swigCPtr, PaddingType.getCPtr(paddingOut));
2047             if (NDalicPINVOKE.SWIGPendingException.Pending)
2048                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2049         }
2050
2051         public void SetMinimumSize(Vector2 size)
2052         {
2053             NDalicPINVOKE.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));
2054             if (NDalicPINVOKE.SWIGPendingException.Pending)
2055                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2056         }
2057
2058         public Vector2 GetMinimumSize()
2059         {
2060             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMinimumSize(swigCPtr), true);
2061             if (NDalicPINVOKE.SWIGPendingException.Pending)
2062                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2063             return ret;
2064         }
2065
2066         public void SetMaximumSize(Vector2 size)
2067         {
2068             NDalicPINVOKE.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));
2069             if (NDalicPINVOKE.SWIGPendingException.Pending)
2070                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2071         }
2072
2073         public Vector2 GetMaximumSize()
2074         {
2075             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMaximumSize(swigCPtr), true);
2076             if (NDalicPINVOKE.SWIGPendingException.Pending)
2077                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2078             return ret;
2079         }
2080
2081         public int GetHierarchyDepth()
2082         {
2083             int ret = NDalicPINVOKE.Actor_GetHierarchyDepth(swigCPtr);
2084             if (NDalicPINVOKE.SWIGPendingException.Pending)
2085                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2086             return ret;
2087         }
2088
2089         internal uint AddRenderer(Renderer renderer)
2090         {
2091             uint ret = NDalicPINVOKE.Actor_AddRenderer(swigCPtr, Renderer.getCPtr(renderer));
2092             if (NDalicPINVOKE.SWIGPendingException.Pending)
2093                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2094             return ret;
2095         }
2096
2097         internal uint GetRendererCount()
2098         {
2099             uint ret = NDalicPINVOKE.Actor_GetRendererCount(swigCPtr);
2100             if (NDalicPINVOKE.SWIGPendingException.Pending)
2101                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2102             return ret;
2103         }
2104
2105         internal Renderer GetRendererAt(uint index)
2106         {
2107             Renderer ret = new Renderer(NDalicPINVOKE.Actor_GetRendererAt(swigCPtr, index), true);
2108             if (NDalicPINVOKE.SWIGPendingException.Pending)
2109                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2110             return ret;
2111         }
2112
2113         internal void RemoveRenderer(Renderer renderer)
2114         {
2115             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_0(swigCPtr, Renderer.getCPtr(renderer));
2116             if (NDalicPINVOKE.SWIGPendingException.Pending)
2117                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2118         }
2119
2120         internal void RemoveRenderer(uint index)
2121         {
2122             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_1(swigCPtr, index);
2123             if (NDalicPINVOKE.SWIGPendingException.Pending)
2124                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2125         }
2126
2127         internal TouchDataSignal TouchSignal()
2128         {
2129             TouchDataSignal ret = new TouchDataSignal(NDalicPINVOKE.Actor_TouchSignal(swigCPtr), false);
2130             if (NDalicPINVOKE.SWIGPendingException.Pending)
2131                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2132             return ret;
2133         }
2134
2135         internal HoverSignal HoveredSignal()
2136         {
2137             HoverSignal ret = new HoverSignal(NDalicPINVOKE.Actor_HoveredSignal(swigCPtr), false);
2138             if (NDalicPINVOKE.SWIGPendingException.Pending)
2139                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2140             return ret;
2141         }
2142
2143         internal WheelSignal WheelEventSignal()
2144         {
2145             WheelSignal ret = new WheelSignal(NDalicPINVOKE.Actor_WheelEventSignal(swigCPtr), false);
2146             if (NDalicPINVOKE.SWIGPendingException.Pending)
2147                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2148             return ret;
2149         }
2150
2151         internal ViewSignal OnWindowSignal()
2152         {
2153             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnStageSignal(swigCPtr), false);
2154             if (NDalicPINVOKE.SWIGPendingException.Pending)
2155                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2156             return ret;
2157         }
2158
2159         internal ViewSignal OffStageSignal()
2160         {
2161             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OffStageSignal(swigCPtr), false);
2162             if (NDalicPINVOKE.SWIGPendingException.Pending)
2163                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2164             return ret;
2165         }
2166
2167         internal ViewSignal OnRelayoutSignal()
2168         {
2169             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnRelayoutSignal(swigCPtr), false);
2170             if (NDalicPINVOKE.SWIGPendingException.Pending)
2171                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2172             return ret;
2173         }
2174
2175         public Vector3 ParentOrigin
2176         {
2177             get
2178             {
2179                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2180                 GetProperty(View.Property.PARENT_ORIGIN).Get(temp);
2181                 return temp;
2182             }
2183             set
2184             {
2185                 SetProperty(View.Property.PARENT_ORIGIN, new Dali.Property.Value(value));
2186             }
2187         }
2188
2189         public float ParentOriginX
2190         {
2191             get
2192             {
2193                 float temp = 0.0f;
2194                 GetProperty(View.Property.PARENT_ORIGIN_X).Get(out temp);
2195                 return temp;
2196             }
2197             set
2198             {
2199                 SetProperty(View.Property.PARENT_ORIGIN_X, new Dali.Property.Value(value));
2200             }
2201         }
2202
2203         public float ParentOriginY
2204         {
2205             get
2206             {
2207                 float temp = 0.0f;
2208                 GetProperty(View.Property.PARENT_ORIGIN_Y).Get(out temp);
2209                 return temp;
2210             }
2211             set
2212             {
2213                 SetProperty(View.Property.PARENT_ORIGIN_Y, new Dali.Property.Value(value));
2214             }
2215         }
2216
2217         public float ParentOriginZ
2218         {
2219             get
2220             {
2221                 float temp = 0.0f;
2222                 GetProperty(View.Property.PARENT_ORIGIN_Z).Get(out temp);
2223                 return temp;
2224             }
2225             set
2226             {
2227                 SetProperty(View.Property.PARENT_ORIGIN_Z, new Dali.Property.Value(value));
2228             }
2229         }
2230
2231         public Vector3 PivotPoint
2232         {
2233             get
2234             {
2235                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2236                 GetProperty(View.Property.ANCHOR_POINT).Get(temp);
2237                 return temp;
2238             }
2239             set
2240             {
2241                 SetProperty(View.Property.ANCHOR_POINT, new Dali.Property.Value(value));
2242             }
2243         }
2244
2245         public float PivotPointX
2246         {
2247             get
2248             {
2249                 float temp = 0.0f;
2250                 GetProperty(View.Property.ANCHOR_POINT_X).Get(out temp);
2251                 return temp;
2252             }
2253             set
2254             {
2255                 SetProperty(View.Property.ANCHOR_POINT_X, new Dali.Property.Value(value));
2256             }
2257         }
2258
2259         public float PivotPointY
2260         {
2261             get
2262             {
2263                 float temp = 0.0f;
2264                 GetProperty(View.Property.ANCHOR_POINT_Y).Get(out temp);
2265                 return temp;
2266             }
2267             set
2268             {
2269                 SetProperty(View.Property.ANCHOR_POINT_Y, new Dali.Property.Value(value));
2270             }
2271         }
2272
2273         public float PivotPointZ
2274         {
2275             get
2276             {
2277                 float temp = 0.0f;
2278                 GetProperty(View.Property.ANCHOR_POINT_Z).Get(out temp);
2279                 return temp;
2280             }
2281             set
2282             {
2283                 SetProperty(View.Property.ANCHOR_POINT_Z, new Dali.Property.Value(value));
2284             }
2285         }
2286
2287         public Vector3 Size
2288         {
2289             get
2290             {
2291                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2292                 GetProperty(View.Property.SIZE).Get(temp);
2293                 return temp;
2294             }
2295             set
2296             {
2297                 SetProperty(View.Property.SIZE, new Dali.Property.Value(value));
2298             }
2299         }
2300
2301         public float SizeWidth
2302         {
2303             get
2304             {
2305                 float temp = 0.0f;
2306                 GetProperty(View.Property.SIZE_WIDTH).Get(out temp);
2307                 return temp;
2308             }
2309             set
2310             {
2311                 SetProperty(View.Property.SIZE_WIDTH, new Dali.Property.Value(value));
2312             }
2313         }
2314
2315         public float SizeHeight
2316         {
2317             get
2318             {
2319                 float temp = 0.0f;
2320                 GetProperty(View.Property.SIZE_HEIGHT).Get(out temp);
2321                 return temp;
2322             }
2323             set
2324             {
2325                 SetProperty(View.Property.SIZE_HEIGHT, new Dali.Property.Value(value));
2326             }
2327         }
2328
2329         public Vector3 Position
2330         {
2331             get
2332             {
2333                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2334                 GetProperty(View.Property.POSITION).Get(temp);
2335                 return temp;
2336             }
2337             set
2338             {
2339                 SetProperty(View.Property.POSITION, new Dali.Property.Value(value));
2340             }
2341         }
2342
2343         public float PositionX
2344         {
2345             get
2346             {
2347                 float temp = 0.0f;
2348                 GetProperty(View.Property.POSITION_X).Get(out temp);
2349                 return temp;
2350             }
2351             set
2352             {
2353                 SetProperty(View.Property.POSITION_X, new Dali.Property.Value(value));
2354             }
2355         }
2356
2357         public float PositionY
2358         {
2359             get
2360             {
2361                 float temp = 0.0f;
2362                 GetProperty(View.Property.POSITION_Y).Get(out temp);
2363                 return temp;
2364             }
2365             set
2366             {
2367                 SetProperty(View.Property.POSITION_Y, new Dali.Property.Value(value));
2368             }
2369         }
2370
2371         public float PositionZ
2372         {
2373             get
2374             {
2375                 float temp = 0.0f;
2376                 GetProperty(View.Property.POSITION_Z).Get(out temp);
2377                 return temp;
2378             }
2379             set
2380             {
2381                 SetProperty(View.Property.POSITION_Z, new Dali.Property.Value(value));
2382             }
2383         }
2384
2385         public Vector3 WorldPosition
2386         {
2387             get
2388             {
2389                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2390                 GetProperty(View.Property.WORLD_POSITION).Get(temp);
2391                 return temp;
2392             }
2393         }
2394
2395         public float WorldPositionX
2396         {
2397             get
2398             {
2399                 float temp = 0.0f;
2400                 GetProperty(View.Property.WORLD_POSITION_X).Get(out temp);
2401                 return temp;
2402             }
2403         }
2404
2405         public float WorldPositionY
2406         {
2407             get
2408             {
2409                 float temp = 0.0f;
2410                 GetProperty(View.Property.WORLD_POSITION_Y).Get(out temp);
2411                 return temp;
2412             }
2413         }
2414
2415         public float WorldPositionZ
2416         {
2417             get
2418             {
2419                 float temp = 0.0f;
2420                 GetProperty(View.Property.WORLD_POSITION_Z).Get(out temp);
2421                 return temp;
2422             }
2423         }
2424
2425         public Rotation Orientation
2426         {
2427             get
2428             {
2429                 Rotation temp = new Rotation();
2430                 GetProperty(View.Property.ORIENTATION).Get(temp);
2431                 return temp;
2432             }
2433             set
2434             {
2435                 SetProperty(View.Property.ORIENTATION, new Dali.Property.Value(value));
2436             }
2437         }
2438
2439         public Rotation WorldOrientation
2440         {
2441             get
2442             {
2443                 Rotation temp = new Rotation();
2444                 GetProperty(View.Property.WORLD_ORIENTATION).Get(temp);
2445                 return temp;
2446             }
2447         }
2448
2449         public Vector3 Scale
2450         {
2451             get
2452             {
2453                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2454                 GetProperty(View.Property.SCALE).Get(temp);
2455                 return temp;
2456             }
2457             set
2458             {
2459                 SetProperty(View.Property.SCALE, new Dali.Property.Value(value));
2460             }
2461         }
2462
2463         public float ScaleX
2464         {
2465             get
2466             {
2467                 float temp = 0.0f;
2468                 GetProperty(View.Property.SCALE_X).Get(out temp);
2469                 return temp;
2470             }
2471             set
2472             {
2473                 SetProperty(View.Property.SCALE_X, new Dali.Property.Value(value));
2474             }
2475         }
2476
2477         public float ScaleY
2478         {
2479             get
2480             {
2481                 float temp = 0.0f;
2482                 GetProperty(View.Property.SCALE_Y).Get(out temp);
2483                 return temp;
2484             }
2485             set
2486             {
2487                 SetProperty(View.Property.SCALE_Y, new Dali.Property.Value(value));
2488             }
2489         }
2490
2491         public float ScaleZ
2492         {
2493             get
2494             {
2495                 float temp = 0.0f;
2496                 GetProperty(View.Property.SCALE_Z).Get(out temp);
2497                 return temp;
2498             }
2499             set
2500             {
2501                 SetProperty(View.Property.SCALE_Z, new Dali.Property.Value(value));
2502             }
2503         }
2504
2505         public Vector3 WorldScale
2506         {
2507             get
2508             {
2509                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2510                 GetProperty(View.Property.WORLD_SCALE).Get(temp);
2511                 return temp;
2512             }
2513         }
2514
2515         public bool Visible
2516         {
2517             get
2518             {
2519                 bool temp = false;
2520                 GetProperty(View.Property.VISIBLE).Get(out temp);
2521                 return temp;
2522             }
2523             set
2524             {
2525                 SetProperty(View.Property.VISIBLE, new Dali.Property.Value(value));
2526             }
2527         }
2528
2529         public Vector4 WorldColor
2530         {
2531             get
2532             {
2533                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
2534                 GetProperty(View.Property.WORLD_COLOR).Get(temp);
2535                 return temp;
2536             }
2537         }
2538
2539         public Matrix WorldMatrix
2540         {
2541             get
2542             {
2543                 Matrix temp = new Matrix();
2544                 GetProperty(View.Property.WORLD_MATRIX).Get(temp);
2545                 return temp;
2546             }
2547         }
2548
2549         public string Name
2550         {
2551             get
2552             {
2553                 string temp;
2554                 GetProperty(View.Property.NAME).Get(out temp);
2555                 return temp;
2556             }
2557             set
2558             {
2559                 SetProperty(View.Property.NAME, new Dali.Property.Value(value));
2560             }
2561         }
2562
2563         public bool Sensitive
2564         {
2565             get
2566             {
2567                 bool temp = false;
2568                 GetProperty(View.Property.SENSITIVE).Get(out temp);
2569                 return temp;
2570             }
2571             set
2572             {
2573                 SetProperty(View.Property.SENSITIVE, new Dali.Property.Value(value));
2574             }
2575         }
2576
2577         public bool LeaveRequired
2578         {
2579             get
2580             {
2581                 bool temp = false;
2582                 GetProperty(View.Property.LEAVE_REQUIRED).Get(out temp);
2583                 return temp;
2584             }
2585             set
2586             {
2587                 SetProperty(View.Property.LEAVE_REQUIRED, new Dali.Property.Value(value));
2588             }
2589         }
2590
2591         public bool InheritOrientation
2592         {
2593             get
2594             {
2595                 bool temp = false;
2596                 GetProperty(View.Property.INHERIT_ORIENTATION).Get(out temp);
2597                 return temp;
2598             }
2599             set
2600             {
2601                 SetProperty(View.Property.INHERIT_ORIENTATION, new Dali.Property.Value(value));
2602             }
2603         }
2604
2605         public bool InheritScale
2606         {
2607             get
2608             {
2609                 bool temp = false;
2610                 GetProperty(View.Property.INHERIT_SCALE).Get(out temp);
2611                 return temp;
2612             }
2613             set
2614             {
2615                 SetProperty(View.Property.INHERIT_SCALE, new Dali.Property.Value(value));
2616             }
2617         }
2618
2619         public string DrawMode
2620         {
2621             get
2622             {
2623                 string temp;
2624                 GetProperty(View.Property.DRAW_MODE).Get(out temp);
2625                 return temp;
2626             }
2627             set
2628             {
2629               SetProperty(View.Property.DRAW_MODE, new Dali.Property.Value(value));
2630             }
2631         }
2632
2633         public Vector3 SizeModeFactor
2634         {
2635             get
2636             {
2637                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2638                 GetProperty(View.Property.SIZE_MODE_FACTOR).Get(temp);
2639                 return temp;
2640             }
2641             set
2642             {
2643                 SetProperty(View.Property.SIZE_MODE_FACTOR, new Dali.Property.Value(value));
2644             }
2645         }
2646
2647         public string WidthResizePolicy
2648         {
2649             get
2650             {
2651                 string temp;
2652                 GetProperty(View.Property.WIDTH_RESIZE_POLICY).Get(out temp);
2653                 return temp;
2654             }
2655             set
2656             {
2657                 SetProperty(View.Property.WIDTH_RESIZE_POLICY, new Dali.Property.Value(value));
2658             }
2659         }
2660
2661         public string HeightResizePolicy
2662         {
2663             get
2664             {
2665                 string temp;
2666                 GetProperty(View.Property.HEIGHT_RESIZE_POLICY).Get(out temp);
2667                 return temp;
2668             }
2669             set
2670             {
2671                 SetProperty(View.Property.HEIGHT_RESIZE_POLICY, new Dali.Property.Value(value));
2672             }
2673         }
2674
2675         public string SizeScalePolicy
2676         {
2677             get
2678             {
2679                 string temp;
2680                 GetProperty(View.Property.SIZE_SCALE_POLICY).Get(out temp);
2681                 return temp;
2682             }
2683             set
2684             {
2685                 SetProperty(View.Property.SIZE_SCALE_POLICY, new Dali.Property.Value(value));
2686             }
2687         }
2688
2689         public bool WidthForHeight
2690         {
2691             get
2692             {
2693                 bool temp = false;
2694                 GetProperty(View.Property.WIDTH_FOR_HEIGHT).Get(out temp);
2695                 return temp;
2696             }
2697             set
2698             {
2699                 SetProperty(View.Property.WIDTH_FOR_HEIGHT, new Dali.Property.Value(value));
2700             }
2701         }
2702
2703         public bool HeightForWidth
2704         {
2705             get
2706             {
2707                 bool temp = false;
2708                 GetProperty(View.Property.HEIGHT_FOR_WIDTH).Get(out temp);
2709                 return temp;
2710             }
2711             set
2712             {
2713                 SetProperty(View.Property.HEIGHT_FOR_WIDTH, new Dali.Property.Value(value));
2714             }
2715         }
2716
2717         public Vector4 Padding
2718         {
2719             get
2720             {
2721                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
2722                 GetProperty(View.Property.PADDING).Get(temp);
2723                 return temp;
2724             }
2725             set
2726             {
2727                 SetProperty(View.Property.PADDING, new Dali.Property.Value(value));
2728             }
2729         }
2730
2731         public Vector2 MinimumSize
2732         {
2733             get
2734             {
2735                 Vector2 temp = new Vector2(0.0f, 0.0f);
2736                 GetProperty(View.Property.MINIMUM_SIZE).Get(temp);
2737                 return temp;
2738             }
2739             set
2740             {
2741                 SetProperty(View.Property.MINIMUM_SIZE, new Dali.Property.Value(value));
2742             }
2743         }
2744
2745         public Vector2 MaximumSize
2746         {
2747             get
2748             {
2749                 Vector2 temp = new Vector2(0.0f, 0.0f);
2750                 GetProperty(View.Property.MAXIMUM_SIZE).Get(temp);
2751                 return temp;
2752             }
2753             set
2754             {
2755                 SetProperty(View.Property.MAXIMUM_SIZE, new Dali.Property.Value(value));
2756             }
2757         }
2758
2759         public bool InheritPosition
2760         {
2761             get
2762             {
2763                 bool temp = false;
2764                 GetProperty(View.Property.INHERIT_POSITION).Get(out temp);
2765                 return temp;
2766             }
2767             set
2768             {
2769                 SetProperty(View.Property.INHERIT_POSITION, new Dali.Property.Value(value));
2770             }
2771         }
2772
2773         public string ClippingMode
2774         {
2775             get
2776             {
2777                 string temp;
2778                 GetProperty(View.Property.CLIPPING_MODE).Get(out temp);
2779                 return temp;
2780             }
2781             set
2782             {
2783                 SetProperty(View.Property.CLIPPING_MODE, new Dali.Property.Value(value));
2784             }
2785         }
2786     }
2787 }