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

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