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