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())
  62             {
  63                 DisposeQueue.Instance.Add(this);
  64                 return;
  65             }
  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                 if (_keyInputFocusGainedEventHandler != null)\r
 108                 {\r
 109                     this.KeyInputFocusGainedSignal().Disconnect(_keyInputFocusGainedCallback);\r
 110                 }\r
 111 \r
 112                 _keyInputFocusGainedEventHandler -= value;\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                 if (_keyInputFocusLostEventHandler != null)\r
 150                 {\r
 151                     this.KeyInputFocusLostSignal().Disconnect(_keyInputFocusLostCallback);\r
 152                 }\r
 153 \r
 154                 _keyInputFocusLostEventHandler -= value;\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                 if (_keyEventHandler != null)\r
 217                 {\r
 218                     this.KeyEventSignal().Disconnect(_keyCallback);\r
 219                 }\r
 220 \r
 221                 _keyEventHandler -= value;\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                 if (_onRelayoutEventHandler != null)\r
 264                 {\r
 265                     this.OnRelayoutSignal().Disconnect(_onRelayoutEventCallback);\r
 266                 }\r
 267 \r
 268                 _onRelayoutEventHandler -= value;\r
 269             }\r
 270         }\r
 271 \r
 272         // Callback for View OnRelayout signal\r
 273         private void OnRelayout(IntPtr data)\r
 274         {\r
 275             if (_onRelayoutEventHandler != null)\r
 276             {\r
 277                 _onRelayoutEventHandler(this, null);\r
 278             }\r
 279         }\r
 280 \r
 281 \r
 282         /**\r
 283           * @brief Event arguments that passed via Touch signal\r
 284           *\r
 285           */\r
 286         public class TouchEventArgs : EventArgs\r
 287         {\r
 288             private Touch _touch;\r
 289 \r
 290             /**\r
 291               * @brief TouchData - contains the information of touch points\r
 292               *\r
 293               */\r
 294             public Touch Touch\r
 295             {\r
 296                 get\r
 297                 {\r
 298                     return _touch;\r
 299                 }\r
 300                 set\r
 301                 {\r
 302                     _touch = value;\r
 303                 }\r
 304             }\r
 305         }\r
 306 \r
 307         private EventHandlerWithReturnType<object, TouchEventArgs, bool> _touchDataEventHandler;\r
 308         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 309         private delegate bool TouchDataCallbackType(IntPtr view, IntPtr touchData);\r
 310         private TouchDataCallbackType _touchDataCallback;\r
 311 \r
 312         /**\r
 313           * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler\r
 314           * provided by the user. Touched signal is emitted when touch input is received.\r
 315           */\r
 316         public event EventHandlerWithReturnType<object, TouchEventArgs, bool> Touched\r
 317         {\r
 318             add\r
 319             {\r
 320                 if (_touchDataEventHandler == null)\r
 321                 {\r
 322                     _touchDataCallback = OnTouch;\r
 323                     this.TouchSignal().Connect(_touchDataCallback);\r
 324                 }\r
 325 \r
 326                 _touchDataEventHandler += value;\r
 327             }\r
 328 \r
 329             remove\r
 330             {\r
 331                 if (_touchDataEventHandler != null)\r
 332                 {\r
 333                     this.TouchSignal().Disconnect(_touchDataCallback);\r
 334                 }\r
 335 \r
 336                 _touchDataEventHandler -= value;\r
 337             }\r
 338         }\r
 339 \r
 340         // Callback for View TouchSignal\r
 341         private bool OnTouch(IntPtr view, IntPtr touchData)\r
 342         {\r
 343             TouchEventArgs e = new TouchEventArgs();\r
 344 \r
 345             e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);\r
 346 \r
 347             if (_touchDataEventHandler != null)\r
 348             {\r
 349                 return _touchDataEventHandler(this, e);\r
 350             }\r
 351             return false;\r
 352         }\r
 353 \r
 354 \r
 355         /**\r
 356           * @brief Event arguments that passed via Hover signal\r
 357           *\r
 358           */\r
 359         public class HoverEventArgs : EventArgs\r
 360         {\r
 361             private Hover _hover;\r
 362             /**\r
 363               * @brief HoverEvent - contains touch points that represent the points\r
 364               * that are currently being hovered or the points where a hover has stopped\r
 365               *\r
 366               */\r
 367             public Hover Hover\r
 368             {\r
 369                 get\r
 370                 {\r
 371                     return _hover;\r
 372                 }\r
 373                 set\r
 374                 {\r
 375                     _hover = value;\r
 376                 }\r
 377             }\r
 378         }\r
 379 \r
 380         private EventHandlerWithReturnType<object, HoverEventArgs, bool> _hoverEventHandler;\r
 381         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 382         private delegate bool HoverEventCallbackType(IntPtr view, IntPtr hoverEvent);\r
 383         private HoverEventCallbackType _hoverEventCallback;\r
 384 \r
 385         /**\r
 386           * @brief Event for Hovered signal which can be used to subscribe/unsubscribe the event handler\r
 387           * provided by the user. Hovered signal is emitted when hover input is received.\r
 388           */\r
 389         public event EventHandlerWithReturnType<object, HoverEventArgs, bool> Hovered\r
 390         {\r
 391             add\r
 392             {\r
 393                 if (_hoverEventHandler == null)\r
 394                 {\r
 395                     _hoverEventCallback = OnHoverEvent;\r
 396                     this.HoveredSignal().Connect(_hoverEventCallback);\r
 397                 }\r
 398 \r
 399                 _hoverEventHandler += value;\r
 400             }\r
 401 \r
 402             remove\r
 403             {\r
 404                 if (_hoverEventHandler != null)\r
 405                 {\r
 406                     this.HoveredSignal().Disconnect(_hoverEventCallback);\r
 407                 }\r
 408 \r
 409                 _hoverEventHandler -= value;\r
 410             }\r
 411         }\r
 412 \r
 413         // Callback for View Hover signal\r
 414         private bool OnHoverEvent(IntPtr view, IntPtr hoverEvent)\r
 415         {\r
 416             HoverEventArgs e = new HoverEventArgs();\r
 417 \r
 418             e.Hover = Tizen.NUI.Hover.GetHoverFromPtr(hoverEvent);\r
 419 \r
 420             if (_hoverEventHandler != null)\r
 421             {\r
 422                 return _hoverEventHandler(this, e);\r
 423             }\r
 424             return false;\r
 425         }\r
 426 \r
 427 \r
 428         /**\r
 429           * @brief Event arguments that passed via Wheel signal\r
 430           *\r
 431           */\r
 432         public class WheelEventArgs : EventArgs\r
 433         {\r
 434             private Wheel _wheel;\r
 435             /**\r
 436               * @brief WheelEvent - store a wheel rolling type : MOUSE_WHEEL or CUSTOM_WHEEL\r
 437               *\r
 438               */\r
 439             public Wheel Wheel\r
 440             {\r
 441                 get\r
 442                 {\r
 443                     return _wheel;\r
 444                 }\r
 445                 set\r
 446                 {\r
 447                     _wheel = value;\r
 448                 }\r
 449             }\r
 450         }\r
 451 \r
 452         private EventHandlerWithReturnType<object, WheelEventArgs, bool> _wheelEventHandler;\r
 453         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 454         private delegate bool WheelEventCallbackType(IntPtr view, IntPtr wheelEvent);\r
 455         private WheelEventCallbackType _wheelEventCallback;\r
 456 \r
 457         /**\r
 458           * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler\r
 459           * provided by the user. WheelMoved signal is emitted when wheel event is received.\r
 460           */\r
 461         public event EventHandlerWithReturnType<object, WheelEventArgs, bool> WheelMoved\r
 462         {\r
 463             add\r
 464             {\r
 465                 if (_wheelEventHandler == null)\r
 466                 {\r
 467                     _wheelEventCallback = OnWheelEvent;\r
 468                     this.WheelEventSignal().Connect(_wheelEventCallback);\r
 469                 }\r
 470 \r
 471                 _wheelEventHandler += value;\r
 472             }\r
 473 \r
 474             remove\r
 475             {\r
 476                 if (_wheelEventHandler != null)\r
 477                 {\r
 478                     this.WheelEventSignal().Disconnect(_wheelEventCallback);\r
 479                 }\r
 480 \r
 481                 _wheelEventHandler -= value;\r
 482             }\r
 483         }\r
 484 \r
 485         // Callback for View Wheel signal\r
 486         private bool OnWheelEvent(IntPtr view, IntPtr wheelEvent)\r
 487         {\r
 488             WheelEventArgs e = new WheelEventArgs();\r
 489 \r
 490             e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);\r
 491 \r
 492             if (_wheelEventHandler != null)\r
 493             {\r
 494                 return _wheelEventHandler(this, e);\r
 495             }\r
 496             return false;\r
 497         }\r
 498 \r
 499 \r
 500         private EventHandler _onStageEventHandler;\r
 501         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 502         private delegate void OnStageEventCallbackType(IntPtr control);\r
 503         private OnStageEventCallbackType _onStageEventCallback;\r
 504 \r
 505         /**\r
 506           * @brief Event for OnStage signal which can be used to subscribe/unsubscribe the event handler\r
 507           * OnStage signal is emitted after the view has been connected to the stage.\r
 508           */\r
 509         public event EventHandler OnStageEvent\r
 510         {\r
 511             add\r
 512             {\r
 513                 if (_onStageEventHandler == null)\r
 514                 {\r
 515                     _onStageEventCallback = OnStage;\r
 516                     this.OnStageSignal().Connect(_onStageEventCallback);\r
 517                 }\r
 518 \r
 519                 _onStageEventHandler += value;\r
 520             }\r
 521 \r
 522             remove\r
 523             {\r
 524                 if (_onStageEventHandler != null)\r
 525                 {\r
 526                     this.OnStageSignal().Disconnect(_onStageEventCallback);\r
 527                 }\r
 528 \r
 529                 _onStageEventHandler -= value;\r
 530             }\r
 531         }\r
 532 \r
 533         // Callback for View OnStage signal\r
 534         private void OnStage(IntPtr data)\r
 535         {\r
 536             if (_onStageEventHandler != null)\r
 537             {\r
 538                 _onStageEventHandler(this, null);\r
 539             }\r
 540         }\r
 541 \r
 542 \r
 543         private EventHandler _offStageEventHandler;\r
 544         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 545         private delegate void OffStageEventCallbackType(IntPtr control);\r
 546         private OffStageEventCallbackType _offStageEventCallback;\r
 547 \r
 548         /**\r
 549           * @brief Event for OffStage signal which can be used to subscribe/unsubscribe the event handler\r
 550           * OffStage signal is emitted after the view has been disconnected from the stage.\r
 551           */\r
 552         public event EventHandler OffStageEvent\r
 553         {\r
 554             add\r
 555             {\r
 556                 if (_offStageEventHandler == null)\r
 557                 {\r
 558                     _offStageEventCallback = OffStage;\r
 559                     this.OnStageSignal().Connect(_offStageEventCallback);\r
 560                 }\r
 561 \r
 562                 _offStageEventHandler += value;\r
 563             }\r
 564 \r
 565             remove\r
 566             {\r
 567                 if (_offStageEventHandler != null)\r
 568                 {\r
 569                     this.OnStageSignal().Disconnect(_offStageEventCallback);\r
 570                 }\r
 571                 _offStageEventHandler -= value;\r
 572             }\r
 573         }\r
 574 \r
 575         // Callback for View OffStage signal\r
 576         private void OffStage(IntPtr data)\r
 577         {\r
 578             if (_offStageEventHandler != null)\r
 579             {\r
 580                 _offStageEventHandler(this, null);\r
 581             }\r
 582         }\r
 583 \r
 584         public static View GetViewFromPtr(global::System.IntPtr cPtr)\r
 585         {\r
 586             View ret = new View(cPtr, false);\r
 587             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 588             return ret;\r
 589         }\r
 590 \r
 591         internal IntPtr GetPtrfromView()\r
 592         {\r
 593             return (IntPtr)swigCPtr;\r
 594         }\r
 595 \r
 596         public Tizen.NUI.PropertyMap Tooltip\r
 597         {\r
 598             get\r
 599             {\r
 600                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();\r
 601                 GetProperty(View.Property.TOOLTIP).Get(temp);\r
 602                 return temp;\r
 603             }\r
 604             set\r
 605             {\r
 606                 SetProperty(View.Property.TOOLTIP, new Tizen.NUI.PropertyValue(value));\r
 607             }\r
 608         }\r
 609 \r
 610         public string TooltipText\r
 611         {\r
 612             set\r
 613             {\r
 614                 SetProperty(View.Property.TOOLTIP, new Tizen.NUI.PropertyValue(value));\r
 615             }\r
 616         }\r
 617 \r
 618         internal class Property : global::System.IDisposable\r
 619         {\r
 620             private global::System.Runtime.InteropServices.HandleRef swigCPtr;\r
 621             protected bool swigCMemOwn;\r
 622 \r
 623             internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)\r
 624             {\r
 625                 swigCMemOwn = cMemoryOwn;\r
 626                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);\r
 627             }\r
 628 \r
 629             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)\r
 630             {\r
 631                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;\r
 632             }\r
 633 \r
 634             ~Property()\r
 635             {\r
 636                 Dispose();\r
 637             }\r
 638 \r
 639             public virtual void Dispose()\r
 640             {\r
 641                 lock (this)\r
 642                 {\r
 643                     if (swigCPtr.Handle != global::System.IntPtr.Zero)\r
 644                     {\r
 645                         if (swigCMemOwn)\r
 646                         {\r
 647                             swigCMemOwn = false;\r
 648                             NDalicPINVOKE.delete_View_Property(swigCPtr);\r
 649                         }\r
 650                         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);\r
 651                     }\r
 652                     global::System.GC.SuppressFinalize(this);\r
 653                 }\r
 654             }\r
 655 \r
 656             internal static readonly int TOOLTIP = NDalicManualPINVOKE.View_Property_TOOLTIP_get();\r
 657 \r
 658             internal Property() : this(NDalicPINVOKE.new_View_Property(), true)\r
 659             {\r
 660                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 661             }\r
 662 \r
 663             internal static readonly int STYLE_NAME = NDalicPINVOKE.View_Property_STYLE_NAME_get();\r
 664             internal static readonly int BACKGROUND_COLOR = NDalicPINVOKE.View_Property_BACKGROUND_COLOR_get();\r
 665             internal static readonly int BACKGROUND_IMAGE = NDalicPINVOKE.View_Property_BACKGROUND_IMAGE_get();\r
 666             internal static readonly int KEY_INPUT_FOCUS = NDalicPINVOKE.View_Property_KEY_INPUT_FOCUS_get();\r
 667             internal static readonly int BACKGROUND = NDalicPINVOKE.View_Property_BACKGROUND_get();\r
 668 \r
 669         }\r
 670 \r
 671 \r
 672         public enum FocusDirection\r
 673         {\r
 674             Left,\r
 675             Right,\r
 676             Up,\r
 677             Down,\r
 678             PageUp,\r
 679             PageDown\r
 680         }\r
 681 \r
 682 \r
 683         public View() : this(NDalicPINVOKE.View_New(), true)\r
 684         {\r
 685             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 686 \r
 687         }\r
 688         internal View(View uiControl) : this(NDalicPINVOKE.new_View__SWIG_1(View.getCPtr(uiControl)), true)\r
 689         {\r
 690             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 691         }\r
 692 \r
 693         internal View Assign(View handle)\r
 694         {\r
 695             View ret = new View(NDalicPINVOKE.View_Assign(swigCPtr, View.getCPtr(handle)), false);\r
 696             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 697             return ret;\r
 698         }\r
 699 \r
 700         public new static View DownCast(BaseHandle handle)\r
 701         {\r
 702             View ret = new View(NDalicPINVOKE.View_DownCast(BaseHandle.getCPtr(handle)), true);\r
 703             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 704             return ret;\r
 705         }\r
 706 \r
 707         public void SetKeyInputFocus()\r
 708         {\r
 709             NDalicPINVOKE.View_SetKeyInputFocus(swigCPtr);\r
 710             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 711         }\r
 712 \r
 713         public bool HasKeyInputFocus()\r
 714         {\r
 715             bool ret = NDalicPINVOKE.View_HasKeyInputFocus(swigCPtr);\r
 716             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 717             return ret;\r
 718         }\r
 719 \r
 720         public void ClearKeyInputFocus()\r
 721         {\r
 722             NDalicPINVOKE.View_ClearKeyInputFocus(swigCPtr);\r
 723             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 724         }\r
 725 \r
 726         internal PinchGestureDetector GetPinchGestureDetector()\r
 727         {\r
 728             PinchGestureDetector ret = new PinchGestureDetector(NDalicPINVOKE.View_GetPinchGestureDetector(swigCPtr), true);\r
 729             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 730             return ret;\r
 731         }\r
 732 \r
 733         internal PanGestureDetector GetPanGestureDetector()\r
 734         {\r
 735             PanGestureDetector ret = new PanGestureDetector(NDalicPINVOKE.View_GetPanGestureDetector(swigCPtr), true);\r
 736             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 737             return ret;\r
 738         }\r
 739 \r
 740         internal TapGestureDetector GetTapGestureDetector()\r
 741         {\r
 742             TapGestureDetector ret = new TapGestureDetector(NDalicPINVOKE.View_GetTapGestureDetector(swigCPtr), true);\r
 743             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 744             return ret;\r
 745         }\r
 746 \r
 747         internal LongPressGestureDetector GetLongPressGestureDetector()\r
 748         {\r
 749             LongPressGestureDetector ret = new LongPressGestureDetector(NDalicPINVOKE.View_GetLongPressGestureDetector(swigCPtr), true);\r
 750             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 751             return ret;\r
 752         }\r
 753 \r
 754         internal void SetStyleName(string styleName)\r
 755         {\r
 756             NDalicPINVOKE.View_SetStyleName(swigCPtr, styleName);\r
 757             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 758         }\r
 759 \r
 760         internal string GetStyleName()\r
 761         {\r
 762             string ret = NDalicPINVOKE.View_GetStyleName(swigCPtr);\r
 763             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 764             return ret;\r
 765         }\r
 766 \r
 767         internal void SetBackgroundColor(Vector4 color)\r
 768         {\r
 769             NDalicPINVOKE.View_SetBackgroundColor(swigCPtr, Vector4.getCPtr(color));\r
 770             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 771         }\r
 772 \r
 773         internal Vector4 GetBackgroundColor()\r
 774         {\r
 775             Vector4 ret = new Vector4(NDalicPINVOKE.View_GetBackgroundColor(swigCPtr), true);\r
 776             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 777             return ret;\r
 778         }\r
 779 \r
 780         internal void SetBackgroundImage(Image image)\r
 781         {\r
 782             NDalicPINVOKE.View_SetBackgroundImage(swigCPtr, Image.getCPtr(image));\r
 783             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 784         }\r
 785 \r
 786         public void ClearBackground()\r
 787         {\r
 788             NDalicPINVOKE.View_ClearBackground(swigCPtr);\r
 789             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 790         }\r
 791 \r
 792         internal ControlKeySignal KeyEventSignal()\r
 793         {\r
 794             ControlKeySignal ret = new ControlKeySignal(NDalicPINVOKE.View_KeyEventSignal(swigCPtr), false);\r
 795             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 796             return ret;\r
 797         }\r
 798 \r
 799         internal KeyInputFocusSignal KeyInputFocusGainedSignal()\r
 800         {\r
 801             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusGainedSignal(swigCPtr), false);\r
 802             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 803             return ret;\r
 804         }\r
 805 \r
 806         internal KeyInputFocusSignal KeyInputFocusLostSignal()\r
 807         {\r
 808             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusLostSignal(swigCPtr), false);\r
 809             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 810             return ret;\r
 811         }\r
 812 \r
 813         internal View(ViewImpl implementation) : this(NDalicPINVOKE.new_View__SWIG_2(ViewImpl.getCPtr(implementation)), true)\r
 814         {\r
 815             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 816         }\r
 817 \r
 818         internal enum PropertyRange\r
 819         {\r
 820             PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX,\r
 821             CONTROL_PROPERTY_START_INDEX = PROPERTY_START_INDEX,\r
 822             CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX + 1000\r
 823         }\r
 824 \r
 825         public string StyleName\r
 826         {\r
 827             get\r
 828             {\r
 829                 string temp;\r
 830                 GetProperty(View.Property.STYLE_NAME).Get(out temp);\r
 831                 return temp;\r
 832             }\r
 833             set\r
 834             {\r
 835                 SetProperty(View.Property.STYLE_NAME, new Tizen.NUI.PropertyValue(value));\r
 836             }\r
 837         }\r
 838 \r
 839         public Color BackgroundColor\r
 840         {\r
 841             get\r
 842             {\r
 843                 Color temp = new Color(0.0f, 0.0f, 0.0f, 0.0f);\r
 844                 GetProperty(View.Property.BACKGROUND_COLOR).Get(temp);\r
 845                 return temp;\r
 846             }\r
 847             set\r
 848             {\r
 849                 SetProperty(View.Property.BACKGROUND_COLOR, new Tizen.NUI.PropertyValue(value));\r
 850             }\r
 851         }\r
 852 \r
 853         public string BackgroundImage\r
 854         {\r
 855             get\r
 856             {\r
 857                 string temp;\r
 858                 GetProperty(View.Property.BACKGROUND).Get(out temp);\r
 859                 return temp;\r
 860             }\r
 861             set\r
 862             {\r
 863                 SetProperty(View.Property.BACKGROUND, new Tizen.NUI.PropertyValue(value));\r
 864             }\r
 865         }\r
 866         internal bool KeyInputFocus\r
 867         {\r
 868             get\r
 869             {\r
 870                 bool temp = false;\r
 871                 GetProperty(View.Property.KEY_INPUT_FOCUS).Get(ref temp);\r
 872                 return temp;\r
 873             }\r
 874             set\r
 875             {\r
 876                 SetProperty(View.Property.KEY_INPUT_FOCUS, new Tizen.NUI.PropertyValue(value));\r
 877             }\r
 878         }\r
 879         public Tizen.NUI.PropertyMap Background\r
 880         {\r
 881             get\r
 882             {\r
 883                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();\r
 884                 GetProperty(View.Property.BACKGROUND).Get(temp);\r
 885                 return temp;\r
 886             }\r
 887             set\r
 888             {\r
 889                 SetProperty(View.Property.BACKGROUND, new Tizen.NUI.PropertyValue(value));\r
 890             }\r
 891         }\r
 892 \r
 893         public Vector2 CellIndex\r
 894         {\r
 895             get\r
 896             {\r
 897                 Vector2 temp = new Vector2(0.0f, 0.0f);\r
 898                 GetProperty(TableView.ChildProperty.CELL_INDEX).Get(temp);\r
 899                 return temp;\r
 900             }\r
 901             set\r
 902             {\r
 903                 SetProperty(TableView.ChildProperty.CELL_INDEX, new Tizen.NUI.PropertyValue(value));\r
 904             }\r
 905         }\r
 906         public float RowSpan\r
 907         {\r
 908             get\r
 909             {\r
 910                 float temp = 0.0f;\r
 911                 GetProperty(TableView.ChildProperty.ROW_SPAN).Get(ref temp);\r
 912                 return temp;\r
 913             }\r
 914             set\r
 915             {\r
 916                 SetProperty(TableView.ChildProperty.ROW_SPAN, new Tizen.NUI.PropertyValue(value));\r
 917             }\r
 918         }\r
 919         public float ColumnSpan\r
 920         {\r
 921             get\r
 922             {\r
 923                 float temp = 0.0f;\r
 924                 GetProperty(TableView.ChildProperty.COLUMN_SPAN).Get(ref temp);\r
 925                 return temp;\r
 926             }\r
 927             set\r
 928             {\r
 929                 SetProperty(TableView.ChildProperty.COLUMN_SPAN, new Tizen.NUI.PropertyValue(value));\r
 930             }\r
 931         }\r
 932         public string CellHorizontalAlignment\r
 933         {\r
 934             get\r
 935             {\r
 936                 string temp;\r
 937                 GetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT).Get(out temp);\r
 938                 return temp;\r
 939             }\r
 940             set\r
 941             {\r
 942                 SetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT, new Tizen.NUI.PropertyValue(value));\r
 943             }\r
 944         }\r
 945         public string CellVerticalAlignment\r
 946         {\r
 947             get\r
 948             {\r
 949                 string temp;\r
 950                 GetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT).Get(out temp);\r
 951                 return temp;\r
 952             }\r
 953             set\r
 954             {\r
 955                 SetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT, new Tizen.NUI.PropertyValue(value));\r
 956             }\r
 957         }\r
 958 \r
 959         public float Flex\r
 960         {\r
 961             get\r
 962             {\r
 963                 float temp = 0.0f;\r
 964                 GetProperty(FlexContainer.ChildProperty.FLEX).Get(ref temp);\r
 965                 return temp;\r
 966             }\r
 967             set\r
 968             {\r
 969                 SetProperty(FlexContainer.ChildProperty.FLEX, new Tizen.NUI.PropertyValue(value));\r
 970             }\r
 971         }\r
 972         public int AlignSelf\r
 973         {\r
 974             get\r
 975             {\r
 976                 int temp = 0;\r
 977                 GetProperty(FlexContainer.ChildProperty.ALIGN_SELF).Get(ref temp);\r
 978                 return temp;\r
 979             }\r
 980             set\r
 981             {\r
 982                 SetProperty(FlexContainer.ChildProperty.ALIGN_SELF, new Tizen.NUI.PropertyValue(value));\r
 983             }\r
 984         }\r
 985         public Vector4 FlexMargin\r
 986         {\r
 987             get\r
 988             {\r
 989                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);\r
 990                 GetProperty(FlexContainer.ChildProperty.FLEX_MARGIN).Get(temp);\r
 991                 return temp;\r
 992             }\r
 993             set\r
 994             {\r
 995                 SetProperty(FlexContainer.ChildProperty.FLEX_MARGIN, new Tizen.NUI.PropertyValue(value));\r
 996             }\r
 997         }\r
 998 \r
 999         public bool Focusable\r
1000         {\r
1001             set\r
1002             {\r
1003                 SetKeyboardFocusable(value);\r
1004             }\r
1005             get\r
1006             {\r
1007                 return IsKeyboardFocusable();\r
1008             }\r
1009         }\r
1010 \r
1011     }\r
1012 \r
1013 }\r