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

   1 /*
   2  * Copyright(c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 namespace Tizen.NUI.UIComponents
  19 {
  20
  21     using System;
  22     using System.Runtime.InteropServices;
  23     using Tizen.NUI.BaseComponents;
  24
  25     /// <summary>
  26     /// The slider is a control to enable sliding an indicator between two values.
  27     /// </summary>
  28     public class Slider : View
  29     {
  30         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  31
  32         internal Slider(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Slider_SWIGUpcast(cPtr), cMemoryOwn)
  33         {
  34             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  35         }
  36
  37         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Slider obj)
  38         {
  39             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  40         }
  41
  42         /// <summary>
  43         /// Dispose.
  44         /// </summary>
  45         protected override void Dispose(DisposeTypes type)
  46         {
  47             if (disposed)
  48             {
  49                 return;
  50             }
  51
  52             if (type == DisposeTypes.Explicit)
  53             {
  54                 //Called by User
  55                 //Release your own managed resources here.
  56                 //You should release all of your own disposable objects here.
  57
  58             }
  59
  60             //Release your own unmanaged resources here.
  61             //You should not access any managed member here except static instance.
  62             //because the execution order of Finalizes is non-deterministic.
  63
  64             if (_sliderValueChangedCallbackDelegate != null)
  65             {
  66                 ValueChangedSignal().Disconnect(_sliderValueChangedCallbackDelegate);
  67             }
  68
  69             if (_sliderSlidingFinishedCallbackDelegate != null)
  70             {
  71                 SlidingFinishedSignal().Disconnect(_sliderSlidingFinishedCallbackDelegate);
  72             }
  73
  74             if (_sliderMarkReachedCallbackDelegate != null)
  75             {
  76                 MarkReachedSignal().Disconnect(_sliderMarkReachedCallbackDelegate);
  77             }
  78
  79             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  80             {
  81                 if (swigCMemOwn)
  82                 {
  83                     swigCMemOwn = false;
  84                     NDalicPINVOKE.delete_Slider(swigCPtr);
  85                 }
  86                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  87             }
  88
  89             base.Dispose(type);
  90         }
  91
  92         /// <summary>
  93         /// The ValueChanged event arguments.
  94         /// </summary>
  95         public class ValueChangedEventArgs : EventArgs
  96         {
  97             private Slider _slider;
  98             private float _slideValue;
  99
 100             /// <summary>
 101             /// The slider.
 102             /// </summary>
 103             /// <since_tizen> 3 </since_tizen>
 104             public Slider Slider
 105             {
 106                 get
 107                 {
 108                     return _slider;
 109                 }
 110                 set
 111                 {
 112                     _slider = value;
 113                 }
 114             }
 115
 116             /// <summary>
 117             /// The slider value.
 118             /// </summary>
 119             /// <since_tizen> 3 </since_tizen>
 120             public float SlideValue
 121             {
 122                 get
 123                 {
 124                     return _slideValue;
 125                 }
 126                 set
 127                 {
 128                     _slideValue = value;
 129                 }
 130             }
 131         }
 132
 133         /// <summary>
 134         /// The SlidingFinished event arguments.
 135         /// </summary>
 136         public class SlidingFinishedEventArgs : EventArgs
 137         {
 138             private Slider _slider;
 139             private float _slideValue;
 140
 141             /// <summary>
 142             /// The slider.
 143             /// </summary>
 144             /// <since_tizen> 3 </since_tizen>
 145             public Slider Slider
 146             {
 147                 get
 148                 {
 149                     return _slider;
 150                 }
 151                 set
 152                 {
 153                     _slider = value;
 154                 }
 155             }
 156
 157             /// <summary>
 158             /// The slider value.
 159             /// </summary>
 160             /// <since_tizen> 3 </since_tizen>
 161             public float SlideValue
 162             {
 163                 get
 164                 {
 165                     return _slideValue;
 166                 }
 167                 set
 168                 {
 169                     _slideValue = value;
 170                 }
 171             }
 172         }
 173
 174         /// <summary>
 175         /// The MarkReached event arguments.
 176         /// </summary>
 177         public class MarkReachedEventArgs : EventArgs
 178         {
 179             private Slider _slider;
 180             private int _slideValue;
 181
 182             /// <summary>
 183             /// The slider.
 184             /// </summary>
 185             /// <since_tizen> 3 </since_tizen>
 186             public Slider Slider
 187             {
 188                 get
 189                 {
 190                     return _slider;
 191                 }
 192                 set
 193                 {
 194                     _slider = value;
 195                 }
 196             }
 197
 198             /// <summary>
 199             /// The slider value.
 200             /// </summary>
 201             /// <since_tizen> 3 </since_tizen>
 202             public int SlideValue
 203             {
 204                 get
 205                 {
 206                     return _slideValue;
 207                 }
 208                 set
 209                 {
 210                     _slideValue = value;
 211                 }
 212             }
 213         }
 214
 215
 216         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 217         private delegate bool ValueChangedCallbackDelegate(IntPtr slider, float slideValue);
 218         private EventHandlerWithReturnType<object, ValueChangedEventArgs, bool> _sliderValueChangedEventHandler;
 219         private ValueChangedCallbackDelegate _sliderValueChangedCallbackDelegate;
 220
 221         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 222         private delegate bool SlidingFinishedCallbackDelegate(IntPtr slider, float slideValue);
 223         private EventHandlerWithReturnType<object, SlidingFinishedEventArgs, bool> _sliderSlidingFinishedEventHandler;
 224         private SlidingFinishedCallbackDelegate _sliderSlidingFinishedCallbackDelegate;
 225
 226         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 227         private delegate bool MarkReachedCallbackDelegate(IntPtr slider, int slideValue);
 228         private EventHandlerWithReturnType<object, MarkReachedEventArgs, bool> _sliderMarkReachedEventHandler;
 229         private MarkReachedCallbackDelegate _sliderMarkReachedCallbackDelegate;
 230
 231         /// <summary>
 232         /// An event emitted when the slider value changes.
 233         /// </summary>
 234         /// <since_tizen> 3 </since_tizen>
 235         public event EventHandlerWithReturnType<object, ValueChangedEventArgs, bool> ValueChanged
 236         {
 237             add
 238             {
 239                 if (_sliderValueChangedEventHandler == null)
 240                 {
 241                     _sliderValueChangedCallbackDelegate = (OnValueChanged);
 242                     ValueChangedSignal().Connect(_sliderValueChangedCallbackDelegate);
 243                 }
 244                 _sliderValueChangedEventHandler += value;
 245             }
 246             remove
 247             {
 248                 _sliderValueChangedEventHandler -= value;
 249                 if (_sliderValueChangedEventHandler == null && ValueChangedSignal().Empty() == false)
 250                 {
 251                     ValueChangedSignal().Disconnect(_sliderValueChangedCallbackDelegate);
 252                 }
 253             }
 254         }
 255
 256         // Callback for Slider ValueChanged signal
 257         private bool OnValueChanged(IntPtr slider, float slideValue)
 258         {
 259             ValueChangedEventArgs e = new ValueChangedEventArgs();
 260
 261             // Populate all members of "e" (ValueChangedEventArgs) with real page
 262             e.Slider = Slider.GetSliderFromPtr(slider);
 263             e.SlideValue = slideValue;
 264
 265             if (_sliderValueChangedEventHandler != null)
 266             {
 267                 //here we send all page to user event handlers
 268                 return _sliderValueChangedEventHandler(this, e);
 269             }
 270             return false;
 271         }
 272
 273         /// <summary>
 274         /// An event emitted when the sliding is finished.
 275         /// </summary>
 276         /// <since_tizen> 3 </since_tizen>
 277         public event EventHandlerWithReturnType<object, SlidingFinishedEventArgs, bool> SlidingFinished
 278         {
 279             add
 280             {
 281                 if (_sliderSlidingFinishedEventHandler == null)
 282                 {
 283                     _sliderSlidingFinishedCallbackDelegate = (OnSlidingFinished);
 284                     SlidingFinishedSignal().Connect(_sliderSlidingFinishedCallbackDelegate);
 285                 }
 286                 _sliderSlidingFinishedEventHandler += value;
 287             }
 288             remove
 289             {
 290                 _sliderSlidingFinishedEventHandler -= value;
 291                 if (_sliderSlidingFinishedEventHandler == null && SlidingFinishedSignal().Empty() == false)
 292                 {
 293                     SlidingFinishedSignal().Disconnect(_sliderSlidingFinishedCallbackDelegate);
 294                 }
 295             }
 296         }
 297
 298         // Callback for Slider SlidingFinished signal
 299         private bool OnSlidingFinished(IntPtr slider, float slideValue)
 300         {
 301             SlidingFinishedEventArgs e = new SlidingFinishedEventArgs();
 302
 303             // Populate all members of "e" (SlidingFinishedEventArgs) with real page
 304             e.Slider = Slider.GetSliderFromPtr(slider);
 305             e.SlideValue = slideValue;
 306
 307             if (_sliderSlidingFinishedEventHandler != null)
 308             {
 309                 //here we send all page to user event handlers
 310                 return _sliderSlidingFinishedEventHandler(this, e);
 311             }
 312             return false;
 313         }
 314
 315         /// <summary>
 316         /// An event emitted when the slider handle reaches a mark.
 317         /// </summary>
 318         /// <since_tizen> 3 </since_tizen>
 319         public event EventHandlerWithReturnType<object, MarkReachedEventArgs, bool> MarkReached
 320         {
 321             add
 322             {
 323                 if (_sliderMarkReachedEventHandler == null)
 324                 {
 325                     _sliderMarkReachedCallbackDelegate = (OnMarkReached);
 326                     MarkReachedSignal().Connect(_sliderMarkReachedCallbackDelegate);
 327                 }
 328                 _sliderMarkReachedEventHandler += value;
 329             }
 330             remove
 331             {
 332                 _sliderMarkReachedEventHandler -= value;
 333                 if (_sliderMarkReachedEventHandler == null && MarkReachedSignal().Empty() == false)
 334                 {
 335                     MarkReachedSignal().Disconnect(_sliderMarkReachedCallbackDelegate);
 336                 }
 337             }
 338         }
 339
 340         // Callback for Slider MarkReached signal
 341         private bool OnMarkReached(IntPtr slider, int slideValue)
 342         {
 343             MarkReachedEventArgs e = new MarkReachedEventArgs();
 344
 345             // Populate all members of "e" (MarkReachedEventArgs) with real page
 346             e.Slider = Slider.GetSliderFromPtr(slider);
 347             e.SlideValue = slideValue;
 348
 349             if (_sliderMarkReachedEventHandler != null)
 350             {
 351                 //here we send all page to user event handlers
 352                 return _sliderMarkReachedEventHandler(this, e);
 353             }
 354             return false;
 355         }
 356
 357         /// <summary>
 358         /// Gets the slider from the pointer.
 359         /// </summary>
 360         /// <param name="cPtr">The pointer of the slider.</param>
 361         /// <returns>The object of the slider type.</returns>
 362         internal static Slider GetSliderFromPtr(global::System.IntPtr cPtr)
 363         {
 364             Slider ret = new Slider(cPtr, false);
 365             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 366             return ret;
 367         }
 368
 369         internal new class Property : global::System.IDisposable
 370         {
 371             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 372             protected bool swigCMemOwn;
 373
 374             internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)
 375             {
 376                 swigCMemOwn = cMemoryOwn;
 377                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 378             }
 379
 380             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)
 381             {
 382                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 383             }
 384
 385             //A Flag to check who called Dispose(). (By User or DisposeQueue)
 386             private bool isDisposeQueued = false;
 387             //A Flat to check if it is already disposed.
 388             protected bool disposed = false;
 389
 390             ~Property()
 391             {
 392                 if (!isDisposeQueued)
 393                 {
 394                     isDisposeQueued = true;
 395                     DisposeQueue.Instance.Add(this);
 396                 }
 397             }
 398
 399             /// <since_tizen> 3 </since_tizen>
 400             public void Dispose()
 401             {
 402                 //Throw excpetion if Dispose() is called in separate thread.
 403                 if (!Window.IsInstalled())
 404                 {
 405                     throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
 406                 }
 407
 408                 if (isDisposeQueued)
 409                 {
 410                     Dispose(DisposeTypes.Implicit);
 411                 }
 412                 else
 413                 {
 414                     Dispose(DisposeTypes.Explicit);
 415                     System.GC.SuppressFinalize(this);
 416                 }
 417             }
 418
 419             protected virtual void Dispose(DisposeTypes type)
 420             {
 421                 if (disposed)
 422                 {
 423                     return;
 424                 }
 425
 426                 if (type == DisposeTypes.Explicit)
 427                 {
 428                     //Called by User
 429                     //Release your own managed resources here.
 430                     //You should release all of your own disposable objects here.
 431
 432                 }
 433
 434                 //Release your own unmanaged resources here.
 435                 //You should not access any managed member here except static instance.
 436                 //because the execution order of Finalizes is non-deterministic.
 437
 438                 if (swigCPtr.Handle != global::System.IntPtr.Zero)
 439                 {
 440                     if (swigCMemOwn)
 441                     {
 442                         swigCMemOwn = false;
 443                         NDalicPINVOKE.delete_Slider_Property(swigCPtr);
 444                     }
 445                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 446                 }
 447
 448                 disposed = true;
 449             }
 450
 451             internal Property() : this(NDalicPINVOKE.new_Slider_Property(), true)
 452             {
 453                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 454             }
 455
 456             internal static readonly int LOWER_BOUND = NDalicPINVOKE.Slider_Property_LOWER_BOUND_get();
 457             internal static readonly int UPPER_BOUND = NDalicPINVOKE.Slider_Property_UPPER_BOUND_get();
 458             internal static readonly int VALUE = NDalicPINVOKE.Slider_Property_VALUE_get();
 459             internal static readonly int TRACK_VISUAL = NDalicPINVOKE.Slider_Property_TRACK_VISUAL_get();
 460             internal static readonly int HANDLE_VISUAL = NDalicPINVOKE.Slider_Property_HANDLE_VISUAL_get();
 461             internal static readonly int PROGRESS_VISUAL = NDalicPINVOKE.Slider_Property_PROGRESS_VISUAL_get();
 462             internal static readonly int POPUP_VISUAL = NDalicPINVOKE.Slider_Property_POPUP_VISUAL_get();
 463             internal static readonly int POPUP_ARROW_VISUAL = NDalicPINVOKE.Slider_Property_POPUP_ARROW_VISUAL_get();
 464             internal static readonly int DISABLED_COLOR = NDalicPINVOKE.Slider_Property_DISABLED_COLOR_get();
 465             internal static readonly int VALUE_PRECISION = NDalicPINVOKE.Slider_Property_VALUE_PRECISION_get();
 466             internal static readonly int SHOW_POPUP = NDalicPINVOKE.Slider_Property_SHOW_POPUP_get();
 467             internal static readonly int SHOW_VALUE = NDalicPINVOKE.Slider_Property_SHOW_VALUE_get();
 468             internal static readonly int MARKS = NDalicPINVOKE.Slider_Property_MARKS_get();
 469             internal static readonly int SNAP_TO_MARKS = NDalicPINVOKE.Slider_Property_SNAP_TO_MARKS_get();
 470             internal static readonly int MARK_TOLERANCE = NDalicPINVOKE.Slider_Property_MARK_TOLERANCE_get();
 471
 472         }
 473
 474         /// <summary>
 475         /// Creates the slider control.
 476         /// </summary>
 477         /// <since_tizen> 3 </since_tizen>
 478         public Slider() : this(NDalicPINVOKE.Slider_New(), true)
 479         {
 480             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 481
 482         }
 483         internal Slider(Slider handle) : this(NDalicPINVOKE.new_Slider__SWIG_1(Slider.getCPtr(handle)), true)
 484         {
 485             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 486         }
 487
 488         internal Slider Assign(Slider handle)
 489         {
 490             Slider ret = new Slider(NDalicPINVOKE.Slider_Assign(swigCPtr, Slider.getCPtr(handle)), false);
 491             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 492             return ret;
 493         }
 494
 495         /// <summary>
 496         /// Downcasts an object handle to the slider.<br />
 497         /// If the handle points to a slider, then the downcast produces a valid handle.<br />
 498         /// If not, then the returned handle is left uninitialized.<br />
 499         /// </summary>
 500         /// <param name="handle">The handle to an object.</param>
 501         /// <returns>The handle to a slider or an uninitialized handle.</returns>
 502         /// <since_tizen> 3 </since_tizen>
 503         public new static Slider DownCast(BaseHandle handle)
 504         {
 505             Slider ret =  Registry.GetManagedBaseHandleFromNativePtr(handle) as Slider;
 506             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 507             return ret;
 508         }
 509
 510         internal SliderValueChangedSignal ValueChangedSignal()
 511         {
 512             SliderValueChangedSignal ret = new SliderValueChangedSignal(NDalicPINVOKE.Slider_ValueChangedSignal(swigCPtr), false);
 513             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 514             return ret;
 515         }
 516
 517         internal SliderValueChangedSignal SlidingFinishedSignal()
 518         {
 519             SliderValueChangedSignal ret = new SliderValueChangedSignal(NDalicPINVOKE.Slider_SlidingFinishedSignal(swigCPtr), false);
 520             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 521             return ret;
 522         }
 523
 524         internal SliderMarkReachedSignal MarkReachedSignal()
 525         {
 526             SliderMarkReachedSignal ret = new SliderMarkReachedSignal(NDalicPINVOKE.Slider_MarkReachedSignal(swigCPtr), false);
 527             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 528             return ret;
 529         }
 530
 531         /// <summary>
 532         /// The lower bound property.
 533         /// </summary>
 534         /// <since_tizen> 3 </since_tizen>
 535         public float LowerBound
 536         {
 537             get
 538             {
 539                 float temp = 0.0f;
 540                 GetProperty(Slider.Property.LOWER_BOUND).Get(out temp);
 541                 return temp;
 542             }
 543             set
 544             {
 545                 SetProperty(Slider.Property.LOWER_BOUND, new Tizen.NUI.PropertyValue(value));
 546             }
 547         }
 548
 549         /// <summary>
 550         /// The upper bound property.
 551         /// </summary>
 552         /// <since_tizen> 3 </since_tizen>
 553         public float UpperBound
 554         {
 555             get
 556             {
 557                 float temp = 0.0f;
 558                 GetProperty(Slider.Property.UPPER_BOUND).Get(out temp);
 559                 return temp;
 560             }
 561             set
 562             {
 563                 SetProperty(Slider.Property.UPPER_BOUND, new Tizen.NUI.PropertyValue(value));
 564             }
 565         }
 566
 567         /// <summary>
 568         /// The value property.
 569         /// </summary>
 570         /// <since_tizen> 3 </since_tizen>
 571         public float Value
 572         {
 573             get
 574             {
 575                 float temp = 0.0f;
 576                 GetProperty(Slider.Property.VALUE).Get(out temp);
 577                 return temp;
 578             }
 579             set
 580             {
 581                 SetProperty(Slider.Property.VALUE, new Tizen.NUI.PropertyValue(value));
 582             }
 583         }
 584
 585         /// <summary>
 586         /// The track visual property.
 587         /// </summary>
 588         /// <since_tizen> 3 </since_tizen>
 589         public PropertyMap TrackVisual
 590         {
 591             get
 592             {
 593                 PropertyMap temp = new PropertyMap();
 594                 GetProperty(Slider.Property.TRACK_VISUAL).Get(temp);
 595                 return temp;
 596             }
 597             set
 598             {
 599                 SetProperty(Slider.Property.TRACK_VISUAL, new Tizen.NUI.PropertyValue(value));
 600             }
 601         }
 602
 603         /// <summary>
 604         /// The handle visual property.
 605         /// </summary>
 606         /// <since_tizen> 3 </since_tizen>
 607         public PropertyMap HandleVisual
 608         {
 609             get
 610             {
 611                 PropertyMap temp = new PropertyMap();
 612                 GetProperty(Slider.Property.HANDLE_VISUAL).Get(temp);
 613                 return temp;
 614             }
 615             set
 616             {
 617                 SetProperty(Slider.Property.HANDLE_VISUAL, new Tizen.NUI.PropertyValue(value));
 618             }
 619         }
 620
 621         /// <summary>
 622         /// The progress visual property.
 623         /// </summary>
 624         /// <since_tizen> 3 </since_tizen>
 625         public PropertyMap ProgressVisual
 626         {
 627             get
 628             {
 629                 PropertyMap temp = new PropertyMap();
 630                 GetProperty(Slider.Property.PROGRESS_VISUAL).Get(temp);
 631                 return temp;
 632             }
 633             set
 634             {
 635                 SetProperty(Slider.Property.PROGRESS_VISUAL, new Tizen.NUI.PropertyValue(value));
 636             }
 637         }
 638
 639         /// <summary>
 640         /// The popup visual property.
 641         /// </summary>
 642         /// <since_tizen> 3 </since_tizen>
 643         public PropertyMap PopupVisual
 644         {
 645             get
 646             {
 647                 PropertyMap temp = new PropertyMap();
 648                 GetProperty(Slider.Property.POPUP_VISUAL).Get(temp);
 649                 return temp;
 650             }
 651             set
 652             {
 653                 SetProperty(Slider.Property.POPUP_VISUAL, new Tizen.NUI.PropertyValue(value));
 654             }
 655         }
 656
 657         /// <summary>
 658         /// The popup arrow visual property.
 659         /// </summary>
 660         /// <since_tizen> 3 </since_tizen>
 661         public PropertyMap PopupArrowVisual
 662         {
 663             get
 664             {
 665                 PropertyMap temp = new PropertyMap();
 666                 GetProperty(Slider.Property.POPUP_ARROW_VISUAL).Get(temp);
 667                 return temp;
 668             }
 669             set
 670             {
 671                 SetProperty(Slider.Property.POPUP_ARROW_VISUAL, new Tizen.NUI.PropertyValue(value));
 672             }
 673         }
 674
 675         /// <summary>
 676         /// The disable color property.
 677         /// </summary>
 678         /// <since_tizen> 3 </since_tizen>
 679         public Vector4 DisabledColor
 680         {
 681             get
 682             {
 683                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
 684                 GetProperty(Slider.Property.DISABLED_COLOR).Get(temp);
 685                 return temp;
 686             }
 687             set
 688             {
 689                 SetProperty(Slider.Property.DISABLED_COLOR, new Tizen.NUI.PropertyValue(value));
 690             }
 691         }
 692
 693         /// <summary>
 694         /// The value precision property.
 695         /// </summary>
 696         /// <since_tizen> 3 </since_tizen>
 697         public int ValuePrecision
 698         {
 699             get
 700             {
 701                 int temp = 0;
 702                 GetProperty(Slider.Property.VALUE_PRECISION).Get(out temp);
 703                 return temp;
 704             }
 705             set
 706             {
 707                 SetProperty(Slider.Property.VALUE_PRECISION, new Tizen.NUI.PropertyValue(value));
 708             }
 709         }
 710
 711         /// <summary>
 712         /// The show popup property.
 713         /// </summary>
 714         /// <since_tizen> 3 </since_tizen>
 715         public bool ShowPopup
 716         {
 717             get
 718             {
 719                 bool temp = false;
 720                 GetProperty(Slider.Property.SHOW_POPUP).Get(out temp);
 721                 return temp;
 722             }
 723             set
 724             {
 725                 SetProperty(Slider.Property.SHOW_POPUP, new Tizen.NUI.PropertyValue(value));
 726             }
 727         }
 728
 729         /// <summary>
 730         /// The show value property.
 731         /// </summary>
 732         /// <since_tizen> 3 </since_tizen>
 733         public bool ShowValue
 734         {
 735             get
 736             {
 737                 bool temp = false;
 738                 GetProperty(Slider.Property.SHOW_VALUE).Get(out temp);
 739                 return temp;
 740             }
 741             set
 742             {
 743                 SetProperty(Slider.Property.SHOW_VALUE, new Tizen.NUI.PropertyValue(value));
 744             }
 745         }
 746
 747         /// <summary>
 748         /// The marks property.
 749         /// </summary>
 750         /// <since_tizen> 3 </since_tizen>
 751         public Tizen.NUI.PropertyArray Marks
 752         {
 753             get
 754             {
 755                 Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
 756                 GetProperty(Slider.Property.MARKS).Get(temp);
 757                 return temp;
 758             }
 759             set
 760             {
 761                 SetProperty(Slider.Property.MARKS, new Tizen.NUI.PropertyValue(value));
 762             }
 763         }
 764
 765         /// <summary>
 766         /// The snap to marks property.
 767         /// </summary>
 768         /// <since_tizen> 3 </since_tizen>
 769         public bool SnapToMarks
 770         {
 771             get
 772             {
 773                 bool temp = false;
 774                 GetProperty(Slider.Property.SNAP_TO_MARKS).Get(out temp);
 775                 return temp;
 776             }
 777             set
 778             {
 779                 SetProperty(Slider.Property.SNAP_TO_MARKS, new Tizen.NUI.PropertyValue(value));
 780             }
 781         }
 782
 783         /// <summary>
 784         /// The mark tolerance property.
 785         /// </summary>
 786         /// <since_tizen> 3 </since_tizen>
 787         public float MarkTolerance
 788         {
 789             get
 790             {
 791                 float temp = 0.0f;
 792                 GetProperty(Slider.Property.MARK_TOLERANCE).Get(out temp);
 793                 return temp;
 794             }
 795             set
 796             {
 797                 SetProperty(Slider.Property.MARK_TOLERANCE, new Tizen.NUI.PropertyValue(value));
 798             }
 799         }
 800
 801     }
 802
 803 }