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