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

   1 /*
   2  * Copyright(c) 2021 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.ComponentModel;
  18
  19 namespace Tizen.NUI
  20 {
  21     using System;
  22     using System.Runtime.InteropServices;
  23     using Tizen.NUI.BaseComponents;
  24     using Tizen.NUI.Binding;
  25
  26     /// <summary>
  27     /// The WidgetView is a class for displaying the widget image and controlling the widget.<br />
  28     /// Input events that the WidgetView gets are delivered to the widget.
  29     /// </summary>
  30     /// <since_tizen> 3 </since_tizen>
  31     public class WidgetView : View
  32     {
  33         /// <summary>
  34         /// PreviewProperty
  35         /// </summary>
  36         [EditorBrowsable(EditorBrowsableState.Never)]
  37         public static readonly BindableProperty PreviewProperty = BindableProperty.Create(nameof(Preview), typeof(bool), typeof(Tizen.NUI.WidgetView), false, propertyChanged: (bindable, oldValue, newValue) =>
  38         {
  39             var instance = (Tizen.NUI.WidgetView)bindable;
  40             if (newValue != null)
  41             {
  42                 instance.InternalPreview = (bool)newValue;
  43             }
  44         },
  45         defaultValueCreator: (bindable) =>
  46         {
  47             var instance = (Tizen.NUI.WidgetView)bindable;
  48             return instance.InternalPreview;
  49         });
  50
  51         /// <summary>
  52         /// LoadingTextProperty
  53         /// </summary>
  54         [EditorBrowsable(EditorBrowsableState.Never)]
  55         public static readonly BindableProperty LoadingTextProperty = BindableProperty.Create(nameof(LoadingText), typeof(bool), typeof(Tizen.NUI.WidgetView), false, propertyChanged: (bindable, oldValue, newValue) =>
  56         {
  57             var instance = (Tizen.NUI.WidgetView)bindable;
  58             if (newValue != null)
  59             {
  60                 instance.InternalLoadingText = (bool)newValue;
  61             }
  62         },
  63         defaultValueCreator: (bindable) =>
  64         {
  65             var instance = (Tizen.NUI.WidgetView)bindable;
  66             return instance.InternalLoadingText;
  67         });
  68
  69         /// <summary>
  70         /// WidgetStateFaultedProperty
  71         /// </summary>
  72         [EditorBrowsable(EditorBrowsableState.Never)]
  73         public static readonly BindableProperty WidgetStateFaultedProperty = BindableProperty.Create(nameof(WidgetStateFaulted), typeof(bool), typeof(Tizen.NUI.WidgetView), false, propertyChanged: (bindable, oldValue, newValue) =>
  74         {
  75             var instance = (Tizen.NUI.WidgetView)bindable;
  76             if (newValue != null)
  77             {
  78                 instance.InternalWidgetStateFaulted = (bool)newValue;
  79             }
  80         },
  81         defaultValueCreator: (bindable) =>
  82         {
  83             var instance = (Tizen.NUI.WidgetView)bindable;
  84             return instance.InternalWidgetStateFaulted;
  85         });
  86
  87         /// <summary>
  88         /// PermanentDeleteProperty
  89         /// </summary>
  90         [EditorBrowsable(EditorBrowsableState.Never)]
  91         public static readonly BindableProperty PermanentDeleteProperty = BindableProperty.Create(nameof(PermanentDelete), typeof(bool), typeof(Tizen.NUI.WidgetView), false, propertyChanged: (bindable, oldValue, newValue) =>
  92         {
  93             var instance = (Tizen.NUI.WidgetView)bindable;
  94             if (newValue != null)
  95             {
  96                 instance.InternalPermanentDelete = (bool)newValue;
  97             }
  98         },
  99         defaultValueCreator: (bindable) =>
 100         {
 101             var instance = (Tizen.NUI.WidgetView)bindable;
 102             return instance.InternalPermanentDelete;
 103         });
 104
 105         /// <summary>
 106         /// RetryTextProperty
 107         /// </summary>
 108         [EditorBrowsable(EditorBrowsableState.Never)]
 109         public static readonly BindableProperty RetryTextProperty = BindableProperty.Create(nameof(RetryText), typeof(Tizen.NUI.PropertyMap), typeof(Tizen.NUI.WidgetView), null, propertyChanged: (bindable, oldValue, newValue) =>
 110         {
 111             var instance = (Tizen.NUI.WidgetView)bindable;
 112             if (newValue != null)
 113             {
 114                 instance.InternalRetryText = (Tizen.NUI.PropertyMap)newValue;
 115             }
 116         },
 117         defaultValueCreator: (bindable) =>
 118         {
 119             var instance = (Tizen.NUI.WidgetView)bindable;
 120             return instance.InternalRetryText;
 121         });
 122
 123         /// <summary>
 124         /// EffectProperty
 125         /// </summary>
 126         [EditorBrowsable(EditorBrowsableState.Never)]
 127         public static readonly BindableProperty EffectProperty = BindableProperty.Create(nameof(Effect), typeof(Tizen.NUI.PropertyMap), typeof(Tizen.NUI.WidgetView), null, propertyChanged: (bindable, oldValue, newValue) =>
 128         {
 129             var instance = (Tizen.NUI.WidgetView)bindable;
 130             if (newValue != null)
 131             {
 132                 instance.InternalEffect = (Tizen.NUI.PropertyMap)newValue;
 133             }
 134         },
 135         defaultValueCreator: (bindable) =>
 136         {
 137             var instance = (Tizen.NUI.WidgetView)bindable;
 138             return instance.InternalEffect;
 139         });
 140
 141         private EventHandler<WidgetViewEventArgs> widgetAddedEventHandler;
 142         private WidgetAddedEventCallbackType widgetAddedEventCallback;
 143         private EventHandler<WidgetViewEventArgs> widgetContentUpdatedEventHandler;
 144         private WidgetContentUpdatedEventCallbackType widgetContentUpdatedEventCallback;
 145         private EventHandler<WidgetViewEventArgs> widgetDeletedEventHandler;
 146         private WidgetDeletedEventCallbackType widgetDeletedEventCallback;
 147         private EventHandler<WidgetViewEventArgs> widgetCreationAbortedEventHandler;
 148         private WidgetCreationAbortedEventCallbackType widgetCreationAbortedEventCallback;
 149         private EventHandler<WidgetViewEventArgs> widgetUpdatePeriodChangedEventHandler;
 150         private WidgetUpdatePeriodChangedEventCallbackType widgetUpdatePeriodChangedEventCallback;
 151         private EventHandler<WidgetViewEventArgs> widgetFaultedEventHandler;
 152         private WidgetFaultedEventCallbackType widgetFaultedEventCallback;
 153
 154         /// <summary>
 155         /// Used in xaml as factory method to create WidgetView.
 156         /// </summary>
 157         /// <param name="widgetId"></param>
 158         /// <param name="contentInfo"></param>
 159         /// <param name="width"></param>
 160         /// <param name="height"></param>
 161         /// <param name="updatePeriod"></param>
 162         /// <returns></returns>
 163         [EditorBrowsable(EditorBrowsableState.Never)]
 164         public static WidgetView CreateWidgetView(string widgetId, string contentInfo, int width, int height, float updatePeriod)
 165         {
 166             return WidgetViewManager.Instance.AddWidget(widgetId, contentInfo, width, height, updatePeriod);
 167         }
 168
 169         /// <summary>
 170         /// Creates a new WidgetView.
 171         /// </summary>
 172         /// <since_tizen> 3 </since_tizen>
 173         public WidgetView(string widgetId, string contentInfo, int width, int height, float updatePeriod) : this(Interop.WidgetView.New(widgetId, contentInfo, width, height, updatePeriod), true)
 174         {
 175             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 176
 177         }
 178
 179         internal WidgetView(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemoryOwn)
 180         {
 181         }
 182         internal WidgetView(WidgetView handle) : this(Interop.WidgetView.NewWidgetView(WidgetView.getCPtr(handle)), true)
 183         {
 184             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 185         }
 186
 187         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 188         private delegate void WidgetAddedEventCallbackType(IntPtr data);
 189         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 190         private delegate void WidgetContentUpdatedEventCallbackType(IntPtr data);
 191         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 192         private delegate void WidgetDeletedEventCallbackType(IntPtr data);
 193         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 194         private delegate void WidgetCreationAbortedEventCallbackType(IntPtr data);
 195         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 196         private delegate void WidgetUpdatePeriodChangedEventCallbackType(IntPtr data);
 197         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 198         private delegate void WidgetFaultedEventCallbackType(IntPtr data);
 199
 200         /// <summary>
 201         /// An event for the WidgetAdded signal which can be used to subscribe or unsubscribe the event handler.<br />
 202         /// This signal is emitted when widget is added.<br />
 203         /// </summary>
 204         /// <since_tizen> 3 </since_tizen>
 205         public event EventHandler<WidgetViewEventArgs> WidgetAdded
 206         {
 207             add
 208             {
 209                 if (widgetAddedEventHandler == null)
 210                 {
 211                     widgetAddedEventCallback = OnWidgetAdded;
 212                     WidgetViewSignal widgetAdded = WidgetAddedSignal();
 213                     widgetAdded?.Connect(widgetAddedEventCallback);
 214                     widgetAdded?.Dispose();
 215                 }
 216
 217                 widgetAddedEventHandler += value;
 218             }
 219
 220             remove
 221             {
 222                 widgetAddedEventHandler -= value;
 223
 224                 WidgetViewSignal widgetAdded = WidgetAddedSignal();
 225                 if (widgetAddedEventHandler == null && widgetAdded?.Empty() == false)
 226                 {
 227                     widgetAdded?.Disconnect(widgetAddedEventCallback);
 228                 }
 229                 widgetAdded?.Dispose();
 230             }
 231         }
 232
 233         /// <summary>
 234         /// An event for the WidgetContentUpdated signal which can be used to subscribe or unsubscribe the event handler.<br />
 235         /// This signal is emitted when the widget content is updated.<br />
 236         /// </summary>
 237         /// <since_tizen> 3 </since_tizen>
 238         public event EventHandler<WidgetViewEventArgs> WidgetContentUpdated
 239         {
 240             add
 241             {
 242                 if (widgetContentUpdatedEventHandler == null)
 243                 {
 244                     widgetContentUpdatedEventCallback = OnWidgetContentUpdated;
 245                     WidgetViewSignal widgetContentUpdated = WidgetContentUpdatedSignal();
 246                     widgetContentUpdated?.Connect(widgetContentUpdatedEventCallback);
 247                     widgetContentUpdated?.Dispose();
 248                 }
 249
 250                 widgetContentUpdatedEventHandler += value;
 251             }
 252
 253             remove
 254             {
 255                 widgetContentUpdatedEventHandler -= value;
 256
 257                 WidgetViewSignal widgetContentUpdated = WidgetContentUpdatedSignal();
 258                 if (widgetContentUpdatedEventHandler == null && widgetContentUpdated?.Empty() == false)
 259                 {
 260                     widgetContentUpdated?.Disconnect(widgetContentUpdatedEventCallback);
 261                 }
 262                 widgetContentUpdated?.Dispose();
 263             }
 264         }
 265
 266         /// <summary>
 267         /// An event for the WidgetDeleted signal which can be used to subscribe or unsubscribe the event handler.<br />
 268         /// This signal is emitted when the widget is deleted.<br />
 269         /// </summary>
 270         /// <since_tizen> 3 </since_tizen>
 271         public event EventHandler<WidgetViewEventArgs> WidgetDeleted
 272         {
 273             add
 274             {
 275                 if (widgetDeletedEventHandler == null)
 276                 {
 277                     widgetDeletedEventCallback = OnWidgetDeleted;
 278                     WidgetViewSignal widgetDeleted = WidgetDeletedSignal();
 279                     widgetDeleted?.Connect(widgetDeletedEventCallback);
 280                     widgetDeleted?.Dispose();
 281                 }
 282
 283                 widgetDeletedEventHandler += value;
 284             }
 285
 286             remove
 287             {
 288                 widgetDeletedEventHandler -= value;
 289
 290                 WidgetViewSignal widgetDeleted = WidgetDeletedSignal();
 291                 if (widgetDeletedEventHandler == null && widgetDeleted?.Empty() == false)
 292                 {
 293                     widgetDeleted?.Disconnect(widgetDeletedEventCallback);
 294                 }
 295                 widgetDeleted?.Dispose();
 296             }
 297         }
 298
 299         /// <summary>
 300         /// An event for the WidgetCreationAborted signal which can be used to subscribe or unsubscribe the event handler.<br />
 301         /// This signal is emitted when the widget creation is aborted.<br />
 302         /// </summary>
 303         /// <since_tizen> 3 </since_tizen>
 304         public event EventHandler<WidgetViewEventArgs> WidgetCreationAborted
 305         {
 306             add
 307             {
 308                 if (widgetCreationAbortedEventHandler == null)
 309                 {
 310                     widgetCreationAbortedEventCallback = OnWidgetCreationAborted;
 311                     WidgetViewSignal widgetCreationAborted = WidgetCreationAbortedSignal();
 312                     widgetCreationAborted?.Connect(widgetCreationAbortedEventCallback);
 313                     widgetCreationAborted?.Dispose();
 314                 }
 315
 316                 widgetCreationAbortedEventHandler += value;
 317             }
 318
 319             remove
 320             {
 321                 widgetCreationAbortedEventHandler -= value;
 322
 323                 WidgetViewSignal widgetCreationAborted = WidgetCreationAbortedSignal();
 324                 if (widgetCreationAbortedEventHandler == null && widgetCreationAborted?.Empty() == false)
 325                 {
 326                     widgetCreationAborted?.Disconnect(widgetCreationAbortedEventCallback);
 327                 }
 328                 widgetCreationAborted?.Dispose();
 329             }
 330         }
 331
 332         /// <summary>
 333         /// An event for the WidgetUpdatePeriodChanged signal which can be used to subscribe or unsubscribe the event handler.<br />
 334         /// This signal is emitted when the widget update period is changed.<br />
 335         /// </summary>
 336         /// <since_tizen> 3 </since_tizen>
 337         public event EventHandler<WidgetViewEventArgs> WidgetUpdatePeriodChanged
 338         {
 339             add
 340             {
 341                 if (widgetUpdatePeriodChangedEventHandler == null)
 342                 {
 343                     widgetUpdatePeriodChangedEventCallback = OnWidgetUpdatePeriodChanged;
 344                     WidgetViewSignal widgetUpdatePeriodChanged = WidgetUpdatePeriodChangedSignal();
 345                     widgetUpdatePeriodChanged?.Connect(widgetUpdatePeriodChangedEventCallback);
 346                     widgetUpdatePeriodChanged?.Dispose();
 347                 }
 348
 349                 widgetUpdatePeriodChangedEventHandler += value;
 350             }
 351
 352             remove
 353             {
 354                 widgetUpdatePeriodChangedEventHandler -= value;
 355
 356                 WidgetViewSignal widgetUpdatePeriodChanged = WidgetUpdatePeriodChangedSignal();
 357                 if (widgetUpdatePeriodChangedEventHandler == null && widgetUpdatePeriodChanged?.Empty() == false)
 358                 {
 359                     widgetUpdatePeriodChanged?.Disconnect(widgetUpdatePeriodChangedEventCallback);
 360                 }
 361                 widgetUpdatePeriodChanged?.Dispose();
 362             }
 363         }
 364
 365         /// <summary>
 366         /// An event for the WidgetFaulted signal which can be used to subscribe or unsubscribe the event handler.<br />
 367         /// This signal is emitted when the widget process is not running.<br />
 368         /// </summary>
 369         /// <since_tizen> 3 </since_tizen>
 370         public event EventHandler<WidgetViewEventArgs> WidgetFaulted
 371         {
 372             add
 373             {
 374                 if (widgetFaultedEventHandler == null)
 375                 {
 376                     widgetFaultedEventCallback = OnWidgetFaulted;
 377                     WidgetViewSignal widgetFaulted = WidgetFaultedSignal();
 378                     widgetFaulted?.Connect(widgetFaultedEventCallback);
 379                     widgetFaulted?.Dispose();
 380                 }
 381
 382                 widgetFaultedEventHandler += value;
 383             }
 384
 385             remove
 386             {
 387                 widgetFaultedEventHandler -= value;
 388
 389                 WidgetViewSignal widgetFaulted = WidgetFaultedSignal();
 390                 if (widgetFaultedEventHandler == null && widgetFaulted?.Empty() == false)
 391                 {
 392                     widgetFaulted?.Disconnect(widgetFaultedEventCallback);
 393                 }
 394                 widgetFaulted?.Dispose();
 395             }
 396         }
 397
 398         /// <summary>
 399         /// Gets the ID of the widget.
 400         /// </summary>
 401         /// <since_tizen> 3 </since_tizen>
 402         public string WidgetID
 403         {
 404             get
 405             {
 406                 string retValue = "";
 407                 PropertyValue widgetId = GetProperty(WidgetView.Property.WidgetId);
 408                 widgetId?.Get(out retValue);
 409                 widgetId?.Dispose();
 410                 return retValue;
 411             }
 412         }
 413
 414         /// <summary>
 415         /// Gets the ID of the instance.
 416         /// </summary>
 417         /// <since_tizen> 3 </since_tizen>
 418         public string InstanceID
 419         {
 420             get
 421             {
 422                 string retValue = "";
 423                 PropertyValue instanceId = GetProperty(WidgetView.Property.InstanceId);
 424                 instanceId?.Get(out retValue);
 425                 instanceId?.Dispose();
 426                 return retValue;
 427             }
 428         }
 429
 430         /// <summary>
 431         /// Gets the content info.
 432         /// </summary>
 433         /// <since_tizen> 3 </since_tizen>
 434         public string ContentInfo
 435         {
 436             get
 437             {
 438                 string retValue = "";
 439                 PropertyValue contentInfo = GetProperty(WidgetView.Property.ContentInfo);
 440                 contentInfo?.Get(out retValue);
 441                 contentInfo?.Dispose();
 442                 return retValue;
 443             }
 444         }
 445
 446         /// <summary>
 447         /// Gets the title.
 448         /// </summary>
 449         /// <since_tizen> 3 </since_tizen>
 450         public string Title
 451         {
 452             get
 453             {
 454                 string retValue = "";
 455                 PropertyValue title = GetProperty(WidgetView.Property.TITLE);
 456                 title?.Get(out retValue);
 457                 title?.Dispose();
 458                 return retValue;
 459             }
 460         }
 461
 462         /// <summary>
 463         /// Gets the update period.
 464         /// </summary>
 465         /// <since_tizen> 3 </since_tizen>
 466         public float UpdatePeriod
 467         {
 468             get
 469             {
 470                 float retValue = 0;
 471                 PropertyValue updatePeriod = GetProperty(WidgetView.Property.UpdatePeriod);
 472                 updatePeriod?.Get(out retValue);
 473                 updatePeriod?.Dispose();
 474                 return retValue;
 475             }
 476         }
 477
 478         /// <summary>
 479         /// Gets or sets the preview.
 480         /// </summary>
 481         /// <since_tizen> 3 </since_tizen>
 482         public bool Preview
 483         {
 484             get
 485             {
 486                 return (bool)GetValue(PreviewProperty);
 487             }
 488             set
 489             {
 490                 SetValue(PreviewProperty, value);
 491                 NotifyPropertyChanged();
 492             }
 493         }
 494
 495         private bool InternalPreview
 496         {
 497             get
 498             {
 499                 bool retValue = false;
 500                 PropertyValue preview = GetProperty(WidgetView.Property.PREVIEW);
 501                 preview?.Get(out retValue);
 502                 preview?.Dispose();
 503                 return retValue;
 504             }
 505             set
 506             {
 507                 PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
 508                 SetProperty(WidgetView.Property.PREVIEW, setValue);
 509                 setValue?.Dispose();
 510             }
 511         }
 512
 513         /// <summary>
 514         /// Gets or sets the loading text.
 515         /// </summary>
 516         /// <since_tizen> 3 </since_tizen>
 517         public bool LoadingText
 518         {
 519             get
 520             {
 521                 return (bool)GetValue(LoadingTextProperty);
 522             }
 523             set
 524             {
 525                 SetValue(LoadingTextProperty, value);
 526                 NotifyPropertyChanged();
 527             }
 528         }
 529
 530         private bool InternalLoadingText
 531         {
 532             get
 533             {
 534                 bool retValue = false;
 535                 PropertyValue loadingText = GetProperty(WidgetView.Property.LoadingText);
 536                 loadingText?.Get(out retValue);
 537                 loadingText?.Dispose();
 538                 return retValue;
 539             }
 540             set
 541             {
 542                 PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
 543                 SetProperty(WidgetView.Property.LoadingText, setValue);
 544                 setValue?.Dispose();
 545             }
 546         }
 547
 548         /// <summary>
 549         /// Gets or sets whether the widget state is faulted or not.
 550         /// </summary>
 551         /// <since_tizen> 3 </since_tizen>
 552         public bool WidgetStateFaulted
 553         {
 554             get
 555             {
 556                 return (bool)GetValue(WidgetStateFaultedProperty);
 557             }
 558             set
 559             {
 560                 SetValue(WidgetStateFaultedProperty, value);
 561                 NotifyPropertyChanged();
 562             }
 563         }
 564
 565         private bool InternalWidgetStateFaulted
 566         {
 567             get
 568             {
 569                 bool retValue = false;
 570                 PropertyValue widgetStateFaulted = GetProperty(WidgetView.Property.WidgetStateFaulted);
 571                 widgetStateFaulted?.Get(out retValue);
 572                 widgetStateFaulted?.Dispose();
 573                 return retValue;
 574             }
 575             set
 576             {
 577                 PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
 578                 SetProperty(WidgetView.Property.WidgetStateFaulted, setValue);
 579                 setValue?.Dispose();
 580             }
 581         }
 582
 583         /// <summary>
 584         /// Gets or sets whether the widget is to delete permanently or not.
 585         /// </summary>
 586         /// <since_tizen> 3 </since_tizen>
 587         public bool PermanentDelete
 588         {
 589             get
 590             {
 591                 return (bool)GetValue(PermanentDeleteProperty);
 592             }
 593             set
 594             {
 595                 SetValue(PermanentDeleteProperty, value);
 596                 NotifyPropertyChanged();
 597             }
 598         }
 599
 600         private bool InternalPermanentDelete
 601         {
 602             get
 603             {
 604                 bool retValue = false;
 605                 PropertyValue permanentDelete = GetProperty(WidgetView.Property.PermanentDelete);
 606                 permanentDelete?.Get(out retValue);
 607                 permanentDelete?.Dispose();
 608                 return retValue;
 609             }
 610             set
 611             {
 612                 PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
 613                 SetProperty(WidgetView.Property.PermanentDelete, setValue);
 614                 setValue.Dispose();
 615             }
 616         }
 617
 618         /// <summary>
 619         /// Gets or sets retry text.
 620         /// </summary>
 621         /// <since_tizen> 4 </since_tizen>
 622         public PropertyMap RetryText
 623         {
 624             get
 625             {
 626                 return GetValue(RetryTextProperty) as PropertyMap;
 627             }
 628             set
 629             {
 630                 SetValue(RetryTextProperty, value);
 631                 NotifyPropertyChanged();
 632             }
 633         }
 634
 635         private PropertyMap InternalRetryText
 636         {
 637             get
 638             {
 639                 PropertyMap retValue = new PropertyMap();
 640                 PropertyValue retryText = GetProperty(WidgetView.Property.RetryText);
 641                 retryText?.Get(retValue);
 642                 retryText?.Dispose();
 643                 return retValue;
 644             }
 645             set
 646             {
 647                 PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
 648                 SetProperty(WidgetView.Property.RetryText, setValue);
 649                 setValue?.Dispose();
 650             }
 651         }
 652
 653         /// <summary>
 654         /// Gets or sets effect.
 655         /// </summary>
 656         /// <since_tizen> 4 </since_tizen>
 657         public PropertyMap Effect
 658         {
 659             get
 660             {
 661                 return GetValue(EffectProperty) as PropertyMap;
 662             }
 663             set
 664             {
 665                 SetValue(EffectProperty, value);
 666                 NotifyPropertyChanged();
 667             }
 668         }
 669
 670         private PropertyMap InternalEffect
 671         {
 672             get
 673             {
 674                 PropertyMap retValue = new PropertyMap();
 675                 PropertyValue effect = GetProperty(WidgetView.Property.EFFECT);
 676                 effect?.Get(retValue);
 677                 effect?.Dispose();
 678                 return retValue;
 679             }
 680             set
 681             {
 682                 PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
 683                 SetProperty(WidgetView.Property.EFFECT, setValue);
 684                 setValue?.Dispose();
 685             }
 686         }
 687
 688         /// <summary>
 689         /// Pauses a given widget.
 690         /// </summary>
 691         /// <returns>True on success, false otherwise.</returns>
 692         /// <since_tizen> 3 </since_tizen>
 693         public bool PauseWidget()
 694         {
 695             bool ret = Interop.WidgetView.PauseWidget(SwigCPtr);
 696             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 697             return ret;
 698         }
 699
 700         /// <summary>
 701         /// Resumes a given widget.
 702         /// </summary>
 703         /// <returns>True on success, false otherwise.</returns>
 704         /// <since_tizen> 3 </since_tizen>
 705         public bool ResumeWidget()
 706         {
 707             bool ret = Interop.WidgetView.ResumeWidget(SwigCPtr);
 708             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 709             return ret;
 710         }
 711
 712         /// <summary>
 713         /// Cancels the touch event procedure.
 714         /// If you call this function after feed the touch down event, the widget will get ON_HOLD events.
 715         ///  If a widget gets ON_HOLD event, it will not do anything even if you feed touch up event.
 716         /// </summary>
 717         /// <returns>True on success, false otherwise.</returns>
 718         /// <since_tizen> 3 </since_tizen>
 719         public bool CancelTouchEvent()
 720         {
 721             bool ret = Interop.WidgetView.CancelTouchEvent(SwigCPtr);
 722             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 723             return ret;
 724         }
 725
 726         /// <summary>
 727         /// Activates a widget in the faulted state.
 728         /// A widget in faulted state must be activated before adding the widget.
 729         /// </summary>
 730         /// <since_tizen> 3 </since_tizen>
 731         public void ActivateFaultedWidget()
 732         {
 733             Interop.WidgetView.ActivateFaultedWidget(SwigCPtr);
 734             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 735         }
 736
 737         /// <summary>
 738         /// Terminate a widget instance.
 739         /// </summary>
 740         /// <returns>True on success, false otherwise</returns>
 741         /// <since_tizen> 4 </since_tizen>
 742         public bool TerminateWidget()
 743         {
 744             bool ret = Interop.WidgetView.TerminateWidget(SwigCPtr);
 745             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 746             return ret;
 747         }
 748
 749         internal static WidgetView DownCast(BaseHandle handle)
 750         {
 751             WidgetView ret = new WidgetView(Interop.WidgetView.DownCast(BaseHandle.getCPtr(handle)), true);
 752             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 753             return ret;
 754         }
 755
 756         internal static WidgetView GetWidgetViewFromPtr(global::System.IntPtr cPtr)
 757         {
 758             if (cPtr == global::System.IntPtr.Zero)
 759             {
 760                 return null;
 761             }
 762             WidgetView ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as WidgetView;
 763             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 764             return ret;
 765         }
 766
 767         internal WidgetView Assign(WidgetView handle)
 768         {
 769             WidgetView ret = new WidgetView(Interop.WidgetView.Assign(SwigCPtr, WidgetView.getCPtr(handle)), false);
 770             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 771             return ret;
 772         }
 773
 774         internal WidgetViewSignal WidgetAddedSignal()
 775         {
 776             WidgetViewSignal ret = new WidgetViewSignal(Interop.WidgetView.WidgetAddedSignal(SwigCPtr), false);
 777             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 778             return ret;
 779         }
 780
 781         internal WidgetViewSignal WidgetDeletedSignal()
 782         {
 783             WidgetViewSignal ret = new WidgetViewSignal(Interop.WidgetView.WidgetDeletedSignal(SwigCPtr), false);
 784             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 785             return ret;
 786         }
 787
 788         internal WidgetViewSignal WidgetCreationAbortedSignal()
 789         {
 790             WidgetViewSignal ret = new WidgetViewSignal(Interop.WidgetView.WidgetCreationAbortedSignal(SwigCPtr), false);
 791             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 792             return ret;
 793         }
 794
 795         internal WidgetViewSignal WidgetContentUpdatedSignal()
 796         {
 797             WidgetViewSignal ret = new WidgetViewSignal(Interop.WidgetView.WidgetContentUpdatedSignal(SwigCPtr), false);
 798             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 799             return ret;
 800         }
 801
 802         internal WidgetViewSignal WidgetUpdatePeriodChangedSignal()
 803         {
 804             WidgetViewSignal ret = new WidgetViewSignal(Interop.WidgetView.WidgetUpdatePeriodChangedSignal(SwigCPtr), false);
 805             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 806             return ret;
 807         }
 808
 809         internal WidgetViewSignal WidgetFaultedSignal()
 810         {
 811             WidgetViewSignal ret = new WidgetViewSignal(Interop.WidgetView.WidgetFaultedSignal(SwigCPtr), false);
 812             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 813             return ret;
 814         }
 815
 816         /// <summary>
 817         /// To make the Button instance be disposed.
 818         /// </summary>
 819         /// <since_tizen> 3 </since_tizen>
 820         protected override void Dispose(DisposeTypes type)
 821         {
 822             if (disposed)
 823             {
 824                 return;
 825             }
 826
 827             //Remove Widget from WidgetViewManager
 828             WidgetViewManager.Instance.RemoveWidget(this);
 829
 830             //Release your own unmanaged resources here.
 831             //You should not access any managed member here except static instance.
 832             //because the execution order of Finalizes is non-deterministic.
 833
 834             if (widgetAddedEventCallback != null)
 835             {
 836                 WidgetViewSignal widgetAdded = this.WidgetAddedSignal();
 837                 widgetAdded?.Disconnect(widgetAddedEventCallback);
 838                 widgetAdded?.Dispose();
 839             }
 840
 841             if (widgetContentUpdatedEventCallback != null)
 842             {
 843                 WidgetViewSignal widgetContentUpdated = this.WidgetContentUpdatedSignal();
 844                 widgetContentUpdated?.Disconnect(widgetContentUpdatedEventCallback);
 845                 widgetContentUpdated?.Dispose();
 846             }
 847
 848             if (widgetCreationAbortedEventCallback != null)
 849             {
 850                 WidgetViewSignal widgetCreationAborted = this.WidgetCreationAbortedSignal();
 851                 widgetCreationAborted?.Disconnect(widgetCreationAbortedEventCallback);
 852                 widgetCreationAborted?.Dispose();
 853             }
 854
 855             if (widgetDeletedEventCallback != null)
 856             {
 857                 WidgetViewSignal widgetDeleted = this.WidgetDeletedSignal();
 858                 widgetDeleted?.Disconnect(widgetDeletedEventCallback);
 859                 widgetDeleted?.Dispose();
 860             }
 861
 862             if (widgetFaultedEventCallback != null)
 863             {
 864                 WidgetViewSignal widgetFaulted = this.WidgetFaultedSignal();
 865                 widgetFaulted?.Disconnect(widgetFaultedEventCallback);
 866                 widgetFaulted?.Dispose();
 867             }
 868
 869             if (widgetUpdatePeriodChangedEventCallback != null)
 870             {
 871                 WidgetViewSignal widgetUpdatePeriodChanged = this.WidgetUpdatePeriodChangedSignal();
 872                 widgetUpdatePeriodChanged?.Disconnect(widgetUpdatePeriodChangedEventCallback);
 873                 widgetUpdatePeriodChanged?.Dispose();
 874             }
 875
 876             base.Dispose(type);
 877         }
 878
 879         /// This will not be public opened.
 880         [EditorBrowsable(EditorBrowsableState.Never)]
 881         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
 882         {
 883             Interop.WidgetView.DeleteWidgetView(swigCPtr);
 884         }
 885
 886         /// <inheritdoc/>
 887         [EditorBrowsable(EditorBrowsableState.Never)]
 888         protected override bool HandleControlStateOnTouch(Touch touch)
 889         {
 890             base.HandleControlStateOnTouch(touch);
 891             return true; // Do not pass the touch event to the below.
 892         }
 893
 894         // Callback for WidgetView WidgetAdded signal
 895         private void OnWidgetAdded(IntPtr data)
 896         {
 897             WidgetViewEventArgs e = new WidgetViewEventArgs();
 898             if (data != IntPtr.Zero)
 899             {
 900                 e.WidgetView = WidgetView.GetWidgetViewFromPtr(data);
 901             }
 902
 903             if (widgetAddedEventHandler != null)
 904             {
 905                 widgetAddedEventHandler(this, e);
 906             }
 907         }
 908
 909         // Callback for WidgetView WidgetDeleted signal
 910         private void OnWidgetDeleted(IntPtr data)
 911         {
 912             WidgetViewEventArgs e = new WidgetViewEventArgs();
 913             if (data != IntPtr.Zero)
 914             {
 915                 e.WidgetView = WidgetView.GetWidgetViewFromPtr(data);
 916             }
 917
 918             if (widgetDeletedEventHandler != null)
 919             {
 920                 widgetDeletedEventHandler(this, e);
 921             }
 922         }
 923
 924         // Callback for WidgetView WidgetCreationAborted signal
 925         private void OnWidgetCreationAborted(IntPtr data)
 926         {
 927             WidgetViewEventArgs e = new WidgetViewEventArgs();
 928             if (data != IntPtr.Zero)
 929             {
 930                 e.WidgetView = WidgetView.GetWidgetViewFromPtr(data);
 931             }
 932
 933             if (widgetCreationAbortedEventHandler != null)
 934             {
 935                 widgetCreationAbortedEventHandler(this, e);
 936             }
 937         }
 938
 939
 940
 941         // Callback for WidgetView WidgetContentUpdated signal
 942         private void OnWidgetContentUpdated(IntPtr data)
 943         {
 944             WidgetViewEventArgs e = new WidgetViewEventArgs();
 945             if (data != IntPtr.Zero)
 946             {
 947                 e.WidgetView = WidgetView.GetWidgetViewFromPtr(data);
 948             }
 949
 950             if (widgetContentUpdatedEventHandler != null)
 951             {
 952                 widgetContentUpdatedEventHandler(this, e);
 953             }
 954         }
 955
 956         // Callback for WidgetView WidgetUpdatePeriodChanged signal
 957         private void OnWidgetUpdatePeriodChanged(IntPtr data)
 958         {
 959             WidgetViewEventArgs e = new WidgetViewEventArgs();
 960             if (data != IntPtr.Zero)
 961             {
 962                 e.WidgetView = WidgetView.GetWidgetViewFromPtr(data);
 963             }
 964
 965             if (widgetUpdatePeriodChangedEventHandler != null)
 966             {
 967                 widgetUpdatePeriodChangedEventHandler(this, e);
 968             }
 969         }
 970
 971         // Callback for WidgetView WidgetFaulted signal
 972         private void OnWidgetFaulted(IntPtr data)
 973         {
 974             WidgetViewEventArgs e = new WidgetViewEventArgs();
 975             if (data != IntPtr.Zero)
 976             {
 977                 e.WidgetView = WidgetView.GetWidgetViewFromPtr(data);
 978             }
 979
 980             if (widgetFaultedEventHandler != null)
 981             {
 982                 widgetFaultedEventHandler(this, e);
 983             }
 984         }
 985
 986         /// <summary>
 987         /// Event arguments of the widget view.
 988         /// </summary>
 989         /// <since_tizen> 3 </since_tizen>
 990         public class WidgetViewEventArgs : EventArgs
 991         {
 992             private WidgetView _widgetView;
 993
 994             /// <summary>
 995             /// The widget view.
 996             /// </summary>
 997             /// <since_tizen> 3 </since_tizen>
 998             public WidgetView WidgetView
 999             {
1000                 get
1001                 {
1002                     return _widgetView;
1003                 }
1004                 set
1005                 {
1006                     _widgetView = value;
1007                 }
1008             }
1009         }
1010
1011         internal new class Property
1012         {
1013             internal static readonly int WidgetId = Interop.WidgetView.WidgetIdGet();
1014             internal static readonly int InstanceId = Interop.WidgetView.InstanceIdGet();
1015             internal static readonly int ContentInfo = Interop.WidgetView.ContentInfoGet();
1016             internal static readonly int TITLE = Interop.WidgetView.TitleGet();
1017             internal static readonly int UpdatePeriod = Interop.WidgetView.UpdatePeriodGet();
1018             internal static readonly int PREVIEW = Interop.WidgetView.PreviewGet();
1019             internal static readonly int LoadingText = Interop.WidgetView.LoadingTextGet();
1020             internal static readonly int WidgetStateFaulted = Interop.WidgetView.WidgetStateFaultedGet();
1021             internal static readonly int PermanentDelete = Interop.WidgetView.PermanentDeleteGet();
1022             internal static readonly int RetryText = Interop.WidgetView.RetryTextGet();
1023             internal static readonly int EFFECT = Interop.WidgetView.EffectGet();
1024
1025
1026             [Obsolete("Do not use this, that is deprecated in API9 and will be removed in API11. Use WidgetId instead.")]
1027             internal static readonly int WIDGET_ID = Interop.WidgetView.WidgetIdGet();
1028             [Obsolete("Do not use this, that is deprecated in API9 and will be removed in API11. Use ContentInfo instead.")]
1029             internal static readonly int CONTENT_INFO = Interop.WidgetView.ContentInfoGet();
1030             [Obsolete("Do not use this, that is deprecated in API9 and will be removed in API11. Use UpdatePeriod instead.")]
1031             internal static readonly int UPDATE_PERIOD = Interop.WidgetView.UpdatePeriodGet();
1032             [Obsolete("Do not use this, that is deprecated in API9 and will be removed in API11. Use LoadingText instead.")]
1033             internal static readonly int LOADING_TEXT = Interop.WidgetView.LoadingTextGet();
1034         }
1035     }
1036
1037 }