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