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