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