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 data.
 103             /// </summary>
 104             /// <since_tizen> 4 </since_tizen>
 105             public WidgetData WidgetData
 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 size.
 123             /// </summary>
 124             /// <since_tizen> 4 </since_tizen>
 125             public Size2D WindowSize
 126             {
 127                 get;
 128                 set;
 129             }
 130         }
 131
 132         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 133         private delegate void CreateCallbackType(IntPtr widgetData, IntPtr bundle, IntPtr windowSize);
 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(IntPtr widgetData, IntPtr bundle, IntPtr windowSize)
 166         {
 167             CreateEventArgs e = new CreateEventArgs();
 168             if (widgetData != null)
 169             {
 170                 e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
 171             }
 172             if (bundle != null)
 173             {
 174                 e.Bundle = new SWIGTYPE_p_bundle(bundle, false);
 175             }
 176             if (windowSize != null)
 177             {
 178                 var val = new Uint16Pair(windowSize, false);
 179                 e.WindowSize = val;
 180                 val.Dispose();
 181             }
 182
 183             _createEventHandler?.Invoke(this, e);
 184         }
 185
 186         internal WidgetInstanceCreateSignalType CreateSignal()
 187         {
 188             WidgetInstanceCreateSignalType ret = new WidgetInstanceCreateSignalType(NDalicManualPINVOKE.Widget_CreateSignal(swigCPtr), false);
 189             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 190             return ret;
 191         }
 192
 193         /// <summary>
 194         /// Event arguments that passed via terminate event signal.
 195         /// </summary>
 196         public class TerminateEventArgs : EventArgs
 197         {
 198             /// <summary>
 199             /// widget data.
 200             /// </summary>
 201             /// <since_tizen> 4 </since_tizen>
 202             public WidgetData WidgetData
 203             {
 204                 get;
 205                 set;
 206             }
 207
 208             /// <summary>
 209             /// a bundle.
 210             /// </summary>
 211             /// <since_tizen> 4 </since_tizen>
 212             public SWIGTYPE_p_bundle Bundle
 213             {
 214                 get;
 215                 set;
 216             }
 217
 218             /// <summary>
 219             /// widget terminate type.
 220             /// </summary>
 221             /// <since_tizen> 4 </since_tizen>
 222             public WidgetTerminateType WidgetTerminateType
 223             {
 224                 get;
 225                 set;
 226             }
 227         }
 228
 229         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 230         private delegate void TerminateCallbackType(IntPtr widgetData, IntPtr bundle, WidgetTerminateType widgetTerminateType);
 231         private TerminateCallbackType _terminateCallback;
 232         private EventHandler<TerminateEventArgs> _terminateEventHandler;
 233
 234         /// <summary>
 235         /// Terminate event.
 236         /// </summary>
 237         /// <since_tizen> 4 </since_tizen>
 238         public event EventHandler<TerminateEventArgs> Terminate
 239         {
 240             add
 241             {
 242                 if (_terminateEventHandler == null)
 243                 {
 244                     _terminateCallback = OnTerminate;
 245                     TerminateSignal().Connect(_terminateCallback);
 246                 }
 247
 248                 _terminateEventHandler += value;
 249             }
 250
 251             remove
 252             {
 253                 _terminateEventHandler -= value;
 254
 255                 if (_terminateEventHandler == null && TerminateSignal().Empty() == false)
 256                 {
 257                    TerminateSignal().Disconnect(_terminateCallback);
 258                 }
 259             }
 260         }
 261
 262         private void OnTerminate(IntPtr widgetData, IntPtr bundle, WidgetTerminateType widgetTerminateType)
 263         {
 264             TerminateEventArgs e = new TerminateEventArgs();
 265             if (widgetData != null)
 266             {
 267                 e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
 268             }
 269             if (bundle != null)
 270             {
 271                 e.Bundle = new SWIGTYPE_p_bundle(bundle, false);
 272             }
 273
 274             e.WidgetTerminateType = widgetTerminateType;
 275             _terminateEventHandler?.Invoke(this, e);
 276         }
 277
 278         internal WidgetInstanceTerminateSignalType TerminateSignal()
 279         {
 280             WidgetInstanceTerminateSignalType ret = new WidgetInstanceTerminateSignalType(NDalicManualPINVOKE.Widget_TerminateSignal(swigCPtr), false);
 281             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 282             return ret;
 283         }
 284
 285         /// <summary>
 286         /// Event arguments that passed via pause event signal.
 287         /// </summary>
 288         public class PauseEventArgs : EventArgs
 289         {
 290             /// <summary>
 291             /// widget data.
 292             /// </summary>
 293             /// <since_tizen> 4 </since_tizen>
 294             public WidgetData WidgetData
 295             {
 296                 get;
 297                 set;
 298             }
 299         }
 300
 301         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 302         private delegate void PauseCallbackType(IntPtr widgetData);
 303         private PauseCallbackType _pauseCallback;
 304         private EventHandler<PauseEventArgs> _pauseEventHandler;
 305
 306         /// <summary>
 307         /// Pause event.
 308         /// </summary>
 309         /// <since_tizen> 4 </since_tizen>
 310         public event EventHandler<PauseEventArgs> Pause
 311         {
 312             add
 313             {
 314                 if (_pauseEventHandler == null)
 315                 {
 316                     _pauseCallback = OnPause;
 317                     PauseSignal().Connect(_pauseCallback);
 318                 }
 319
 320                 _pauseEventHandler += value;
 321             }
 322
 323             remove
 324             {
 325                 _pauseEventHandler -= value;
 326
 327                 if (_pauseEventHandler == null && PauseSignal().Empty() == false)
 328                 {
 329                    PauseSignal().Disconnect(_pauseCallback);
 330                 }
 331             }
 332         }
 333
 334         private void OnPause(IntPtr widgetData)
 335         {
 336             PauseEventArgs e = new PauseEventArgs();
 337             if (widgetData != null)
 338             {
 339                 e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
 340             }
 341
 342             _pauseEventHandler?.Invoke(this, e);
 343         }
 344
 345         internal WidgetInstancePauseOrResumeSignalType PauseSignal()
 346         {
 347             WidgetInstancePauseOrResumeSignalType ret = new WidgetInstancePauseOrResumeSignalType(NDalicManualPINVOKE.Widget_PauseSignal(swigCPtr), false);
 348             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 349             return ret;
 350         }
 351
 352         /// <summary>
 353         /// Event arguments that passed via pause event signal.
 354         /// </summary>
 355         public class ResumeEventArgs : EventArgs
 356         {
 357             /// <summary>
 358             /// widget data.
 359             /// </summary>
 360             /// <since_tizen> 4 </since_tizen>
 361             public WidgetData WidgetData
 362             {
 363                 get;
 364                 set;
 365             }
 366         }
 367
 368         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 369         private delegate void ResumeCallbackType(IntPtr widgetData);
 370         private ResumeCallbackType _resumeCallback;
 371         private EventHandler<ResumeEventArgs> _resumeEventHandler;
 372
 373         /// <summary>
 374         /// Resume event.
 375         /// </summary>
 376         /// <since_tizen> 4 </since_tizen>
 377         public event EventHandler<ResumeEventArgs> Resume
 378         {
 379             add
 380             {
 381                 if (_resumeEventHandler == null)
 382                 {
 383                     _resumeCallback = OnResume;
 384                     ResumeSignal().Connect(_resumeCallback);
 385                 }
 386
 387                 _resumeEventHandler += value;
 388             }
 389
 390             remove
 391             {
 392                 _resumeEventHandler -= value;
 393
 394                 if (_resumeEventHandler == null && ResumeSignal().Empty() == false)
 395                 {
 396                    ResumeSignal().Disconnect(_resumeCallback);
 397                 }
 398             }
 399         }
 400
 401         private void OnResume(IntPtr widgetData)
 402         {
 403             ResumeEventArgs e = new ResumeEventArgs();
 404             if (widgetData != null)
 405             {
 406                 e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
 407             }
 408
 409             _resumeEventHandler?.Invoke(this, e);
 410         }
 411
 412         internal WidgetInstancePauseOrResumeSignalType ResumeSignal()
 413         {
 414             WidgetInstancePauseOrResumeSignalType ret = new WidgetInstancePauseOrResumeSignalType(NDalicManualPINVOKE.Widget_ResumeSignal(swigCPtr), false);
 415             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 416             return ret;
 417         }
 418
 419         /// <summary>
 420         /// Event arguments that passed via resize signal.
 421         /// </summary>
 422         public class ResizeEventArgs : EventArgs
 423         {
 424             /// <summary>
 425             /// widget data.
 426             /// </summary>
 427             /// <since_tizen> 4 </since_tizen>
 428             public WidgetData WidgetData
 429             {
 430                 get;
 431                 set;
 432             }
 433
 434             /// <summary>
 435             /// window size.
 436             /// </summary>
 437             /// <since_tizen> 4 </since_tizen>
 438             public Size2D WindowSize
 439             {
 440                 get;
 441                 set;
 442             }
 443         }
 444
 445         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 446         private delegate void ResizeCallbackType(IntPtr widgetData, IntPtr windowSize);
 447         private ResizeCallbackType _resizeCallback;
 448         private EventHandler<ResizeEventArgs> _resizeEventHandler;
 449
 450         /// <summary>
 451         /// Resize event.
 452         /// </summary>
 453         /// <since_tizen> 4 </since_tizen>
 454         public event EventHandler<ResizeEventArgs> Resize
 455         {
 456             add
 457             {
 458                 if (_resizeEventHandler == null)
 459                 {
 460                     _resizeCallback = OnResize;
 461                     ResizeSignal().Connect(_resizeCallback);
 462                 }
 463
 464                 _resizeEventHandler += value;
 465             }
 466
 467             remove
 468             {
 469                 _resizeEventHandler -= value;
 470
 471                 if (_resizeEventHandler == null && ResizeSignal().Empty() == false)
 472                 {
 473                    ResizeSignal().Disconnect(_resizeCallback);
 474                 }
 475             }
 476         }
 477
 478         private void OnResize(IntPtr widgetData, IntPtr windowSize)
 479         {
 480             ResizeEventArgs e = new ResizeEventArgs();
 481             if (widgetData != null)
 482             {
 483                 e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
 484             }
 485             if (windowSize != null)
 486             {
 487                 var val = new Uint16Pair(windowSize, false);
 488                 e.WindowSize = val;
 489                 val.Dispose();
 490             }
 491
 492             _resizeEventHandler?.Invoke(this, e);
 493         }
 494
 495         internal WidgetInstanceResizeSignalType ResizeSignal()
 496         {
 497             WidgetInstanceResizeSignalType ret = new WidgetInstanceResizeSignalType(NDalicManualPINVOKE.Widget_ResizeSignal(swigCPtr), false);
 498             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 499             return ret;
 500         }
 501
 502         /// <summary>
 503         /// Event arguments that passed via update event signal.
 504         /// </summary>
 505         public class UpdateEventArgs : EventArgs
 506         {
 507             /// <summary>
 508             /// widget data.
 509             /// </summary>
 510             /// <since_tizen> 4 </since_tizen>
 511             public WidgetData WidgetData
 512             {
 513                 get;
 514                 set;
 515             }
 516
 517             /// <summary>
 518             /// A bundle.
 519             /// </summary>
 520             /// <since_tizen> 4 </since_tizen>
 521             public SWIGTYPE_p_bundle Bundle
 522             {
 523                 get;
 524                 set;
 525             }
 526
 527             /// <summary>
 528             /// It means several steps.
 529             /// </summary>
 530             /// <remark>
 531             /// 0 -> no force
 532             /// 1 -> force but do someting
 533             /// 2 -> force
 534             /// </remark>
 535             /// <since_tizen> 4 </since_tizen>
 536             public int Force
 537             {
 538                 get;
 539                 set;
 540             }
 541         }
 542
 543         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 544         private delegate void UpdateCallbackType(IntPtr widgetData, IntPtr bundle, int force);
 545         private UpdateCallbackType _updateCallback;
 546         private EventHandler<UpdateEventArgs> _updateEventHandler;
 547
 548         /// <summary>
 549         /// Update event.
 550         /// </summary>
 551         /// <since_tizen> 4 </since_tizen>
 552         public event EventHandler<UpdateEventArgs> Update
 553         {
 554             add
 555             {
 556                 if (_updateEventHandler == null)
 557                 {
 558                     _updateCallback = OnUpdate;
 559                     UpdateSignal().Connect(_updateCallback);
 560                 }
 561
 562                 _updateEventHandler += value;
 563             }
 564
 565             remove
 566             {
 567                 _updateEventHandler -= value;
 568
 569                 if (_updateEventHandler == null && UpdateSignal().Empty() == false)
 570                 {
 571                    UpdateSignal().Disconnect(_updateCallback);
 572                 }
 573             }
 574         }
 575
 576         private void OnUpdate(IntPtr widgetData, IntPtr bundle, int force)
 577         {
 578             UpdateEventArgs e = new UpdateEventArgs();
 579             if (widgetData != null)
 580             {
 581                 e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
 582             }
 583             if (bundle != null)
 584             {
 585                 e.Bundle = new SWIGTYPE_p_bundle(bundle, false);
 586             }
 587             e.Force = force;
 588
 589             _updateEventHandler?.Invoke(this, e);
 590         }
 591
 592         internal WidgetInstanceUpdateSignalType UpdateSignal()
 593         {
 594             WidgetInstanceUpdateSignalType ret = new WidgetInstanceUpdateSignalType(NDalicManualPINVOKE.Widget_UpdateSignal(swigCPtr), false);
 595             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 596             return ret;
 597         }
 598
 599         /// <summary>
 600         /// Enumeration for terminate type of widget instance.
 601         /// </summary>
 602         /// <since_tizen> 4 </since_tizen>
 603         public enum WidgetTerminateType
 604         {
 605             /// <summary>
 606             /// User deleted this widget from the viewer
 607             /// </summary>
 608             Permanent,
 609             /// <summary>
 610             /// Widget is deleted because of other reasons (e.g. widget process is terminated temporarily by the system)
 611             /// </summary>
 612             Temporary
 613         }
 614
 615         /// <summary>
 616         /// Enumeration for lifecycle event type of widget instance.
 617         /// </summary>
 618         /// <since_tizen> 4 </since_tizen>
 619         public enum WidgetLifecycleEventType
 620         {
 621             /// <summary>
 622             /// The widget is dead.
 623             /// </summary>
 624             AppDead = 0,
 625             /// <summary>
 626             /// The widget is dead.
 627             /// </summary>
 628             Create = 1,
 629             /// <summary>
 630             /// The widget is destroyed.
 631             /// </summary>
 632             Destroy = 2,
 633             /// <summary>
 634             /// The widget is paused.
 635             /// </summary>
 636             Pause = 3,
 637             /// <summary>
 638             /// The widget is resumed.
 639             /// </summary>
 640             Resume = 4
 641         }
 642     }
 643 }