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