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