src/Tizen.NUI/src/public/UIComponents/ProgressBar.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
  17 namespace Tizen.NUI.UIComponents
  18 {
  19
  20     using System;
  21     using System.Runtime.InteropServices;
  22     using Tizen.NUI.BaseComponents;
  23
  24     /// <summary>
  25     /// The ProgressBar is a control to give the user an indication of the progress of an operation.
  26     /// </summary>
  27     public class ProgressBar : View
  28     {
  29         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  30
  31         internal ProgressBar(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.ProgressBar_SWIGUpcast(cPtr), cMemoryOwn)
  32         {
  33             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  34         }
  35
  36         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ProgressBar obj)
  37         {
  38             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  39         }
  40
  41         /// <summary>
  42         /// To dispose the ProgressBar instance.
  43         /// </summary>
  44         protected override void Dispose(DisposeTypes type)
  45         {
  46             if (disposed)
  47             {
  48                 return;
  49             }
  50
  51             if (type == DisposeTypes.Explicit)
  52             {
  53                 //Called by User
  54                 //Release your own managed resources here.
  55                 //You should release all of your own disposable objects here.
  56
  57             }
  58
  59             //Release your own unmanaged resources here.
  60             //You should not access any managed member here except static instance.
  61             //because the execution order of Finalizes is non-deterministic.
  62
  63             if (_progressBarValueChangedCallbackDelegate != null)
  64             {
  65                 ValueChangedSignal().Disconnect(_progressBarValueChangedCallbackDelegate);
  66             }
  67
  68             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  69             {
  70                 if (swigCMemOwn)
  71                 {
  72                     swigCMemOwn = false;
  73                     NDalicPINVOKE.delete_ProgressBar(swigCPtr);
  74                 }
  75                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  76             }
  77
  78             base.Dispose(type);
  79         }
  80
  81
  82         /// <summary>
  83         /// Event arguments that passed via the ValueChangedEventArgs.
  84         /// </summary>
  85         public class ValueChangedEventArgs : EventArgs
  86         {
  87             private ProgressBar _progressBar;
  88             private float _progressValue;
  89             private float _secondaryProgressValue;
  90
  91             public ProgressBar ProgressBar
  92             {
  93                 get
  94                 {
  95                     return _progressBar;
  96                 }
  97                 set
  98                 {
  99                     _progressBar = value;
 100                 }
 101             }
 102
 103             public float ProgressValue
 104             {
 105                 get
 106                 {
 107                     return _progressValue;
 108                 }
 109                 set
 110                 {
 111                     _progressValue = value;
 112                 }
 113             }
 114
 115             public float SecondaryProgressValue
 116             {
 117                 get
 118                 {
 119                     return _secondaryProgressValue;
 120                 }
 121                 set
 122                 {
 123                     _secondaryProgressValue = value;
 124                 }
 125             }
 126
 127         }
 128
 129         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 130         private delegate void ValueChangedCallbackDelegate(IntPtr progressBar, float progressValue, float secondaryProgressValue);
 131         private EventHandler<ValueChangedEventArgs> _progressBarValueChangedEventHandler;
 132         private ValueChangedCallbackDelegate _progressBarValueChangedCallbackDelegate;
 133
 134         /// <summary>
 135         /// The event is sent when the ProgressBar value changes.
 136         /// </summary>
 137         /// <since_tizen> 3 </since_tizen>
 138         public event EventHandler<ValueChangedEventArgs> ValueChanged
 139         {
 140             add
 141             {
 142                 if (_progressBarValueChangedEventHandler == null)
 143                 {
 144                     _progressBarValueChangedCallbackDelegate = (OnValueChanged);
 145                     ValueChangedSignal().Connect(_progressBarValueChangedCallbackDelegate);
 146                 }
 147                 _progressBarValueChangedEventHandler += value;
 148             }
 149             remove
 150             {
 151                 _progressBarValueChangedEventHandler -= value;
 152                 if (_progressBarValueChangedEventHandler == null && ValueChangedSignal().Empty() == false)
 153                 {
 154                     ValueChangedSignal().Disconnect(_progressBarValueChangedCallbackDelegate);
 155                 }
 156             }
 157         }
 158
 159         // Callback for ProgressBar ValueChanged signal
 160         private void OnValueChanged(IntPtr progressBar, float progressValue, float secondaryProgressValue)
 161         {
 162             ValueChangedEventArgs e = new ValueChangedEventArgs();
 163
 164             // Populate all members of "e" (ValueChangedEventArgs) with real page
 165             e.ProgressBar = Registry.GetManagedBaseHandleFromNativePtr(progressBar) as ProgressBar;
 166             e.ProgressValue = progressValue;
 167             e.SecondaryProgressValue = secondaryProgressValue;
 168
 169             if (_progressBarValueChangedEventHandler != null)
 170             {
 171                 _progressBarValueChangedEventHandler(this, e);
 172             }
 173         }
 174
 175         internal new class Property
 176         {
 177             internal static readonly int PROGRESS_VALUE = NDalicPINVOKE.ProgressBar_Property_PROGRESS_VALUE_get();
 178             internal static readonly int SECONDARY_PROGRESS_VALUE = NDalicPINVOKE.ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get();
 179             internal static readonly int INDETERMINATE = NDalicPINVOKE.ProgressBar_Property_INDETERMINATE_get();
 180             internal static readonly int TRACK_VISUAL = NDalicPINVOKE.ProgressBar_Property_TRACK_VISUAL_get();
 181             internal static readonly int PROGRESS_VISUAL = NDalicPINVOKE.ProgressBar_Property_PROGRESS_VISUAL_get();
 182             internal static readonly int SECONDARY_PROGRESS_VISUAL = NDalicPINVOKE.ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get();
 183             internal static readonly int INDETERMINATE_VISUAL = NDalicPINVOKE.ProgressBar_Property_INDETERMINATE_VISUAL_get();
 184             internal static readonly int INDETERMINATE_VISUAL_ANIMATION = NDalicPINVOKE.ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get();
 185             internal static readonly int LABEL_VISUAL = NDalicPINVOKE.ProgressBar_Property_LABEL_VISUAL_get();
 186         }
 187
 188         /// <summary>
 189         /// Creates the ProgressBar.
 190         /// </summary>
 191         /// <since_tizen> 3 </since_tizen>
 192         public ProgressBar() : this(NDalicPINVOKE.ProgressBar_New(), true)
 193         {
 194             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 195
 196         }
 197
 198         internal ProgressBarValueChangedSignal ValueChangedSignal()
 199         {
 200             ProgressBarValueChangedSignal ret = new ProgressBarValueChangedSignal(NDalicPINVOKE.ProgressBar_ValueChangedSignal(swigCPtr), false);
 201             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 202             return ret;
 203         }
 204
 205         /// <summary>
 206         /// The progress value of the progress bar, the progress runs from 0 to 1.<br>
 207         /// If the value is set to 0, then the progress bar will be set to beginning.<br>
 208         /// If the value is set to 1, then the progress bar will be set to end.<br>
 209         /// Any value outside the range is ignored.<br>
 210         /// </summary>
 211         /// <since_tizen> 3 </since_tizen>
 212         public float ProgressValue
 213         {
 214             get
 215             {
 216                 float temp = 0.0f;
 217                 GetProperty(ProgressBar.Property.PROGRESS_VALUE).Get(out temp);
 218                 return temp;
 219             }
 220             set
 221             {
 222                 SetProperty(ProgressBar.Property.PROGRESS_VALUE, new Tizen.NUI.PropertyValue(value));
 223             }
 224         }
 225         /// <summary>
 226         /// The secondary progress value of the progress bar, the secondary progress runs from 0 to 1.<br>
 227         /// Optional. If not supplied, the default is 0.<br>
 228         /// If the value is set to 0, then the progress bar will be set secondary progress to beginning.<br>
 229         /// If the value is set to 1, then the progress bar will be set secondary progress to end.<br>
 230         /// Any value outside of the range is ignored.<br>
 231         /// </summary>
 232         /// <since_tizen> 3 </since_tizen>
 233         public float SecondaryProgressValue
 234         {
 235             get
 236             {
 237                 float temp = 0.0f;
 238                 GetProperty(ProgressBar.Property.SECONDARY_PROGRESS_VALUE).Get(out temp);
 239                 return temp;
 240             }
 241             set
 242             {
 243                 SetProperty(ProgressBar.Property.SECONDARY_PROGRESS_VALUE, new Tizen.NUI.PropertyValue(value));
 244             }
 245         }
 246         /// <summary>
 247         /// Sets the progress bar as \e indeterminate state.
 248         /// </summary>
 249         /// <since_tizen> 3 </since_tizen>
 250         public bool Indeterminate
 251         {
 252             get
 253             {
 254                 bool temp = false;
 255                 GetProperty(ProgressBar.Property.INDETERMINATE).Get(out temp);
 256                 return temp;
 257             }
 258             set
 259             {
 260                 SetProperty(ProgressBar.Property.INDETERMINATE, new Tizen.NUI.PropertyValue(value));
 261             }
 262         }
 263         /// <summary>
 264         /// The track visual value of progress bar, it's full progress area, and it's shown behind the PROGRESS_VISUAL.<br>
 265         /// Optional. If not supplied, the default track visual will be shown.<br>
 266         /// </summary>
 267         /// <since_tizen> 3 </since_tizen>
 268         public Tizen.NUI.PropertyMap TrackVisual
 269         {
 270             get
 271             {
 272                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
 273                 GetProperty(ProgressBar.Property.TRACK_VISUAL).Get(temp);
 274                 return temp;
 275             }
 276             set
 277             {
 278                 SetProperty(ProgressBar.Property.TRACK_VISUAL, new Tizen.NUI.PropertyValue(value));
 279             }
 280         }
 281         /// <summary>
 282         /// The progress visual value of the progress bar, the size of the progress visual is changed based on the PROGRESS_VALUE.<br>
 283         /// Optional. If not supplied, then the default progress visual will be shown.<br>
 284         /// </summary>
 285         /// <since_tizen> 3 </since_tizen>
 286         public Tizen.NUI.PropertyMap ProgressVisual
 287         {
 288             get
 289             {
 290                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
 291                 GetProperty(ProgressBar.Property.PROGRESS_VISUAL).Get(temp);
 292                 return temp;
 293             }
 294             set
 295             {
 296                 SetProperty(ProgressBar.Property.PROGRESS_VISUAL, new Tizen.NUI.PropertyValue(value));
 297             }
 298         }
 299         /// <summary>
 300         /// The secondary progress visual of the progress bar, the size of the secondary progress visual is changed based on the SECONDARY_PROGRESS_VALUE.<br>
 301         /// Optional. If not supplied, then the secondary progress visual will not be shown.<br>
 302         /// </summary>
 303         /// <since_tizen> 3 </since_tizen>
 304         public Tizen.NUI.PropertyMap SecondaryProgressVisual
 305         {
 306             get
 307             {
 308                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
 309                 GetProperty(ProgressBar.Property.SECONDARY_PROGRESS_VISUAL).Get(temp);
 310                 return temp;
 311             }
 312             set
 313             {
 314                 SetProperty(ProgressBar.Property.SECONDARY_PROGRESS_VISUAL, new Tizen.NUI.PropertyValue(value));
 315             }
 316         }
 317         /// <summary>
 318         /// The indeterminate visual of the progress bar.<br>
 319         /// Optional. If not supplied, then the default indeterminate visual will be shown.<br>
 320         /// </summary>
 321         /// <since_tizen> 3 </since_tizen>
 322         public Tizen.NUI.PropertyMap IndeterminateVisual
 323         {
 324             get
 325             {
 326                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
 327                 GetProperty(ProgressBar.Property.INDETERMINATE_VISUAL).Get(temp);
 328                 return temp;
 329             }
 330             set
 331             {
 332                 SetProperty(ProgressBar.Property.INDETERMINATE_VISUAL, new Tizen.NUI.PropertyValue(value));
 333             }
 334         }
 335         /// <summary>
 336         /// The transition data for the indeterminate visual animation.<br>
 337         /// Optional. If not supplied, then the default animation will be played.<br>
 338         /// </summary>
 339         /// <since_tizen> 3 </since_tizen>
 340         public Tizen.NUI.PropertyArray IndeterminateVisualAnimation
 341         {
 342             get
 343             {
 344                 Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
 345                 GetProperty(ProgressBar.Property.INDETERMINATE_VISUAL_ANIMATION).Get(temp);
 346                 return temp;
 347             }
 348             set
 349             {
 350                 SetProperty(ProgressBar.Property.INDETERMINATE_VISUAL_ANIMATION, new Tizen.NUI.PropertyValue(value));
 351             }
 352         }
 353         /// <summary>
 354         /// The label visual of the progress bar.
 355         /// </summary>
 356         /// <since_tizen> 3 </since_tizen>
 357         public Tizen.NUI.PropertyMap LabelVisual
 358         {
 359             get
 360             {
 361                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
 362                 GetProperty(ProgressBar.Property.LABEL_VISUAL).Get(temp);
 363                 return temp;
 364             }
 365             set
 366             {
 367                 SetProperty(ProgressBar.Property.LABEL_VISUAL, new Tizen.NUI.PropertyValue(value));
 368             }
 369         }
 370
 371     }
 372
 373 }