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