Tizen.NUI/src/public/View.cs

   1 // Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved\r
   2 // PROPRIETARY/CONFIDENTIAL \r
   3 // This software is the confidential and proprietary\r
   4 // information of SAMSUNG ELECTRONICS ("Confidential Information"). You shall\r
   5 // not disclose such Confidential Information and shall use it only in\r
   6 // accordance with the terms of the license agreement you entered into with\r
   7 // SAMSUNG ELECTRONICS. SAMSUNG make no representations or warranties about the\r
   8 // suitability of the software, either express or implied, including but not\r
   9 // limited to the implied warranties of merchantability, fitness for a\r
  10 // particular purpose, or non-infringement. SAMSUNG shall not be liable for any\r
  11 // damages suffered by licensee as a result of using, modifying or distributing\r
  12 // this software or its derivatives.\r
  13 \r
  14 // Copyright (c) 2017 Samsung Electronics Co., Ltd.\r
  15 //\r
  16 // Licensed under the Apache License, Version 2.0 (the "License");\r
  17 // you may not use this file except in compliance with the License.\r
  18 // You may obtain a copy of the License at\r
  19 //\r
  20 // http://www.apache.org/licenses/LICENSE-2.0\r
  21 //\r
  22 // Unless required by applicable law or agreed to in writing, software\r
  23 // distributed under the License is distributed on an "AS IS" BASIS,\r
  24 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  25 // See the License for the specific language governing permissions and\r
  26 // limitations under the License.\r
  27 //\r
  28 \r
  29 // This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts\r
  30 // Some have been manually changed\r
  31 \r
  32 \r
  33 namespace Tizen.NUI\r
  34 {\r
  35 \r
  36     using System;\r
  37     using System.Runtime.InteropServices;\r
  38 \r
  39 \r
  40     public class View : CustomActor\r
  41     {\r
  42         private global::System.Runtime.InteropServices.HandleRef swigCPtr;\r
  43 \r
  44         internal View(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.View_SWIGUpcast(cPtr), cMemoryOwn)\r
  45         {\r
  46             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);\r
  47         }\r
  48 \r
  49         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(View obj)\r
  50         {\r
  51             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;\r
  52         }\r
  53 \r
  54         ~View()\r
  55         {\r
  56             Dispose();\r
  57         }\r
  58 \r
  59         public override void Dispose()\r
  60         {\r
  61             if (!Stage.IsInstalled())\r
  62             {\r
  63                 DisposeQueue.Instance.Add(this);\r
  64                 return;\r
  65             }\r
  66 \r
  67             lock (this)\r
  68             {\r
  69                 if (swigCPtr.Handle != global::System.IntPtr.Zero)\r
  70                 {\r
  71                     if (swigCMemOwn)\r
  72                     {\r
  73                         swigCMemOwn = false;\r
  74                         NDalicPINVOKE.delete_View(swigCPtr);\r
  75                     }\r
  76                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);\r
  77                 }\r
  78                 global::System.GC.SuppressFinalize(this);\r
  79                 base.Dispose();\r
  80             }\r
  81         }\r
  82 \r
  83         private EventHandler _keyInputFocusGainedEventHandler;\r
  84         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
  85         private delegate void KeyInputFocusGainedCallbackType(IntPtr control);\r
  86         private KeyInputFocusGainedCallbackType _keyInputFocusGainedCallback;\r
  87 \r
  88         /**\r
  89           * @brief Event for KeyInputFocusGained signal which can be used to subscribe/unsubscribe the event handler\r
  90           * provided by the user. KeyInputFocusGained signal is emitted when the control gets Key Input Focus.\r
  91           */\r
  92         public event EventHandler FocusGained\r
  93         {\r
  94             add\r
  95             {\r
  96                 if (_keyInputFocusGainedEventHandler == null)\r
  97                 {\r
  98                     _keyInputFocusGainedCallback = OnKeyInputFocusGained;\r
  99                     this.KeyInputFocusGainedSignal().Connect(_keyInputFocusGainedCallback);\r
 100                 }\r
 101 \r
 102                 _keyInputFocusGainedEventHandler += value;\r
 103             }\r
 104 \r
 105             remove\r
 106             {\r
 107                 _keyInputFocusGainedEventHandler -= value;\r
 108 \r
 109                 if (_keyInputFocusGainedEventHandler == null && _keyInputFocusGainedCallback != null)\r
 110                 {\r
 111                     this.KeyInputFocusGainedSignal().Disconnect(_keyInputFocusGainedCallback);\r
 112                 }\r
 113             }\r
 114         }\r
 115 \r
 116         private void OnKeyInputFocusGained(IntPtr view)\r
 117         {\r
 118             if (_keyInputFocusGainedEventHandler != null)\r
 119             {\r
 120                 _keyInputFocusGainedEventHandler(this, null);\r
 121             }\r
 122         }\r
 123 \r
 124 \r
 125         private EventHandler _keyInputFocusLostEventHandler;\r
 126         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 127         private delegate void KeyInputFocusLostCallbackType(IntPtr control);\r
 128         private KeyInputFocusLostCallbackType _keyInputFocusLostCallback;\r
 129 \r
 130         /**\r
 131           * @brief Event for KeyInputFocusLost signal which can be used to subscribe/unsubscribe the event handler\r
 132           * provided by the user. KeyInputFocusLost signal is emitted when the control loses Key Input Focus.\r
 133           */\r
 134         public event EventHandler FocusLost\r
 135         {\r
 136             add\r
 137             {\r
 138                 if (_keyInputFocusLostEventHandler == null)\r
 139                 {\r
 140                     _keyInputFocusLostCallback = OnKeyInputFocusLost;\r
 141                     this.KeyInputFocusLostSignal().Connect(_keyInputFocusLostCallback);\r
 142                 }\r
 143 \r
 144                 _keyInputFocusLostEventHandler += value;\r
 145             }\r
 146 \r
 147             remove\r
 148             {\r
 149                 _keyInputFocusLostEventHandler -= value;\r
 150 \r
 151                 if (_keyInputFocusLostEventHandler == null && _keyInputFocusLostCallback != null)\r
 152                 {\r
 153                     this.KeyInputFocusLostSignal().Disconnect(_keyInputFocusLostCallback);\r
 154                 }\r
 155             }\r
 156         }\r
 157 \r
 158         private void OnKeyInputFocusLost(IntPtr view)\r
 159         {\r
 160             if (_keyInputFocusLostEventHandler != null)\r
 161             {\r
 162                 _keyInputFocusLostEventHandler(this, null);\r
 163             }\r
 164         }\r
 165 \r
 166 \r
 167         /**\r
 168           * @brief Event arguments that passed via KeyEvent signal\r
 169           *\r
 170           */\r
 171         public class KeyEventArgs : EventArgs\r
 172         {\r
 173             private Key _key;\r
 174 \r
 175             /**\r
 176               * @brief KeyEvent - is the keyevent sent to the View.\r
 177               *\r
 178               */\r
 179             public Key Key\r
 180             {\r
 181                 get\r
 182                 {\r
 183                     return _key;\r
 184                 }\r
 185                 set\r
 186                 {\r
 187                     _key = value;\r
 188                 }\r
 189             }\r
 190         }\r
 191 \r
 192         private EventHandlerWithReturnType<object, KeyEventArgs, bool> _keyEventHandler;\r
 193         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 194         private delegate bool KeyCallbackType(IntPtr control, IntPtr keyEvent);\r
 195         private KeyCallbackType _keyCallback;\r
 196 \r
 197         /**\r
 198           * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler\r
 199           * provided by the user. KeyPressed signal is emitted when key event is received.\r
 200           */\r
 201         public event EventHandlerWithReturnType<object, KeyEventArgs, bool> KeyEvent\r
 202         {\r
 203             add\r
 204             {\r
 205                 if (_keyEventHandler == null)\r
 206                 {\r
 207                     _keyCallback = OnKeyEvent;\r
 208                     this.KeyEventSignal().Connect(_keyCallback);\r
 209                 }\r
 210 \r
 211                 _keyEventHandler += value;\r
 212             }\r
 213 \r
 214             remove\r
 215             {\r
 216                 _keyEventHandler -= value;\r
 217 \r
 218                 if (_keyEventHandler == null && _keyCallback != null)\r
 219                 {\r
 220                     this.KeyEventSignal().Disconnect(_keyCallback);\r
 221                 }\r
 222             }\r
 223         }\r
 224 \r
 225         private bool OnKeyEvent(IntPtr view, IntPtr keyEvent)\r
 226         {\r
 227             KeyEventArgs e = new KeyEventArgs();\r
 228 \r
 229             e.Key = Tizen.NUI.Key.GetKeyFromPtr(keyEvent);\r
 230 \r
 231             if (_keyEventHandler != null)\r
 232             {\r
 233                 return _keyEventHandler(this, e);\r
 234             }\r
 235             return false;\r
 236         }\r
 237 \r
 238 \r
 239         private EventHandler _onRelayoutEventHandler;\r
 240         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 241         private delegate void OnRelayoutEventCallbackType(IntPtr control);\r
 242         private OnRelayoutEventCallbackType _onRelayoutEventCallback;\r
 243 \r
 244         /**\r
 245           * @brief Event for OnRelayout signal which can be used to subscribe/unsubscribe the event handler\r
 246           * OnRelayout signal is emitted after the size has been set on the view during relayout.\r
 247           */\r
 248         public event EventHandler OnRelayoutEvent\r
 249         {\r
 250             add\r
 251             {\r
 252                 if (_onRelayoutEventHandler == null)\r
 253                 {\r
 254                     _onRelayoutEventCallback = OnRelayout;\r
 255                     this.OnRelayoutSignal().Connect(_onRelayoutEventCallback);\r
 256                 }\r
 257 \r
 258                 _onRelayoutEventHandler += value;\r
 259             }\r
 260 \r
 261             remove\r
 262             {\r
 263                 _onRelayoutEventHandler -= value;\r
 264 \r
 265                 if (_onRelayoutEventHandler == null && _onRelayoutEventCallback != null)\r
 266                 {\r
 267                     this.OnRelayoutSignal().Disconnect(_onRelayoutEventCallback);\r
 268                 }\r
 269 \r
 270             }\r
 271         }\r
 272 \r
 273         // Callback for View OnRelayout signal\r
 274         private void OnRelayout(IntPtr data)\r
 275         {\r
 276             if (_onRelayoutEventHandler != null)\r
 277             {\r
 278                 _onRelayoutEventHandler(this, null);\r
 279             }\r
 280         }\r
 281 \r
 282 \r
 283         /**\r
 284           * @brief Event arguments that passed via Touch signal\r
 285           *\r
 286           */\r
 287         public class TouchEventArgs : EventArgs\r
 288         {\r
 289             private Touch _touch;\r
 290 \r
 291             /**\r
 292               * @brief TouchData - contains the information of touch points\r
 293               *\r
 294               */\r
 295             public Touch Touch\r
 296             {\r
 297                 get\r
 298                 {\r
 299                     return _touch;\r
 300                 }\r
 301                 set\r
 302                 {\r
 303                     _touch = value;\r
 304                 }\r
 305             }\r
 306         }\r
 307 \r
 308         private EventHandlerWithReturnType<object, TouchEventArgs, bool> _touchDataEventHandler;\r
 309         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 310         private delegate bool TouchDataCallbackType(IntPtr view, IntPtr touchData);\r
 311         private TouchDataCallbackType _touchDataCallback;\r
 312 \r
 313         /**\r
 314           * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler\r
 315           * provided by the user. Touched signal is emitted when touch input is received.\r
 316           */\r
 317         public event EventHandlerWithReturnType<object, TouchEventArgs, bool> Touched\r
 318         {\r
 319             add\r
 320             {\r
 321                 if (_touchDataEventHandler == null)\r
 322                 {\r
 323                     _touchDataCallback = OnTouch;\r
 324                     this.TouchSignal().Connect(_touchDataCallback);\r
 325                 }\r
 326 \r
 327                 _touchDataEventHandler += value;\r
 328             }\r
 329 \r
 330             remove\r
 331             {\r
 332                 _touchDataEventHandler -= value;\r
 333 \r
 334                 if (_touchDataEventHandler == null && _touchDataCallback != null)\r
 335                 {\r
 336                     this.TouchSignal().Disconnect(_touchDataCallback);\r
 337                 }\r
 338 \r
 339             }\r
 340         }\r
 341 \r
 342         // Callback for View TouchSignal\r
 343         private bool OnTouch(IntPtr view, IntPtr touchData)\r
 344         {\r
 345             TouchEventArgs e = new TouchEventArgs();\r
 346 \r
 347             e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);\r
 348 \r
 349             if (_touchDataEventHandler != null)\r
 350             {\r
 351                 return _touchDataEventHandler(this, e);\r
 352             }\r
 353             return false;\r
 354         }\r
 355 \r
 356 \r
 357         /**\r
 358           * @brief Event arguments that passed via Hover signal\r
 359           *\r
 360           */\r
 361         public class HoverEventArgs : EventArgs\r
 362         {\r
 363             private Hover _hover;\r
 364             /**\r
 365               * @brief HoverEvent - contains touch points that represent the points\r
 366               * that are currently being hovered or the points where a hover has stopped\r
 367               *\r
 368               */\r
 369             public Hover Hover\r
 370             {\r
 371                 get\r
 372                 {\r
 373                     return _hover;\r
 374                 }\r
 375                 set\r
 376                 {\r
 377                     _hover = value;\r
 378                 }\r
 379             }\r
 380         }\r
 381 \r
 382         private EventHandlerWithReturnType<object, HoverEventArgs, bool> _hoverEventHandler;\r
 383         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 384         private delegate bool HoverEventCallbackType(IntPtr view, IntPtr hoverEvent);\r
 385         private HoverEventCallbackType _hoverEventCallback;\r
 386 \r
 387         /**\r
 388           * @brief Event for Hovered signal which can be used to subscribe/unsubscribe the event handler\r
 389           * provided by the user. Hovered signal is emitted when hover input is received.\r
 390           */\r
 391         public event EventHandlerWithReturnType<object, HoverEventArgs, bool> Hovered\r
 392         {\r
 393             add\r
 394             {\r
 395                 if (_hoverEventHandler == null)\r
 396                 {\r
 397                     _hoverEventCallback = OnHoverEvent;\r
 398                     this.HoveredSignal().Connect(_hoverEventCallback);\r
 399                 }\r
 400 \r
 401                 _hoverEventHandler += value;\r
 402             }\r
 403 \r
 404             remove\r
 405             {\r
 406                 _hoverEventHandler -= value;\r
 407 \r
 408                 if (_hoverEventHandler == null && _hoverEventCallback != null)\r
 409                 {\r
 410                     this.HoveredSignal().Disconnect(_hoverEventCallback);\r
 411                 }\r
 412 \r
 413             }\r
 414         }\r
 415 \r
 416         // Callback for View Hover signal\r
 417         private bool OnHoverEvent(IntPtr view, IntPtr hoverEvent)\r
 418         {\r
 419             HoverEventArgs e = new HoverEventArgs();\r
 420 \r
 421             e.Hover = Tizen.NUI.Hover.GetHoverFromPtr(hoverEvent);\r
 422 \r
 423             if (_hoverEventHandler != null)\r
 424             {\r
 425                 return _hoverEventHandler(this, e);\r
 426             }\r
 427             return false;\r
 428         }\r
 429 \r
 430 \r
 431         /**\r
 432           * @brief Event arguments that passed via Wheel signal\r
 433           *\r
 434           */\r
 435         public class WheelEventArgs : EventArgs\r
 436         {\r
 437             private Wheel _wheel;\r
 438             /**\r
 439               * @brief WheelEvent - store a wheel rolling type : MOUSE_WHEEL or CUSTOM_WHEEL\r
 440               *\r
 441               */\r
 442             public Wheel Wheel\r
 443             {\r
 444                 get\r
 445                 {\r
 446                     return _wheel;\r
 447                 }\r
 448                 set\r
 449                 {\r
 450                     _wheel = value;\r
 451                 }\r
 452             }\r
 453         }\r
 454 \r
 455         private EventHandlerWithReturnType<object, WheelEventArgs, bool> _wheelEventHandler;\r
 456         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 457         private delegate bool WheelEventCallbackType(IntPtr view, IntPtr wheelEvent);\r
 458         private WheelEventCallbackType _wheelEventCallback;\r
 459 \r
 460         /**\r
 461           * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler\r
 462           * provided by the user. WheelMoved signal is emitted when wheel event is received.\r
 463           */\r
 464         public event EventHandlerWithReturnType<object, WheelEventArgs, bool> WheelMoved\r
 465         {\r
 466             add\r
 467             {\r
 468                 if (_wheelEventHandler == null)\r
 469                 {\r
 470                     _wheelEventCallback = OnWheelEvent;\r
 471                     this.WheelEventSignal().Connect(_wheelEventCallback);\r
 472                 }\r
 473 \r
 474                 _wheelEventHandler += value;\r
 475             }\r
 476 \r
 477             remove\r
 478             {\r
 479                 _wheelEventHandler -= value;\r
 480 \r
 481                 if (_wheelEventHandler == null && _wheelEventCallback != null)\r
 482                 {\r
 483                     this.WheelEventSignal().Disconnect(_wheelEventCallback);\r
 484                 }\r
 485 \r
 486             }\r
 487         }\r
 488 \r
 489         // Callback for View Wheel signal\r
 490         private bool OnWheelEvent(IntPtr view, IntPtr wheelEvent)\r
 491         {\r
 492             WheelEventArgs e = new WheelEventArgs();\r
 493 \r
 494             e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);\r
 495 \r
 496             if (_wheelEventHandler != null)\r
 497             {\r
 498                 return _wheelEventHandler(this, e);\r
 499             }\r
 500             return false;\r
 501         }\r
 502 \r
 503 \r
 504         private EventHandler _onStageEventHandler;\r
 505         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 506         private delegate void OnStageEventCallbackType(IntPtr control);\r
 507         private OnStageEventCallbackType _onStageEventCallback;\r
 508 \r
 509         /**\r
 510           * @brief Event for OnStage signal which can be used to subscribe/unsubscribe the event handler\r
 511           * OnStage signal is emitted after the view has been connected to the stage.\r
 512           */\r
 513         public event EventHandler OnStageEvent\r
 514         {\r
 515             add\r
 516             {\r
 517                 if (_onStageEventHandler == null)\r
 518                 {\r
 519                     _onStageEventCallback = OnStage;\r
 520                     this.OnStageSignal().Connect(_onStageEventCallback);\r
 521                 }\r
 522 \r
 523                 _onStageEventHandler += value;\r
 524             }\r
 525 \r
 526             remove\r
 527             {\r
 528                 _onStageEventHandler -= value;\r
 529 \r
 530                 if (_onStageEventHandler == null && _onStageEventCallback != null)\r
 531                 {\r
 532                     this.OnStageSignal().Disconnect(_onStageEventCallback);\r
 533                 }\r
 534             }\r
 535         }\r
 536 \r
 537         // Callback for View OnStage signal\r
 538         private void OnStage(IntPtr data)\r
 539         {\r
 540             if (_onStageEventHandler != null)\r
 541             {\r
 542                 _onStageEventHandler(this, null);\r
 543             }\r
 544         }\r
 545 \r
 546 \r
 547         private EventHandler _offStageEventHandler;\r
 548         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 549         private delegate void OffStageEventCallbackType(IntPtr control);\r
 550         private OffStageEventCallbackType _offStageEventCallback;\r
 551 \r
 552         /**\r
 553           * @brief Event for OffStage signal which can be used to subscribe/unsubscribe the event handler\r
 554           * OffStage signal is emitted after the view has been disconnected from the stage.\r
 555           */\r
 556         public event EventHandler OffStageEvent\r
 557         {\r
 558             add\r
 559             {\r
 560                 if (_offStageEventHandler == null)\r
 561                 {\r
 562                     _offStageEventCallback = OffStage;\r
 563                     this.OnStageSignal().Connect(_offStageEventCallback);\r
 564                 }\r
 565 \r
 566                 _offStageEventHandler += value;\r
 567             }\r
 568 \r
 569             remove\r
 570             {\r
 571                 _offStageEventHandler -= value;\r
 572 \r
 573                 if (_offStageEventHandler == null  && _offStageEventCallback != null)\r
 574                 {\r
 575                     this.OnStageSignal().Disconnect(_offStageEventCallback);\r
 576                 }\r
 577             }\r
 578         }\r
 579 \r
 580         // Callback for View OffStage signal\r
 581         private void OffStage(IntPtr data)\r
 582         {\r
 583             if (_offStageEventHandler != null)\r
 584             {\r
 585                 _offStageEventHandler(this, null);\r
 586             }\r
 587         }\r
 588 \r
 589         public static View GetViewFromPtr(global::System.IntPtr cPtr)\r
 590         {\r
 591             View ret = new View(cPtr, false);\r
 592             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 593             return ret;\r
 594         }\r
 595 \r
 596         internal IntPtr GetPtrfromView()\r
 597         {\r
 598             return (IntPtr)swigCPtr;\r
 599         }\r
 600 \r
 601         public Tizen.NUI.PropertyMap Tooltip\r
 602         {\r
 603             get\r
 604             {\r
 605                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();\r
 606                 GetProperty(View.Property.TOOLTIP).Get(temp);\r
 607                 return temp;\r
 608             }\r
 609             set\r
 610             {\r
 611                 SetProperty(View.Property.TOOLTIP, new Tizen.NUI.PropertyValue(value));\r
 612             }\r
 613         }\r
 614 \r
 615         public string TooltipText\r
 616         {\r
 617             set\r
 618             {\r
 619                 SetProperty(View.Property.TOOLTIP, new Tizen.NUI.PropertyValue(value));\r
 620             }\r
 621         }\r
 622 \r
 623         internal class Property : global::System.IDisposable\r
 624         {\r
 625             private global::System.Runtime.InteropServices.HandleRef swigCPtr;\r
 626             protected bool swigCMemOwn;\r
 627 \r
 628             internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)\r
 629             {\r
 630                 swigCMemOwn = cMemoryOwn;\r
 631                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);\r
 632             }\r
 633 \r
 634             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)\r
 635             {\r
 636                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;\r
 637             }\r
 638 \r
 639             ~Property()\r
 640             {\r
 641                 Dispose();\r
 642             }\r
 643 \r
 644             public virtual void Dispose()\r
 645             {\r
 646                 lock (this)\r
 647                 {\r
 648                     if (swigCPtr.Handle != global::System.IntPtr.Zero)\r
 649                     {\r
 650                         if (swigCMemOwn)\r
 651                         {\r
 652                             swigCMemOwn = false;\r
 653                             NDalicPINVOKE.delete_View_Property(swigCPtr);\r
 654                         }\r
 655                         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);\r
 656                     }\r
 657                     global::System.GC.SuppressFinalize(this);\r
 658                 }\r
 659             }\r
 660 \r
 661             internal static readonly int TOOLTIP = NDalicManualPINVOKE.View_Property_TOOLTIP_get();\r
 662 \r
 663             internal Property() : this(NDalicPINVOKE.new_View_Property(), true)\r
 664             {\r
 665                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 666             }\r
 667 \r
 668             internal static readonly int STYLE_NAME = NDalicPINVOKE.View_Property_STYLE_NAME_get();\r
 669             internal static readonly int BACKGROUND_COLOR = NDalicPINVOKE.View_Property_BACKGROUND_COLOR_get();\r
 670             internal static readonly int BACKGROUND_IMAGE = NDalicPINVOKE.View_Property_BACKGROUND_IMAGE_get();\r
 671             internal static readonly int KEY_INPUT_FOCUS = NDalicPINVOKE.View_Property_KEY_INPUT_FOCUS_get();\r
 672             internal static readonly int BACKGROUND = NDalicPINVOKE.View_Property_BACKGROUND_get();\r
 673 \r
 674         }\r
 675 \r
 676 \r
 677         public enum FocusDirection\r
 678         {\r
 679             Left,\r
 680             Right,\r
 681             Up,\r
 682             Down,\r
 683             PageUp,\r
 684             PageDown\r
 685         }\r
 686 \r
 687 \r
 688         public View() : this(NDalicPINVOKE.View_New(), true)\r
 689         {\r
 690             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 691 \r
 692         }\r
 693         internal View(View uiControl) : this(NDalicPINVOKE.new_View__SWIG_1(View.getCPtr(uiControl)), true)\r
 694         {\r
 695             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 696         }\r
 697 \r
 698         internal View Assign(View handle)\r
 699         {\r
 700             View ret = new View(NDalicPINVOKE.View_Assign(swigCPtr, View.getCPtr(handle)), false);\r
 701             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 702             return ret;\r
 703         }\r
 704 \r
 705         public new static View DownCast(BaseHandle handle)\r
 706         {\r
 707             View ret = new View(NDalicPINVOKE.View_DownCast(BaseHandle.getCPtr(handle)), true);\r
 708             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 709             return ret;\r
 710         }\r
 711 \r
 712         public void SetKeyInputFocus()\r
 713         {\r
 714             NDalicPINVOKE.View_SetKeyInputFocus(swigCPtr);\r
 715             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 716         }\r
 717 \r
 718         public bool HasKeyInputFocus()\r
 719         {\r
 720             bool ret = NDalicPINVOKE.View_HasKeyInputFocus(swigCPtr);\r
 721             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 722             return ret;\r
 723         }\r
 724 \r
 725         public void ClearKeyInputFocus()\r
 726         {\r
 727             NDalicPINVOKE.View_ClearKeyInputFocus(swigCPtr);\r
 728             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 729         }\r
 730 \r
 731         internal PinchGestureDetector GetPinchGestureDetector()\r
 732         {\r
 733             PinchGestureDetector ret = new PinchGestureDetector(NDalicPINVOKE.View_GetPinchGestureDetector(swigCPtr), true);\r
 734             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 735             return ret;\r
 736         }\r
 737 \r
 738         internal PanGestureDetector GetPanGestureDetector()\r
 739         {\r
 740             PanGestureDetector ret = new PanGestureDetector(NDalicPINVOKE.View_GetPanGestureDetector(swigCPtr), true);\r
 741             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 742             return ret;\r
 743         }\r
 744 \r
 745         internal TapGestureDetector GetTapGestureDetector()\r
 746         {\r
 747             TapGestureDetector ret = new TapGestureDetector(NDalicPINVOKE.View_GetTapGestureDetector(swigCPtr), true);\r
 748             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 749             return ret;\r
 750         }\r
 751 \r
 752         internal LongPressGestureDetector GetLongPressGestureDetector()\r
 753         {\r
 754             LongPressGestureDetector ret = new LongPressGestureDetector(NDalicPINVOKE.View_GetLongPressGestureDetector(swigCPtr), true);\r
 755             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 756             return ret;\r
 757         }\r
 758 \r
 759         internal void SetStyleName(string styleName)\r
 760         {\r
 761             NDalicPINVOKE.View_SetStyleName(swigCPtr, styleName);\r
 762             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 763         }\r
 764 \r
 765         internal string GetStyleName()\r
 766         {\r
 767             string ret = NDalicPINVOKE.View_GetStyleName(swigCPtr);\r
 768             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 769             return ret;\r
 770         }\r
 771 \r
 772         internal void SetBackgroundColor(Vector4 color)\r
 773         {\r
 774             NDalicPINVOKE.View_SetBackgroundColor(swigCPtr, Vector4.getCPtr(color));\r
 775             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 776         }\r
 777 \r
 778         internal Vector4 GetBackgroundColor()\r
 779         {\r
 780             Vector4 ret = new Vector4(NDalicPINVOKE.View_GetBackgroundColor(swigCPtr), true);\r
 781             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 782             return ret;\r
 783         }\r
 784 \r
 785         internal void SetBackgroundImage(Image image)\r
 786         {\r
 787             NDalicPINVOKE.View_SetBackgroundImage(swigCPtr, Image.getCPtr(image));\r
 788             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 789         }\r
 790 \r
 791         public void ClearBackground()\r
 792         {\r
 793             NDalicPINVOKE.View_ClearBackground(swigCPtr);\r
 794             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 795         }\r
 796 \r
 797         internal ControlKeySignal KeyEventSignal()\r
 798         {\r
 799             ControlKeySignal ret = new ControlKeySignal(NDalicPINVOKE.View_KeyEventSignal(swigCPtr), false);\r
 800             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 801             return ret;\r
 802         }\r
 803 \r
 804         internal KeyInputFocusSignal KeyInputFocusGainedSignal()\r
 805         {\r
 806             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusGainedSignal(swigCPtr), false);\r
 807             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 808             return ret;\r
 809         }\r
 810 \r
 811         internal KeyInputFocusSignal KeyInputFocusLostSignal()\r
 812         {\r
 813             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusLostSignal(swigCPtr), false);\r
 814             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 815             return ret;\r
 816         }\r
 817 \r
 818         internal View(ViewImpl implementation) : this(NDalicPINVOKE.new_View__SWIG_2(ViewImpl.getCPtr(implementation)), true)\r
 819         {\r
 820             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 821         }\r
 822 \r
 823         internal enum PropertyRange\r
 824         {\r
 825             PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX,\r
 826             CONTROL_PROPERTY_START_INDEX = PROPERTY_START_INDEX,\r
 827             CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX + 1000\r
 828         }\r
 829 \r
 830         public string StyleName\r
 831         {\r
 832             get\r
 833             {\r
 834                 string temp;\r
 835                 GetProperty(View.Property.STYLE_NAME).Get(out temp);\r
 836                 return temp;\r
 837             }\r
 838             set\r
 839             {\r
 840                 SetProperty(View.Property.STYLE_NAME, new Tizen.NUI.PropertyValue(value));\r
 841             }\r
 842         }\r
 843 \r
 844         public Color BackgroundColor\r
 845         {\r
 846             get\r
 847             {\r
 848                 Color temp = new Color(0.0f, 0.0f, 0.0f, 0.0f);\r
 849                 GetProperty(View.Property.BACKGROUND_COLOR).Get(temp);\r
 850                 return temp;\r
 851             }\r
 852             set\r
 853             {\r
 854                 SetProperty(View.Property.BACKGROUND_COLOR, new Tizen.NUI.PropertyValue(value));\r
 855             }\r
 856         }\r
 857 \r
 858         public string BackgroundImage\r
 859         {\r
 860             get\r
 861             {\r
 862                 string temp;\r
 863                 GetProperty(View.Property.BACKGROUND).Get(out temp);\r
 864                 return temp;\r
 865             }\r
 866             set\r
 867             {\r
 868                 SetProperty(View.Property.BACKGROUND, new Tizen.NUI.PropertyValue(value));\r
 869             }\r
 870         }\r
 871         internal bool KeyInputFocus\r
 872         {\r
 873             get\r
 874             {\r
 875                 bool temp = false;\r
 876                 GetProperty(View.Property.KEY_INPUT_FOCUS).Get(ref temp);\r
 877                 return temp;\r
 878             }\r
 879             set\r
 880             {\r
 881                 SetProperty(View.Property.KEY_INPUT_FOCUS, new Tizen.NUI.PropertyValue(value));\r
 882             }\r
 883         }\r
 884         public Tizen.NUI.PropertyMap Background\r
 885         {\r
 886             get\r
 887             {\r
 888                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();\r
 889                 GetProperty(View.Property.BACKGROUND).Get(temp);\r
 890                 return temp;\r
 891             }\r
 892             set\r
 893             {\r
 894                 SetProperty(View.Property.BACKGROUND, new Tizen.NUI.PropertyValue(value));\r
 895             }\r
 896         }\r
 897 \r
 898         public Vector2 CellIndex\r
 899         {\r
 900             get\r
 901             {\r
 902                 Vector2 temp = new Vector2(0.0f, 0.0f);\r
 903                 GetProperty(TableView.ChildProperty.CELL_INDEX).Get(temp);\r
 904                 return temp;\r
 905             }\r
 906             set\r
 907             {\r
 908                 SetProperty(TableView.ChildProperty.CELL_INDEX, new Tizen.NUI.PropertyValue(value));\r
 909             }\r
 910         }\r
 911         public float RowSpan\r
 912         {\r
 913             get\r
 914             {\r
 915                 float temp = 0.0f;\r
 916                 GetProperty(TableView.ChildProperty.ROW_SPAN).Get(ref temp);\r
 917                 return temp;\r
 918             }\r
 919             set\r
 920             {\r
 921                 SetProperty(TableView.ChildProperty.ROW_SPAN, new Tizen.NUI.PropertyValue(value));\r
 922             }\r
 923         }\r
 924         public float ColumnSpan\r
 925         {\r
 926             get\r
 927             {\r
 928                 float temp = 0.0f;\r
 929                 GetProperty(TableView.ChildProperty.COLUMN_SPAN).Get(ref temp);\r
 930                 return temp;\r
 931             }\r
 932             set\r
 933             {\r
 934                 SetProperty(TableView.ChildProperty.COLUMN_SPAN, new Tizen.NUI.PropertyValue(value));\r
 935             }\r
 936         }\r
 937         public string CellHorizontalAlignment\r
 938         {\r
 939             get\r
 940             {\r
 941                 string temp;\r
 942                 GetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT).Get(out temp);\r
 943                 return temp;\r
 944             }\r
 945             set\r
 946             {\r
 947                 SetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT, new Tizen.NUI.PropertyValue(value));\r
 948             }\r
 949         }\r
 950         public string CellVerticalAlignment\r
 951         {\r
 952             get\r
 953             {\r
 954                 string temp;\r
 955                 GetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT).Get(out temp);\r
 956                 return temp;\r
 957             }\r
 958             set\r
 959             {\r
 960                 SetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT, new Tizen.NUI.PropertyValue(value));\r
 961             }\r
 962         }\r
 963 \r
 964         /// <summary>\r
 965         /// Child Property of FlexContainer\r
 966         /// The proportion of the free space in the container the flex item will receive. \r
 967         /// If all items in the container set this property, their sizes will be proportional to the specified flex factor\r
 968         /// </summary> \r
 969         public float Flex\r
 970         {\r
 971             get\r
 972             {\r
 973                 float temp = 0.0f;\r
 974                 GetProperty(FlexContainer.ChildProperty.FLEX).Get(ref temp);\r
 975                 return temp;\r
 976             }\r
 977             set\r
 978             {\r
 979                 SetProperty(FlexContainer.ChildProperty.FLEX, new Tizen.NUI.PropertyValue(value));\r
 980             }\r
 981         }\r
 982 \r
 983         /// <summary>\r
 984         /// Child Property of FlexContainer\r
 985         /// The alignment of the flex item along the cross axis, which, if set, overides the default alignment for all items in the container\r
 986         /// </summary> \r
 987         public int AlignSelf\r
 988         {\r
 989             get\r
 990             {\r
 991                 int temp = 0;\r
 992                 GetProperty(FlexContainer.ChildProperty.ALIGN_SELF).Get(ref temp);\r
 993                 return temp;\r
 994             }\r
 995             set\r
 996             {\r
 997                 SetProperty(FlexContainer.ChildProperty.ALIGN_SELF, new Tizen.NUI.PropertyValue(value));\r
 998             }\r
 999         }\r
1000 \r
1001         /// <summary>\r
1002         /// Child Property of FlexContainer\r
1003         /// The space around the flex item\r
1004         /// </summary> \r
1005         public Vector4 FlexMargin\r
1006         {\r
1007             get\r
1008             {\r
1009                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);\r
1010                 GetProperty(FlexContainer.ChildProperty.FLEX_MARGIN).Get(temp);\r
1011                 return temp;\r
1012             }\r
1013             set\r
1014             {\r
1015                 SetProperty(FlexContainer.ChildProperty.FLEX_MARGIN, new Tizen.NUI.PropertyValue(value));\r
1016             }\r
1017         }\r
1018 \r
1019         public bool Focusable\r
1020         {\r
1021             set\r
1022             {\r
1023                 SetKeyboardFocusable(value);\r
1024             }\r
1025             get\r
1026             {\r
1027                 return IsKeyboardFocusable();\r
1028             }\r
1029         }\r
1030 \r
1031     }\r
1032 \r
1033 }\r