src/Tizen.NUI/src/public/UIComponents/Slider.cs

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