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