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