src/Tizen.NUI/src/public/Widget.cs

   1 /** Copyright (c) 2017 Samsung Electronics Co., Ltd.
   2 *
   3 * Licensed under the Apache License, Version 2.0 (the "License");
   4 * you may not use this file except in compliance with the License.
   5 * You may obtain a copy of the License at
   6 *
   7 * http://www.apache.org/licenses/LICENSE-2.0
   8 *
   9 * Unless required by applicable law or agreed to in writing, software
  10 * distributed under the License is distributed on an "AS IS" BASIS,
  11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 * See the License for the specific language governing permissions and
  13 * limitations under the License.
  14 *
  15 */
  16 using System;
  17 using System.Runtime.InteropServices;
  18 using Tizen.Applications;
  19
  20 namespace Tizen.NUI
  21 {
  22     /// <summary>
  23     /// Widget object should be created by WidgetApplication.
  24     /// </summary>
  25     public class Widget : BaseHandle
  26     {
  27         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  28
  29         internal Widget(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicManualPINVOKE.Widget_SWIGUpcast(cPtr), cMemoryOwn)
  30         {
  31             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  32         }
  33
  34         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Widget obj)
  35         {
  36             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  37         }
  38
  39         /// <summary>
  40         /// To make Widget instance be disposed.
  41         /// </summary>
  42         protected override void Dispose(DisposeTypes type)
  43         {
  44             if(disposed)
  45             {
  46                 return;
  47             }
  48
  49             if(type == DisposeTypes.Explicit)
  50             {
  51                 //Called by User
  52                 //Release your own managed resources here.
  53                 //You should release all of your own disposable objects here.
  54             }
  55
  56             //Release your own unmanaged resources here.
  57             //You should not access any managed member here except static instance.
  58             //because the execution order of Finalizes is non-deterministic.
  59
  60             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  61             {
  62                 if (swigCMemOwn)
  63                 {
  64                     swigCMemOwn = false;
  65                     NDalicManualPINVOKE.delete_Widget(swigCPtr);
  66                 }
  67                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  68             }
  69
  70             base.Dispose(type);
  71         }
  72
  73         /// <summary>
  74         /// This is the constructor for Widget.
  75         /// </summary>
  76         /// <param name="id">for widget instance</param>
  77         /// <since_tizen> 4 </since_tizen>
  78         public Widget(string id) : this(NDalicManualPINVOKE.Widget_New(id), true)
  79         {
  80             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  81         }
  82
  83         internal Widget(Widget widget) : this(NDalicManualPINVOKE.new_Widget__SWIG_1(Widget.getCPtr(widget)), true)
  84         {
  85             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  86         }
  87
  88         internal Widget Assign(Widget widget)
  89         {
  90             Widget ret = new Widget(NDalicManualPINVOKE.Widget_Assign(swigCPtr, Widget.getCPtr(widget)), false);
  91             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  92             return ret;
  93         }
  94
  95         /// <summary>
  96         /// Event arguments that passed via KeyEvent signal.
  97         /// </summary>
  98         public class CreateEventArgs : EventArgs
  99         {
 100             /// <summary>
 101             /// widget data.
 102             /// </summary>
 103             /// <since_tizen> 4 </since_tizen>
 104             public WidgetData WidgetData
 105             {
 106                 get;
 107                 set;
 108             }
 109
 110             /// <summary>
 111             /// a bundle.
 112             /// </summary>
 113             /// <since_tizen> 4 </since_tizen>
 114             public SWIGTYPE_p_bundle Bundle
 115             {
 116                 get;
 117                 set;
 118             }
 119
 120             /// <summary>
 121             /// window size.
 122             /// </summary>
 123             /// <since_tizen> 4 </since_tizen>
 124             public Size2D WindowSize
 125             {
 126                 get;
 127                 set;
 128             }
 129         }
 130
 131         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 132         private delegate void CreateCallbackType(IntPtr widgetData, IntPtr bundle, IntPtr windowSize);
 133         private CreateCallbackType _createCallback;
 134         private EventHandler<CreateEventArgs> _createEventHandler;
 135
 136         /// <summary>
 137         /// Create event.
 138         /// </summary>
 139         /// <since_tizen> 4 </since_tizen>
 140         public event EventHandler<CreateEventArgs> Create
 141         {
 142             add
 143             {
 144                 if (_createEventHandler == null)
 145                 {
 146                     _createCallback = OnCreate;
 147                     CreateSignal().Connect(_createCallback);
 148                 }
 149
 150                 _createEventHandler += value;
 151             }
 152
 153             remove
 154             {
 155                 _createEventHandler -= value;
 156
 157                 if (_createEventHandler == null && CreateSignal().Empty() == false)
 158                 {
 159                    CreateSignal().Disconnect(_createCallback);
 160                 }
 161             }
 162         }
 163
 164         private void OnCreate(IntPtr widgetData, IntPtr bundle, IntPtr windowSize)
 165         {
 166             CreateEventArgs e = new CreateEventArgs();
 167             if (widgetData != null)
 168             {
 169                 e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
 170             }
 171             if (bundle != null)
 172             {
 173                 e.Bundle = new SWIGTYPE_p_bundle(bundle, false);
 174             }
 175             if (windowSize != null)
 176             {
 177                 var val = new Uint16Pair(windowSize, false);
 178                 e.WindowSize = val;
 179                 val.Dispose();
 180             }
 181
 182             _createEventHandler?.Invoke(this, e);
 183         }
 184
 185         internal WidgetInstanceCreateSignalType CreateSignal()
 186         {
 187             WidgetInstanceCreateSignalType ret = new WidgetInstanceCreateSignalType(NDalicManualPINVOKE.Widget_CreateSignal(swigCPtr), false);
 188             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 189             return ret;
 190         }
 191
 192         /// <summary>
 193         /// Event arguments that passed via terminate event signal.
 194         /// </summary>
 195         public class TerminateEventArgs : EventArgs
 196         {
 197             /// <summary>
 198             /// widget data.
 199             /// </summary>
 200             /// <since_tizen> 4 </since_tizen>
 201             public WidgetData WidgetData
 202             {
 203                 get;
 204                 set;
 205             }
 206
 207             /// <summary>
 208             /// a bundle.
 209             /// </summary>
 210             /// <since_tizen> 4 </since_tizen>
 211             public SWIGTYPE_p_bundle Bundle
 212             {
 213                 get;
 214                 set;
 215             }
 216
 217             /// <summary>
 218             /// widget terminate type.
 219             /// </summary>
 220             /// <since_tizen> 4 </since_tizen>
 221             public WidgetTerminateType WidgetTerminateType
 222             {
 223                 get;
 224                 set;
 225             }
 226         }
 227
 228         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 229         private delegate void TerminateCallbackType(IntPtr widgetData, IntPtr bundle, WidgetTerminateType widgetTerminateType);
 230         private TerminateCallbackType _terminateCallback;
 231         private EventHandler<TerminateEventArgs> _terminateEventHandler;
 232
 233         /// <summary>
 234         /// Terminate event.
 235         /// </summary>
 236         /// <since_tizen> 4 </since_tizen>
 237         public event EventHandler<TerminateEventArgs> Terminate
 238         {
 239             add
 240             {
 241                 if (_terminateEventHandler == null)
 242                 {
 243                     _terminateCallback = OnTerminate;
 244                     TerminateSignal().Connect(_terminateCallback);
 245                 }
 246
 247                 _terminateEventHandler += value;
 248             }
 249
 250             remove
 251             {
 252                 _terminateEventHandler -= value;
 253
 254                 if (_terminateEventHandler == null && TerminateSignal().Empty() == false)
 255                 {
 256                    TerminateSignal().Disconnect(_terminateCallback);
 257                 }
 258             }
 259         }
 260
 261         private void OnTerminate(IntPtr widgetData, IntPtr bundle, WidgetTerminateType widgetTerminateType)
 262         {
 263             TerminateEventArgs e = new TerminateEventArgs();
 264             if (widgetData != null)
 265             {
 266                 e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
 267             }
 268             if (bundle != null)
 269             {
 270                 e.Bundle = new SWIGTYPE_p_bundle(bundle, false);
 271             }
 272
 273             e.WidgetTerminateType = widgetTerminateType;
 274             _terminateEventHandler?.Invoke(this, e);
 275         }
 276
 277         internal WidgetInstanceTerminateSignalType TerminateSignal()
 278         {
 279             WidgetInstanceTerminateSignalType ret = new WidgetInstanceTerminateSignalType(NDalicManualPINVOKE.Widget_TerminateSignal(swigCPtr), false);
 280             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 281             return ret;
 282         }
 283
 284         /// <summary>
 285         /// Event arguments that passed via pause event signal.
 286         /// </summary>
 287         public class PauseEventArgs : EventArgs
 288         {
 289             /// <summary>
 290             /// widget data.
 291             /// </summary>
 292             /// <since_tizen> 4 </since_tizen>
 293             public WidgetData WidgetData
 294             {
 295                 get;
 296                 set;
 297             }
 298         }
 299
 300         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 301         private delegate void PauseCallbackType(IntPtr widgetData);
 302         private PauseCallbackType _pauseCallback;
 303         private EventHandler<PauseEventArgs> _pauseEventHandler;
 304
 305         /// <summary>
 306         /// Pause event.
 307         /// </summary>
 308         /// <since_tizen> 4 </since_tizen>
 309         public event EventHandler<PauseEventArgs> Pause
 310         {
 311             add
 312             {
 313                 if (_pauseEventHandler == null)
 314                 {
 315                     _pauseCallback = OnPause;
 316                     PauseSignal().Connect(_pauseCallback);
 317                 }
 318
 319                 _pauseEventHandler += value;
 320             }
 321
 322             remove
 323             {
 324                 _pauseEventHandler -= value;
 325
 326                 if (_pauseEventHandler == null && PauseSignal().Empty() == false)
 327                 {
 328                    PauseSignal().Disconnect(_pauseCallback);
 329                 }
 330             }
 331         }
 332
 333         private void OnPause(IntPtr widgetData)
 334         {
 335             PauseEventArgs e = new PauseEventArgs();
 336             if (widgetData != null)
 337             {
 338                 e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
 339             }
 340
 341             _pauseEventHandler?.Invoke(this, e);
 342         }
 343
 344         internal WidgetInstancePauseOrResumeSignalType PauseSignal()
 345         {
 346             WidgetInstancePauseOrResumeSignalType ret = new WidgetInstancePauseOrResumeSignalType(NDalicManualPINVOKE.Widget_PauseSignal(swigCPtr), false);
 347             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 348             return ret;
 349         }
 350
 351         /// <summary>
 352         /// Event arguments that passed via pause event signal.
 353         /// </summary>
 354         public class ResumeEventArgs : EventArgs
 355         {
 356             /// <summary>
 357             /// widget data.
 358             /// </summary>
 359             /// <since_tizen> 4 </since_tizen>
 360             public WidgetData WidgetData
 361             {
 362                 get;
 363                 set;
 364             }
 365         }
 366
 367         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 368         private delegate void ResumeCallbackType(IntPtr widgetData);
 369         private ResumeCallbackType _resumeCallback;
 370         private EventHandler<ResumeEventArgs> _resumeEventHandler;
 371
 372         /// <summary>
 373         /// Resume event.
 374         /// </summary>
 375         /// <since_tizen> 4 </since_tizen>
 376         public event EventHandler<ResumeEventArgs> Resume
 377         {
 378             add
 379             {
 380                 if (_resumeEventHandler == null)
 381                 {
 382                     _resumeCallback = OnResume;
 383                     ResumeSignal().Connect(_resumeCallback);
 384                 }
 385
 386                 _resumeEventHandler += value;
 387             }
 388
 389             remove
 390             {
 391                 _resumeEventHandler -= value;
 392
 393                 if (_resumeEventHandler == null && ResumeSignal().Empty() == false)
 394                 {
 395                    ResumeSignal().Disconnect(_resumeCallback);
 396                 }
 397             }
 398         }
 399
 400         private void OnResume(IntPtr widgetData)
 401         {
 402             ResumeEventArgs e = new ResumeEventArgs();
 403             if (widgetData != null)
 404             {
 405                 e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
 406             }
 407
 408             _resumeEventHandler?.Invoke(this, e);
 409         }
 410
 411         internal WidgetInstancePauseOrResumeSignalType ResumeSignal()
 412         {
 413             WidgetInstancePauseOrResumeSignalType ret = new WidgetInstancePauseOrResumeSignalType(NDalicManualPINVOKE.Widget_ResumeSignal(swigCPtr), false);
 414             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 415             return ret;
 416         }
 417
 418         /// <summary>
 419         /// Event arguments that passed via resize signal.
 420         /// </summary>
 421         public class ResizeEventArgs : EventArgs
 422         {
 423             /// <summary>
 424             /// widget data.
 425             /// </summary>
 426             /// <since_tizen> 4 </since_tizen>
 427             public WidgetData WidgetData
 428             {
 429                 get;
 430                 set;
 431             }
 432
 433             /// <summary>
 434             /// window size.
 435             /// </summary>
 436             /// <since_tizen> 4 </since_tizen>
 437             public Size2D WindowSize
 438             {
 439                 get;
 440                 set;
 441             }
 442         }
 443
 444         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 445         private delegate void ResizeCallbackType(IntPtr widgetData, IntPtr windowSize);
 446         private ResizeCallbackType _resizeCallback;
 447         private EventHandler<ResizeEventArgs> _resizeEventHandler;
 448
 449         /// <summary>
 450         /// Resize event.
 451         /// </summary>
 452         /// <since_tizen> 4 </since_tizen>
 453         public event EventHandler<ResizeEventArgs> Resize
 454         {
 455             add
 456             {
 457                 if (_resizeEventHandler == null)
 458                 {
 459                     _resizeCallback = OnResize;
 460                     ResizeSignal().Connect(_resizeCallback);
 461                 }
 462
 463                 _resizeEventHandler += value;
 464             }
 465
 466             remove
 467             {
 468                 _resizeEventHandler -= value;
 469
 470                 if (_resizeEventHandler == null && ResizeSignal().Empty() == false)
 471                 {
 472                    ResizeSignal().Disconnect(_resizeCallback);
 473                 }
 474             }
 475         }
 476
 477         private void OnResize(IntPtr widgetData, IntPtr windowSize)
 478         {
 479             ResizeEventArgs e = new ResizeEventArgs();
 480             if (widgetData != null)
 481             {
 482                 e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
 483             }
 484             if (windowSize != null)
 485             {
 486                 var val = new Uint16Pair(windowSize, false);
 487                 e.WindowSize = val;
 488                 val.Dispose();
 489             }
 490
 491             _resizeEventHandler?.Invoke(this, e);
 492         }
 493
 494         internal WidgetInstanceResizeSignalType ResizeSignal()
 495         {
 496             WidgetInstanceResizeSignalType ret = new WidgetInstanceResizeSignalType(NDalicManualPINVOKE.Widget_ResizeSignal(swigCPtr), false);
 497             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 498             return ret;
 499         }
 500
 501         /// <summary>
 502         /// Event arguments that passed via update event signal.
 503         /// </summary>
 504         public class UpdateEventArgs : EventArgs
 505         {
 506             /// <summary>
 507             /// widget data.
 508             /// </summary>
 509             /// <since_tizen> 4 </since_tizen>
 510             public WidgetData WidgetData
 511             {
 512                 get;
 513                 set;
 514             }
 515
 516             /// <summary>
 517             /// A bundle.
 518             /// </summary>
 519             /// <since_tizen> 4 </since_tizen>
 520             public SWIGTYPE_p_bundle Bundle
 521             {
 522                 get;
 523                 set;
 524             }
 525
 526             /// <summary>
 527             /// It means several steps.
 528             /// </summary>
 529             /// <remark>
 530             /// 0 -> no force
 531             /// 1 -> force but do someting
 532             /// 2 -> force
 533             /// </remark>
 534             /// <since_tizen> 4 </since_tizen>
 535             public int Force
 536             {
 537                 get;
 538                 set;
 539             }
 540         }
 541
 542         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 543         private delegate void UpdateCallbackType(IntPtr widgetData, IntPtr bundle, int force);
 544         private UpdateCallbackType _updateCallback;
 545         private EventHandler<UpdateEventArgs> _updateEventHandler;
 546
 547         /// <summary>
 548         /// Update event.
 549         /// </summary>
 550         /// <since_tizen> 4 </since_tizen>
 551         public event EventHandler<UpdateEventArgs> Update
 552         {
 553             add
 554             {
 555                 if (_updateEventHandler == null)
 556                 {
 557                     _updateCallback = OnUpdate;
 558                     UpdateSignal().Connect(_updateCallback);
 559                 }
 560
 561                 _updateEventHandler += value;
 562             }
 563
 564             remove
 565             {
 566                 _updateEventHandler -= value;
 567
 568                 if (_updateEventHandler == null && UpdateSignal().Empty() == false)
 569                 {
 570                    UpdateSignal().Disconnect(_updateCallback);
 571                 }
 572             }
 573         }
 574
 575         private void OnUpdate(IntPtr widgetData, IntPtr bundle, int force)
 576         {
 577             UpdateEventArgs e = new UpdateEventArgs();
 578             if (widgetData != null)
 579             {
 580                 e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
 581             }
 582             if (bundle != null)
 583             {
 584                 e.Bundle = new SWIGTYPE_p_bundle(bundle, false);
 585             }
 586             e.Force = force;
 587
 588             _updateEventHandler?.Invoke(this, e);
 589         }
 590
 591         internal WidgetInstanceUpdateSignalType UpdateSignal()
 592         {
 593             WidgetInstanceUpdateSignalType ret = new WidgetInstanceUpdateSignalType(NDalicManualPINVOKE.Widget_UpdateSignal(swigCPtr), false);
 594             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 595             return ret;
 596         }
 597
 598         /// <summary>
 599         /// Enumeration for terminate type of widget instance.
 600         /// </summary>
 601         /// <since_tizen> 4 </since_tizen>
 602         public enum WidgetTerminateType
 603         {
 604             /// <summary>
 605             /// User deleted this widget from the viewer
 606             /// </summary>
 607             Permanent,
 608             /// <summary>
 609             /// Widget is deleted because of other reasons (e.g. widget process is terminated temporarily by the system)
 610             /// </summary>
 611             Temporary
 612         }
 613
 614         /// <summary>
 615         /// Enumeration for lifecycle event type of widget instance.
 616         /// </summary>
 617         /// <since_tizen> 4 </since_tizen>
 618         public enum WidgetLifecycleEventType
 619         {
 620             /// <summary>
 621             /// The widget is dead.
 622             /// </summary>
 623             AppDead = 0,
 624             /// <summary>
 625             /// The widget is dead.
 626             /// </summary>
 627             Create = 1,
 628             /// <summary>
 629             /// The widget is destroyed.
 630             /// </summary>
 631             Destroy = 2,
 632             /// <summary>
 633             /// The widget is paused.
 634             /// </summary>
 635             Pause = 3,
 636             /// <summary>
 637             /// The widget is resumed.
 638             /// </summary>
 639             Resume = 4
 640         }
 641     }
 642 }