src/Tizen.NUI/src/public/UIComponents/Slider.cs

   1 /*
   2  * Copyright(c) 2018 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 System.ComponentModel;
  20 using Tizen.NUI.BaseComponents;
  21 using Tizen.NUI.Binding;
  22
  23 namespace Tizen.NUI.UIComponents
  24 {
  25     /// <summary>
  26     /// The slider is a control to enable sliding an indicator between two values.
  27     /// </summary>
  28     /// <since_tizen> 3 </since_tizen>
  29     public class Slider : View
  30     {
  31         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  32         [EditorBrowsable(EditorBrowsableState.Never)]
  33         public static readonly BindableProperty LowerBoundProperty = BindableProperty.Create("LowerBound", typeof(float), typeof(Slider), 0.0f, propertyChanged: (bindable, oldValue, newValue) =>
  34         {
  35             var slider = (Slider)bindable;
  36             if (newValue != null)
  37             {
  38                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.LOWER_BOUND, new Tizen.NUI.PropertyValue((float)newValue));
  39             }
  40         },
  41         defaultValueCreator:(bindable) =>
  42         {
  43             var slider = (Slider)bindable;
  44             float temp = 0.0f;
  45             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.LOWER_BOUND).Get(out temp);
  46             return temp;
  47         });
  48         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  49         [EditorBrowsable(EditorBrowsableState.Never)]
  50         public static readonly BindableProperty UpperBoundProperty = BindableProperty.Create("UpperBound", typeof(float), typeof(Slider), 1.0f, propertyChanged: (bindable, oldValue, newValue) =>
  51         {
  52             var slider = (Slider)bindable;
  53             if (newValue != null)
  54             {
  55                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.UPPER_BOUND, new Tizen.NUI.PropertyValue((float)newValue));
  56             }
  57         },
  58         defaultValueCreator:(bindable) =>
  59         {
  60             var slider = (Slider)bindable;
  61             float temp = 0.0f;
  62             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.UPPER_BOUND).Get(out temp);
  63             return temp;
  64         });
  65         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  66         [EditorBrowsable(EditorBrowsableState.Never)]
  67         public static readonly BindableProperty ValueProperty = BindableProperty.Create("Value", typeof(float), typeof(Slider), default(float), propertyChanged: (bindable, oldValue, newValue) =>
  68         {
  69             var slider = (Slider)bindable;
  70             if (newValue != null)
  71             {
  72                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.VALUE, new Tizen.NUI.PropertyValue((float)newValue));
  73             }
  74         },
  75         defaultValueCreator:(bindable) =>
  76         {
  77             var slider = (Slider)bindable;
  78             float temp = 0.0f;
  79             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.VALUE).Get(out temp);
  80             return temp;
  81         });
  82         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  83         [EditorBrowsable(EditorBrowsableState.Never)]
  84         public static readonly BindableProperty TrackVisualProperty = BindableProperty.Create("TrackVisual", typeof(PropertyMap), typeof(Slider), new PropertyMap(), propertyChanged: (bindable, oldValue, newValue) =>
  85         {
  86             var slider = (Slider)bindable;
  87             if (newValue != null)
  88             {
  89                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.TRACK_VISUAL, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
  90             }
  91         },
  92         defaultValueCreator:(bindable) =>
  93         {
  94             var slider = (Slider)bindable;
  95             PropertyMap temp = new PropertyMap();
  96             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.TRACK_VISUAL).Get(temp);
  97             return temp;
  98         });
  99         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 100         [EditorBrowsable(EditorBrowsableState.Never)]
 101         public static readonly BindableProperty HandleVisualProperty = BindableProperty.Create("HandleVisual", typeof(PropertyMap), typeof(Slider), new PropertyMap(), propertyChanged: (bindable, oldValue, newValue) =>
 102         {
 103             var slider = (Slider)bindable;
 104             if (newValue != null)
 105             {
 106                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.HANDLE_VISUAL, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
 107             }
 108         },
 109         defaultValueCreator:(bindable) =>
 110         {
 111             var slider = (Slider)bindable;
 112             PropertyMap temp = new PropertyMap();
 113             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.HANDLE_VISUAL).Get(temp);
 114             return temp;
 115         });
 116         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 117         [EditorBrowsable(EditorBrowsableState.Never)]
 118         public static readonly BindableProperty ProgressVisualProperty = BindableProperty.Create("ProgressVisual", typeof(PropertyMap), typeof(Slider), new PropertyMap(), propertyChanged: (bindable, oldValue, newValue) =>
 119         {
 120             var slider = (Slider)bindable;
 121             if (newValue != null)
 122             {
 123                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.PROGRESS_VISUAL, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
 124             }
 125         },
 126         defaultValueCreator:(bindable) =>
 127         {
 128             var slider = (Slider)bindable;
 129             PropertyMap temp = new PropertyMap();
 130             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.PROGRESS_VISUAL).Get(temp);
 131             return temp;
 132         });
 133         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 134         [EditorBrowsable(EditorBrowsableState.Never)]
 135         public static readonly BindableProperty PopupVisualProperty = BindableProperty.Create("PopupVisual", typeof(PropertyMap), typeof(Slider), new PropertyMap(), propertyChanged: (bindable, oldValue, newValue) =>
 136         {
 137             var slider = (Slider)bindable;
 138             if (newValue != null)
 139             {
 140                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.POPUP_VISUAL, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
 141             }
 142         },
 143         defaultValueCreator:(bindable) =>
 144         {
 145             var slider = (Slider)bindable;
 146             PropertyMap temp = new PropertyMap();
 147             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.POPUP_VISUAL).Get(temp);
 148             return temp;
 149         });
 150         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 151         [EditorBrowsable(EditorBrowsableState.Never)]
 152         public static readonly BindableProperty PopupArrowVisualProperty = BindableProperty.Create("PopupArrowVisual", typeof(PropertyMap), typeof(Slider), new PropertyMap(), propertyChanged: (bindable, oldValue, newValue) =>
 153         {
 154             var slider = (Slider)bindable;
 155             if (newValue != null)
 156             {
 157                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.POPUP_ARROW_VISUAL, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
 158             }
 159         },
 160         defaultValueCreator:(bindable) =>
 161         {
 162             var slider = (Slider)bindable;
 163             PropertyMap temp = new PropertyMap();
 164             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.POPUP_ARROW_VISUAL).Get(temp);
 165             return temp;
 166         });
 167         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 168         [EditorBrowsable(EditorBrowsableState.Never)]
 169         public static readonly BindableProperty DisabledColorProperty = BindableProperty.Create("DisabledColor", typeof(Vector4), typeof(Slider), Vector4.Zero, propertyChanged: (bindable, oldValue, newValue) =>
 170         {
 171             var slider = (Slider)bindable;
 172             if (newValue != null)
 173             {
 174                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.DISABLED_COLOR, new Tizen.NUI.PropertyValue((Vector4)newValue));
 175             }
 176         },
 177         defaultValueCreator:(bindable) =>
 178         {
 179             var slider = (Slider)bindable;
 180             Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
 181             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.DISABLED_COLOR).Get(temp);
 182             return temp;
 183         });
 184         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 185         [EditorBrowsable(EditorBrowsableState.Never)]
 186         public static readonly BindableProperty ValuePrecisionProperty = BindableProperty.Create("ValuePrecision", typeof(int), typeof(Slider), default(int), propertyChanged: (bindable, oldValue, newValue) =>
 187         {
 188             var slider = (Slider)bindable;
 189             if (newValue != null)
 190             {
 191                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.VALUE_PRECISION, new Tizen.NUI.PropertyValue((int)newValue));
 192             }
 193         },
 194         defaultValueCreator:(bindable) =>
 195         {
 196             var slider = (Slider)bindable;
 197             int temp = 0;
 198             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.VALUE_PRECISION).Get(out temp);
 199             return temp;
 200         });
 201         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 202         [EditorBrowsable(EditorBrowsableState.Never)]
 203         public static readonly BindableProperty ShowPopupProperty = BindableProperty.Create("ShowPopup", typeof(bool), typeof(Slider), false, propertyChanged: (bindable, oldValue, newValue) =>
 204         {
 205             var slider = (Slider)bindable;
 206             if (newValue != null)
 207             {
 208                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.SHOW_POPUP, new Tizen.NUI.PropertyValue((bool)newValue));
 209             }
 210         },
 211         defaultValueCreator:(bindable) =>
 212         {
 213             var slider = (Slider)bindable;
 214             bool temp = false;
 215             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.SHOW_POPUP).Get(out temp);
 216             return temp;
 217         });
 218         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 219         [EditorBrowsable(EditorBrowsableState.Never)]
 220         public static readonly BindableProperty ShowValueProperty = BindableProperty.Create("ShowValue", typeof(bool), typeof(Slider), false, propertyChanged: (bindable, oldValue, newValue) =>
 221         {
 222             var slider = (Slider)bindable;
 223             if (newValue != null)
 224             {
 225                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.SHOW_VALUE, new Tizen.NUI.PropertyValue((bool)newValue));
 226             }
 227         },
 228         defaultValueCreator:(bindable) =>
 229         {
 230             var slider = (Slider)bindable;
 231             bool temp = false;
 232             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.SHOW_VALUE).Get(out temp);
 233             return temp;
 234         });
 235         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 236         [EditorBrowsable(EditorBrowsableState.Never)]
 237         public static readonly BindableProperty MarksProperty = BindableProperty.Create("Marks", typeof(PropertyArray), typeof(Slider), new PropertyArray(), propertyChanged: (bindable, oldValue, newValue) =>
 238         {
 239             var slider = (Slider)bindable;
 240             if (newValue != null)
 241             {
 242                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.MARKS, new Tizen.NUI.PropertyValue((PropertyArray)newValue));
 243             }
 244         },
 245         defaultValueCreator:(bindable) =>
 246         {
 247             var slider = (Slider)bindable;
 248             Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
 249             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.MARKS).Get(temp);
 250             return temp;
 251         });
 252         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 253         [EditorBrowsable(EditorBrowsableState.Never)]
 254         public static readonly BindableProperty MarkToleranceProperty = BindableProperty.Create("MarkTolerance", typeof(float), typeof(Slider), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 255         {
 256             var slider = (Slider)bindable;
 257             if (newValue != null)
 258             {
 259                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.MARK_TOLERANCE, new Tizen.NUI.PropertyValue((float)newValue));
 260             }
 261         },
 262         defaultValueCreator:(bindable) =>
 263         {
 264             var slider = (Slider)bindable;
 265             float temp = 0.0f;
 266             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.MARK_TOLERANCE).Get(out temp);
 267             return temp;
 268         });
 269         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 270         [EditorBrowsable(EditorBrowsableState.Never)]
 271         public static readonly BindableProperty SnapToMarksProperty = BindableProperty.Create("SnapToMarks", typeof(bool), typeof(Slider), false, propertyChanged: (bindable, oldValue, newValue) =>
 272         {
 273             var slider = (Slider)bindable;
 274             if (newValue != null)
 275             {
 276                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.SNAP_TO_MARKS, new Tizen.NUI.PropertyValue((bool)newValue));
 277             }
 278         },
 279         defaultValueCreator:(bindable) =>
 280         {
 281             var slider = (Slider)bindable;
 282             bool temp = false;
 283             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.SNAP_TO_MARKS).Get(out temp);
 284             return temp;
 285         });
 286
 287         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 288         private EventHandlerWithReturnType<object, ValueChangedEventArgs, bool> _sliderValueChangedEventHandler;
 289         private ValueChangedCallbackDelegate _sliderValueChangedCallbackDelegate;
 290         private EventHandlerWithReturnType<object, SlidingFinishedEventArgs, bool> _sliderSlidingFinishedEventHandler;
 291         private SlidingFinishedCallbackDelegate _sliderSlidingFinishedCallbackDelegate;
 292         private EventHandlerWithReturnType<object, MarkReachedEventArgs, bool> _sliderMarkReachedEventHandler;
 293         private MarkReachedCallbackDelegate _sliderMarkReachedCallbackDelegate;
 294
 295         /// <summary>
 296         /// Creates the slider control.
 297         /// </summary>
 298         /// <since_tizen> 3 </since_tizen>
 299         public Slider() : this(Interop.Slider.Slider_New(), true)
 300         {
 301             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 302         }
 303
 304         internal Slider(global::System.IntPtr cPtr, bool cMemoryOwn) : base(Interop.Slider.Slider_SWIGUpcast(cPtr), cMemoryOwn)
 305         {
 306             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 307         }
 308
 309         internal Slider(Slider handle) : this(Interop.Slider.new_Slider__SWIG_1(Slider.getCPtr(handle)), true)
 310         {
 311             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 312         }
 313
 314         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 315         private delegate bool ValueChangedCallbackDelegate(IntPtr slider, float slideValue);
 316         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 317         private delegate bool SlidingFinishedCallbackDelegate(IntPtr slider, float slideValue);
 318         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 319         private delegate bool MarkReachedCallbackDelegate(IntPtr slider, int slideValue);
 320
 321         /// <summary>
 322         /// An event emitted when the slider value changes.
 323         /// </summary>
 324         /// <since_tizen> 3 </since_tizen>
 325         public event EventHandlerWithReturnType<object, ValueChangedEventArgs, bool> ValueChanged
 326         {
 327             add
 328             {
 329                 if (_sliderValueChangedEventHandler == null)
 330                 {
 331                     _sliderValueChangedCallbackDelegate = (OnValueChanged);
 332                     ValueChangedSignal().Connect(_sliderValueChangedCallbackDelegate);
 333                 }
 334                 _sliderValueChangedEventHandler += value;
 335             }
 336             remove
 337             {
 338                 _sliderValueChangedEventHandler -= value;
 339                 if (_sliderValueChangedEventHandler == null && ValueChangedSignal().Empty() == false)
 340                 {
 341                     ValueChangedSignal().Disconnect(_sliderValueChangedCallbackDelegate);
 342                 }
 343             }
 344         }
 345
 346         /// <summary>
 347         /// An event emitted when the sliding is finished.
 348         /// </summary>
 349         /// <since_tizen> 3 </since_tizen>
 350         public event EventHandlerWithReturnType<object, SlidingFinishedEventArgs, bool> SlidingFinished
 351         {
 352             add
 353             {
 354                 if (_sliderSlidingFinishedEventHandler == null)
 355                 {
 356                     _sliderSlidingFinishedCallbackDelegate = (OnSlidingFinished);
 357                     SlidingFinishedSignal().Connect(_sliderSlidingFinishedCallbackDelegate);
 358                 }
 359                 _sliderSlidingFinishedEventHandler += value;
 360             }
 361             remove
 362             {
 363                 _sliderSlidingFinishedEventHandler -= value;
 364                 if (_sliderSlidingFinishedEventHandler == null && SlidingFinishedSignal().Empty() == false)
 365                 {
 366                     SlidingFinishedSignal().Disconnect(_sliderSlidingFinishedCallbackDelegate);
 367                 }
 368             }
 369         }
 370
 371         /// <summary>
 372         /// An event emitted when the slider handle reaches a mark.
 373         /// </summary>
 374         /// <since_tizen> 3 </since_tizen>
 375         public event EventHandlerWithReturnType<object, MarkReachedEventArgs, bool> MarkReached
 376         {
 377             add
 378             {
 379                 if (_sliderMarkReachedEventHandler == null)
 380                 {
 381                     _sliderMarkReachedCallbackDelegate = (OnMarkReached);
 382                     MarkReachedSignal().Connect(_sliderMarkReachedCallbackDelegate);
 383                 }
 384                 _sliderMarkReachedEventHandler += value;
 385             }
 386             remove
 387             {
 388                 _sliderMarkReachedEventHandler -= value;
 389                 if (_sliderMarkReachedEventHandler == null && MarkReachedSignal().Empty() == false)
 390                 {
 391                     MarkReachedSignal().Disconnect(_sliderMarkReachedCallbackDelegate);
 392                 }
 393             }
 394         }
 395
 396         /// <summary>
 397         /// The lower bound property.
 398         /// </summary>
 399         /// <since_tizen> 3 </since_tizen>
 400         public float LowerBound
 401         {
 402             get
 403             {
 404                 return (float)GetValue(LowerBoundProperty);
 405             }
 406             set
 407             {
 408                 SetValue(LowerBoundProperty, value);
 409             }
 410         }
 411
 412         /// <summary>
 413         /// The upper bound property.
 414         /// </summary>
 415         /// <since_tizen> 3 </since_tizen>
 416         public float UpperBound
 417         {
 418             get
 419             {
 420                 return (float)GetValue(UpperBoundProperty);
 421             }
 422             set
 423             {
 424                 SetValue(UpperBoundProperty, value);
 425             }
 426         }
 427
 428         /// <summary>
 429         /// The value property.
 430         /// </summary>
 431         /// <since_tizen> 3 </since_tizen>
 432         public float Value
 433         {
 434             get
 435             {
 436                 return (float)GetValue(ValueProperty);
 437             }
 438             set
 439             {
 440                 SetValue(ValueProperty, value);
 441             }
 442         }
 443
 444         /// <summary>
 445         /// The track visual property.
 446         /// </summary>
 447         /// <since_tizen> 3 </since_tizen>
 448         public PropertyMap TrackVisual
 449         {
 450             get
 451             {
 452                 return (PropertyMap)GetValue(TrackVisualProperty);
 453             }
 454             set
 455             {
 456                 SetValue(TrackVisualProperty, value);
 457             }
 458         }
 459
 460         /// <summary>
 461         /// The handle visual property.
 462         /// </summary>
 463         /// <since_tizen> 3 </since_tizen>
 464         public PropertyMap HandleVisual
 465         {
 466             get
 467             {
 468                 return (PropertyMap)GetValue(HandleVisualProperty);
 469             }
 470             set
 471             {
 472                 SetValue(HandleVisualProperty, value);
 473             }
 474         }
 475
 476         /// <summary>
 477         /// The progress visual property.
 478         /// </summary>
 479         /// <since_tizen> 3 </since_tizen>
 480         public PropertyMap ProgressVisual
 481         {
 482             get
 483             {
 484                 return (PropertyMap)GetValue(ProgressVisualProperty);
 485             }
 486             set
 487             {
 488                 SetValue(ProgressVisualProperty, value);
 489             }
 490         }
 491
 492         /// <summary>
 493         /// The popup visual property.
 494         /// </summary>
 495         /// <since_tizen> 3 </since_tizen>
 496         public PropertyMap PopupVisual
 497         {
 498             get
 499             {
 500                 return (PropertyMap)GetValue(PopupVisualProperty);
 501             }
 502             set
 503             {
 504                 SetValue(PopupVisualProperty, value);
 505             }
 506         }
 507
 508         /// <summary>
 509         /// The popup arrow visual property.
 510         /// </summary>
 511         /// <since_tizen> 3 </since_tizen>
 512         public PropertyMap PopupArrowVisual
 513         {
 514             get
 515             {
 516                 return (PropertyMap)GetValue(PopupArrowVisualProperty);
 517             }
 518             set
 519             {
 520                 SetValue(PopupArrowVisualProperty, value);
 521             }
 522         }
 523
 524         /// <summary>
 525         /// The disable color property.
 526         /// </summary>
 527         /// <since_tizen> 3 </since_tizen>
 528         public Vector4 DisabledColor
 529         {
 530             get
 531             {
 532                 return (Vector4)GetValue(DisabledColorProperty);
 533             }
 534             set
 535             {
 536                 SetValue(DisabledColorProperty, value);
 537             }
 538         }
 539
 540         /// <summary>
 541         /// The value precision property.
 542         /// </summary>
 543         /// <since_tizen> 3 </since_tizen>
 544         public int ValuePrecision
 545         {
 546             get
 547             {
 548                 return (int)GetValue(ValuePrecisionProperty);
 549             }
 550             set
 551             {
 552                 SetValue(ValuePrecisionProperty, value);
 553             }
 554         }
 555
 556         /// <summary>
 557         /// The show popup property.
 558         /// </summary>
 559         /// <since_tizen> 3 </since_tizen>
 560         public bool ShowPopup
 561         {
 562             get
 563             {
 564                 return (bool)GetValue(ShowPopupProperty);
 565             }
 566             set
 567             {
 568                 SetValue(ShowPopupProperty, value);
 569             }
 570         }
 571
 572         /// <summary>
 573         /// The show value property.
 574         /// </summary>
 575         /// <since_tizen> 3 </since_tizen>
 576         public bool ShowValue
 577         {
 578             get
 579             {
 580                 return (bool)GetValue(ShowValueProperty);
 581             }
 582             set
 583             {
 584                 SetValue(ShowValueProperty, value);
 585             }
 586         }
 587
 588         /// <summary>
 589         /// The marks property.
 590         /// </summary>
 591         /// <since_tizen> 3 </since_tizen>
 592         public Tizen.NUI.PropertyArray Marks
 593         {
 594             get
 595             {
 596                 return (PropertyArray)GetValue(MarksProperty);
 597             }
 598             set
 599             {
 600                 SetValue(MarksProperty, value);
 601             }
 602         }
 603
 604         /// <summary>
 605         /// The snap to marks property.
 606         /// </summary>
 607         /// <since_tizen> 3 </since_tizen>
 608         public bool SnapToMarks
 609         {
 610             get
 611             {
 612                 return (bool)GetValue(SnapToMarksProperty);
 613             }
 614             set
 615             {
 616                 SetValue(SnapToMarksProperty, value);
 617             }
 618         }
 619
 620         /// <summary>
 621         /// The mark tolerance property.
 622         /// </summary>
 623         /// <since_tizen> 3 </since_tizen>
 624         public float MarkTolerance
 625         {
 626             get
 627             {
 628                 return (float)GetValue(MarkToleranceProperty);
 629             }
 630             set
 631             {
 632                 SetValue(MarkToleranceProperty, value);
 633             }
 634         }
 635
 636         /// <summary>
 637         /// Downcasts an object handle to the slider.<br />
 638         /// If the handle points to a slider, then the downcast produces a valid handle.<br />
 639         /// If not, then the returned handle is left uninitialized.<br />
 640         /// </summary>
 641         /// <param name="handle">The handle to an object.</param>
 642         /// <returns>The handle to a slider or an uninitialized handle.</returns>
 643         /// <since_tizen> 3 </since_tizen>
 644         public static Slider DownCast(BaseHandle handle)
 645         {
 646             Slider ret = Registry.GetManagedBaseHandleFromNativePtr(handle) as Slider;
 647             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 648             return ret;
 649         }
 650
 651         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Slider obj)
 652         {
 653             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 654         }
 655
 656         /// <summary>
 657         /// Gets the slider from the pointer.
 658         /// </summary>
 659         /// <param name="cPtr">The pointer of the slider.</param>
 660         /// <returns>The object of the slider type.</returns>
 661         internal static Slider GetSliderFromPtr(global::System.IntPtr cPtr)
 662         {
 663             Slider ret = new Slider(cPtr, false);
 664             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 665             return ret;
 666         }
 667
 668         internal Slider Assign(Slider handle)
 669         {
 670             Slider ret = new Slider(Interop.Slider.Slider_Assign(swigCPtr, Slider.getCPtr(handle)), false);
 671             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 672             return ret;
 673         }
 674
 675         internal SliderValueChangedSignal ValueChangedSignal()
 676         {
 677             SliderValueChangedSignal ret = new SliderValueChangedSignal(Interop.Slider.Slider_ValueChangedSignal(swigCPtr), false);
 678             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 679             return ret;
 680         }
 681
 682         internal SliderValueChangedSignal SlidingFinishedSignal()
 683         {
 684             SliderValueChangedSignal ret = new SliderValueChangedSignal(Interop.Slider.Slider_SlidingFinishedSignal(swigCPtr), false);
 685             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 686             return ret;
 687         }
 688
 689         internal SliderMarkReachedSignal MarkReachedSignal()
 690         {
 691             SliderMarkReachedSignal ret = new SliderMarkReachedSignal(Interop.Slider.Slider_MarkReachedSignal(swigCPtr), false);
 692             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 693             return ret;
 694         }
 695
 696         /// <summary>
 697         /// Dispose.
 698         /// </summary>
 699         /// <since_tizen> 3 </since_tizen>
 700         protected override void Dispose(DisposeTypes type)
 701         {
 702             if (disposed)
 703             {
 704                 return;
 705             }
 706
 707             if (type == DisposeTypes.Explicit)
 708             {
 709                 //Called by User
 710                 //Release your own managed resources here.
 711                 //You should release all of your own disposable objects here.
 712
 713             }
 714
 715             //Release your own unmanaged resources here.
 716             //You should not access any managed member here except static instance.
 717             //because the execution order of Finalizes is non-deterministic.
 718             if (this != null)
 719             {
 720                 if (_sliderValueChangedCallbackDelegate != null)
 721                 {
 722                     ValueChangedSignal().Disconnect(_sliderValueChangedCallbackDelegate);
 723                 }
 724
 725                 if (_sliderSlidingFinishedCallbackDelegate != null)
 726                 {
 727                     SlidingFinishedSignal().Disconnect(_sliderSlidingFinishedCallbackDelegate);
 728                 }
 729
 730                 if (_sliderMarkReachedCallbackDelegate != null)
 731                 {
 732                     MarkReachedSignal().Disconnect(_sliderMarkReachedCallbackDelegate);
 733                 }
 734             }
 735
 736             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 737             {
 738                 if (swigCMemOwn)
 739                 {
 740                     swigCMemOwn = false;
 741                     Interop.Slider.delete_Slider(swigCPtr);
 742                 }
 743                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 744             }
 745
 746             base.Dispose(type);
 747         }
 748
 749         // Callback for Slider ValueChanged signal
 750         private bool OnValueChanged(IntPtr slider, float slideValue)
 751         {
 752             ValueChangedEventArgs e = new ValueChangedEventArgs();
 753
 754             // Populate all members of "e" (ValueChangedEventArgs) with real page
 755             e.Slider = Slider.GetSliderFromPtr(slider);
 756             e.SlideValue = slideValue;
 757
 758             if (_sliderValueChangedEventHandler != null)
 759             {
 760                 //here we send all page to user event handlers
 761                 return _sliderValueChangedEventHandler(this, e);
 762             }
 763             return false;
 764         }
 765
 766         // Callback for Slider SlidingFinished signal
 767         private bool OnSlidingFinished(IntPtr slider, float slideValue)
 768         {
 769             SlidingFinishedEventArgs e = new SlidingFinishedEventArgs();
 770
 771             // Populate all members of "e" (SlidingFinishedEventArgs) with real page
 772             e.Slider = Slider.GetSliderFromPtr(slider);
 773             e.SlideValue = slideValue;
 774
 775             if (_sliderSlidingFinishedEventHandler != null)
 776             {
 777                 //here we send all page to user event handlers
 778                 return _sliderSlidingFinishedEventHandler(this, e);
 779             }
 780             return false;
 781         }
 782
 783         // Callback for Slider MarkReached signal
 784         private bool OnMarkReached(IntPtr slider, int slideValue)
 785         {
 786             MarkReachedEventArgs e = new MarkReachedEventArgs();
 787
 788             // Populate all members of "e" (MarkReachedEventArgs) with real page
 789             e.Slider = Slider.GetSliderFromPtr(slider);
 790             e.SlideValue = slideValue;
 791
 792             if (_sliderMarkReachedEventHandler != null)
 793             {
 794                 //here we send all page to user event handlers
 795                 return _sliderMarkReachedEventHandler(this, e);
 796             }
 797             return false;
 798         }
 799
 800         /// <summary>
 801         /// The ValueChanged event arguments.
 802         /// </summary>
 803         /// <since_tizen> 3 </since_tizen>
 804         public class ValueChangedEventArgs : EventArgs
 805         {
 806             private Slider _slider;
 807             private float _slideValue;
 808
 809             /// <summary>
 810             /// The slider.
 811             /// </summary>
 812             /// <since_tizen> 3 </since_tizen>
 813             public Slider Slider
 814             {
 815                 get
 816                 {
 817                     return _slider;
 818                 }
 819                 set
 820                 {
 821                     _slider = value;
 822                 }
 823             }
 824
 825             /// <summary>
 826             /// The slider value.
 827             /// </summary>
 828             /// <since_tizen> 3 </since_tizen>
 829             public float SlideValue
 830             {
 831                 get
 832                 {
 833                     return _slideValue;
 834                 }
 835                 set
 836                 {
 837                     _slideValue = value;
 838                 }
 839             }
 840         }
 841
 842         /// <summary>
 843         /// The SlidingFinished event arguments.
 844         /// </summary>
 845         /// <since_tizen> 3 </since_tizen>
 846         public class SlidingFinishedEventArgs : EventArgs
 847         {
 848             private Slider _slider;
 849             private float _slideValue;
 850
 851             /// <summary>
 852             /// The slider.
 853             /// </summary>
 854             /// <since_tizen> 3 </since_tizen>
 855             public Slider Slider
 856             {
 857                 get
 858                 {
 859                     return _slider;
 860                 }
 861                 set
 862                 {
 863                     _slider = value;
 864                 }
 865             }
 866
 867             /// <summary>
 868             /// The slider value.
 869             /// </summary>
 870             /// <since_tizen> 3 </since_tizen>
 871             public float SlideValue
 872             {
 873                 get
 874                 {
 875                     return _slideValue;
 876                 }
 877                 set
 878                 {
 879                     _slideValue = value;
 880                 }
 881             }
 882         }
 883
 884         /// <summary>
 885         /// The MarkReached event arguments.
 886         /// </summary>
 887         /// <since_tizen> 3 </since_tizen>
 888         public class MarkReachedEventArgs : EventArgs
 889         {
 890             private Slider _slider;
 891             private int _slideValue;
 892
 893             /// <summary>
 894             /// The slider.
 895             /// </summary>
 896             /// <since_tizen> 3 </since_tizen>
 897             public Slider Slider
 898             {
 899                 get
 900                 {
 901                     return _slider;
 902                 }
 903                 set
 904                 {
 905                     _slider = value;
 906                 }
 907             }
 908
 909             /// <summary>
 910             /// The slider value.
 911             /// </summary>
 912             /// <since_tizen> 3 </since_tizen>
 913             public int SlideValue
 914             {
 915                 get
 916                 {
 917                     return _slideValue;
 918                 }
 919                 set
 920                 {
 921                     _slideValue = value;
 922                 }
 923             }
 924         }
 925
 926         internal new class Property
 927         {
 928             internal static readonly int LOWER_BOUND = Interop.Slider.Slider_Property_LOWER_BOUND_get();
 929             internal static readonly int UPPER_BOUND = Interop.Slider.Slider_Property_UPPER_BOUND_get();
 930             internal static readonly int VALUE = Interop.Slider.Slider_Property_VALUE_get();
 931             internal static readonly int TRACK_VISUAL = Interop.Slider.Slider_Property_TRACK_VISUAL_get();
 932             internal static readonly int HANDLE_VISUAL = Interop.Slider.Slider_Property_HANDLE_VISUAL_get();
 933             internal static readonly int PROGRESS_VISUAL = Interop.Slider.Slider_Property_PROGRESS_VISUAL_get();
 934             internal static readonly int POPUP_VISUAL = Interop.Slider.Slider_Property_POPUP_VISUAL_get();
 935             internal static readonly int POPUP_ARROW_VISUAL = Interop.Slider.Slider_Property_POPUP_ARROW_VISUAL_get();
 936             internal static readonly int DISABLED_COLOR = Interop.Slider.Slider_Property_DISABLED_COLOR_get();
 937             internal static readonly int VALUE_PRECISION = Interop.Slider.Slider_Property_VALUE_PRECISION_get();
 938             internal static readonly int SHOW_POPUP = Interop.Slider.Slider_Property_SHOW_POPUP_get();
 939             internal static readonly int SHOW_VALUE = Interop.Slider.Slider_Property_SHOW_VALUE_get();
 940             internal static readonly int MARKS = Interop.Slider.Slider_Property_MARKS_get();
 941             internal static readonly int SNAP_TO_MARKS = Interop.Slider.Slider_Property_SNAP_TO_MARKS_get();
 942             internal static readonly int MARK_TOLERANCE = Interop.Slider.Slider_Property_MARK_TOLERANCE_get();
 943         }
 944     }
 945 }