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

   1 /*
   2  * Copyright(c) 2018 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 using System;
  18 using System.Runtime.InteropServices;
  19 using System.ComponentModel;
  20 using Tizen.NUI.BaseComponents;
  21 using Tizen.NUI.Binding;
  22 using Tizen.NUI.Binding.Internals;
  23
  24 namespace Tizen.NUI.UIComponents
  25 {
  26     /// <summary>
  27     /// The slider is a control to enable sliding an indicator between two values.
  28     /// </summary>
  29     /// <since_tizen> 3 </since_tizen>
  30     public class Slider : View
  31     {
  32         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  33         [EditorBrowsable(EditorBrowsableState.Never)]
  34         public static readonly BindableProperty LowerBoundProperty = BindableProperty.Create("LowerBound", typeof(float), typeof(Slider), 0.0f, propertyChanged: (bindable, oldValue, newValue) =>
  35         {
  36             var slider = (Slider)bindable;
  37             if (newValue != null)
  38             {
  39                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.LOWER_BOUND, new Tizen.NUI.PropertyValue((float)newValue));
  40             }
  41         },
  42         defaultValueCreator:(bindable) =>
  43         {
  44             var slider = (Slider)bindable;
  45             float temp = 0.0f;
  46             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.LOWER_BOUND).Get(out temp);
  47             return temp;
  48         });
  49         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  50         [EditorBrowsable(EditorBrowsableState.Never)]
  51         public static readonly BindableProperty UpperBoundProperty = BindableProperty.Create("UpperBound", typeof(float), typeof(Slider), 1.0f, propertyChanged: (bindable, oldValue, newValue) =>
  52         {
  53             var slider = (Slider)bindable;
  54             if (newValue != null)
  55             {
  56                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.UPPER_BOUND, new Tizen.NUI.PropertyValue((float)newValue));
  57             }
  58         },
  59         defaultValueCreator:(bindable) =>
  60         {
  61             var slider = (Slider)bindable;
  62             float temp = 0.0f;
  63             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.UPPER_BOUND).Get(out temp);
  64             return temp;
  65         });
  66         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  67         [EditorBrowsable(EditorBrowsableState.Never)]
  68         public static readonly BindableProperty ValueProperty = BindableProperty.Create("Value", typeof(float), typeof(Slider), default(float), BindingMode.TwoWay, propertyChanged: (bindable, oldValue, newValue) =>
  69         {
  70             var slider = (Slider)bindable;
  71             if (newValue != null)
  72             {
  73                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.VALUE, new Tizen.NUI.PropertyValue((float)newValue));
  74             }
  75         },
  76         defaultValueCreator:(bindable) =>
  77         {
  78             var slider = (Slider)bindable;
  79             float temp = 0.0f;
  80             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.VALUE).Get(out temp);
  81             return temp;
  82         });
  83         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  84         [EditorBrowsable(EditorBrowsableState.Never)]
  85         public static readonly BindableProperty TrackVisualProperty = BindableProperty.Create("TrackVisual", typeof(PropertyMap), typeof(Slider), new PropertyMap(), propertyChanged: (bindable, oldValue, newValue) =>
  86         {
  87             var slider = (Slider)bindable;
  88             if (newValue != null)
  89             {
  90                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.TRACK_VISUAL, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
  91             }
  92         },
  93         defaultValueCreator:(bindable) =>
  94         {
  95             var slider = (Slider)bindable;
  96             PropertyMap temp = new PropertyMap();
  97             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.TRACK_VISUAL).Get(temp);
  98             return temp;
  99         });
 100         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 101         [EditorBrowsable(EditorBrowsableState.Never)]
 102         public static readonly BindableProperty HandleVisualProperty = BindableProperty.Create("HandleVisual", typeof(PropertyMap), typeof(Slider), new PropertyMap(), propertyChanged: (bindable, oldValue, newValue) =>
 103         {
 104             var slider = (Slider)bindable;
 105             if (newValue != null)
 106             {
 107                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.HANDLE_VISUAL, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
 108             }
 109         },
 110         defaultValueCreator:(bindable) =>
 111         {
 112             var slider = (Slider)bindable;
 113             PropertyMap temp = new PropertyMap();
 114             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.HANDLE_VISUAL).Get(temp);
 115             return temp;
 116         });
 117         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 118         [EditorBrowsable(EditorBrowsableState.Never)]
 119         public static readonly BindableProperty ProgressVisualProperty = BindableProperty.Create("ProgressVisual", typeof(PropertyMap), typeof(Slider), new PropertyMap(), propertyChanged: (bindable, oldValue, newValue) =>
 120         {
 121             var slider = (Slider)bindable;
 122             if (newValue != null)
 123             {
 124                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.PROGRESS_VISUAL, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
 125             }
 126         },
 127         defaultValueCreator:(bindable) =>
 128         {
 129             var slider = (Slider)bindable;
 130             PropertyMap temp = new PropertyMap();
 131             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.PROGRESS_VISUAL).Get(temp);
 132             return temp;
 133         });
 134         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 135         [EditorBrowsable(EditorBrowsableState.Never)]
 136         public static readonly BindableProperty PopupVisualProperty = BindableProperty.Create("PopupVisual", typeof(PropertyMap), typeof(Slider), new PropertyMap(), propertyChanged: (bindable, oldValue, newValue) =>
 137         {
 138             var slider = (Slider)bindable;
 139             if (newValue != null)
 140             {
 141                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.POPUP_VISUAL, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
 142             }
 143         },
 144         defaultValueCreator:(bindable) =>
 145         {
 146             var slider = (Slider)bindable;
 147             PropertyMap temp = new PropertyMap();
 148             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.POPUP_VISUAL).Get(temp);
 149             return temp;
 150         });
 151         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 152         [EditorBrowsable(EditorBrowsableState.Never)]
 153         public static readonly BindableProperty PopupArrowVisualProperty = BindableProperty.Create("PopupArrowVisual", typeof(PropertyMap), typeof(Slider), new PropertyMap(), propertyChanged: (bindable, oldValue, newValue) =>
 154         {
 155             var slider = (Slider)bindable;
 156             if (newValue != null)
 157             {
 158                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.POPUP_ARROW_VISUAL, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
 159             }
 160         },
 161         defaultValueCreator:(bindable) =>
 162         {
 163             var slider = (Slider)bindable;
 164             PropertyMap temp = new PropertyMap();
 165             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.POPUP_ARROW_VISUAL).Get(temp);
 166             return temp;
 167         });
 168         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 169         [EditorBrowsable(EditorBrowsableState.Never)]
 170         public static readonly BindableProperty DisabledColorProperty = BindableProperty.Create("DisabledColor", typeof(Vector4), typeof(Slider), Vector4.Zero, propertyChanged: (bindable, oldValue, newValue) =>
 171         {
 172             var slider = (Slider)bindable;
 173             if (newValue != null)
 174             {
 175                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.DISABLED_COLOR, new Tizen.NUI.PropertyValue((Vector4)newValue));
 176             }
 177         },
 178         defaultValueCreator:(bindable) =>
 179         {
 180             var slider = (Slider)bindable;
 181             Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
 182             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.DISABLED_COLOR).Get(temp);
 183             return temp;
 184         });
 185         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 186         [EditorBrowsable(EditorBrowsableState.Never)]
 187         public static readonly BindableProperty ValuePrecisionProperty = BindableProperty.Create("ValuePrecision", typeof(int), typeof(Slider), default(int), propertyChanged: (bindable, oldValue, newValue) =>
 188         {
 189             var slider = (Slider)bindable;
 190             if (newValue != null)
 191             {
 192                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.VALUE_PRECISION, new Tizen.NUI.PropertyValue((int)newValue));
 193             }
 194         },
 195         defaultValueCreator:(bindable) =>
 196         {
 197             var slider = (Slider)bindable;
 198             int temp = 0;
 199             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.VALUE_PRECISION).Get(out temp);
 200             return temp;
 201         });
 202         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 203         [EditorBrowsable(EditorBrowsableState.Never)]
 204         public static readonly BindableProperty ShowPopupProperty = BindableProperty.Create("ShowPopup", typeof(bool), typeof(Slider), false, propertyChanged: (bindable, oldValue, newValue) =>
 205         {
 206             var slider = (Slider)bindable;
 207             if (newValue != null)
 208             {
 209                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.SHOW_POPUP, new Tizen.NUI.PropertyValue((bool)newValue));
 210             }
 211         },
 212         defaultValueCreator:(bindable) =>
 213         {
 214             var slider = (Slider)bindable;
 215             bool temp = false;
 216             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.SHOW_POPUP).Get(out temp);
 217             return temp;
 218         });
 219         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 220         [EditorBrowsable(EditorBrowsableState.Never)]
 221         public static readonly BindableProperty ShowValueProperty = BindableProperty.Create("ShowValue", typeof(bool), typeof(Slider), false, propertyChanged: (bindable, oldValue, newValue) =>
 222         {
 223             var slider = (Slider)bindable;
 224             if (newValue != null)
 225             {
 226                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.SHOW_VALUE, new Tizen.NUI.PropertyValue((bool)newValue));
 227             }
 228         },
 229         defaultValueCreator:(bindable) =>
 230         {
 231             var slider = (Slider)bindable;
 232             bool temp = false;
 233             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.SHOW_VALUE).Get(out temp);
 234             return temp;
 235         });
 236         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 237         [EditorBrowsable(EditorBrowsableState.Never)]
 238         public static readonly BindableProperty MarksProperty = BindableProperty.Create("Marks", typeof(PropertyArray), typeof(Slider), new PropertyArray(), propertyChanged: (bindable, oldValue, newValue) =>
 239         {
 240             var slider = (Slider)bindable;
 241             if (newValue != null)
 242             {
 243                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.MARKS, new Tizen.NUI.PropertyValue((PropertyArray)newValue));
 244             }
 245         },
 246         defaultValueCreator:(bindable) =>
 247         {
 248             var slider = (Slider)bindable;
 249             Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
 250             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.MARKS).Get(temp);
 251             return temp;
 252         });
 253         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 254         [EditorBrowsable(EditorBrowsableState.Never)]
 255         public static readonly BindableProperty MarkToleranceProperty = BindableProperty.Create("MarkTolerance", typeof(float), typeof(Slider), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 256         {
 257             var slider = (Slider)bindable;
 258             if (newValue != null)
 259             {
 260                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.MARK_TOLERANCE, new Tizen.NUI.PropertyValue((float)newValue));
 261             }
 262         },
 263         defaultValueCreator:(bindable) =>
 264         {
 265             var slider = (Slider)bindable;
 266             float temp = 0.0f;
 267             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.MARK_TOLERANCE).Get(out temp);
 268             return temp;
 269         });
 270         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 271         [EditorBrowsable(EditorBrowsableState.Never)]
 272         public static readonly BindableProperty SnapToMarksProperty = BindableProperty.Create("SnapToMarks", typeof(bool), typeof(Slider), false, propertyChanged: (bindable, oldValue, newValue) =>
 273         {
 274             var slider = (Slider)bindable;
 275             if (newValue != null)
 276             {
 277                 Tizen.NUI.Object.SetProperty(slider.swigCPtr, Slider.Property.SNAP_TO_MARKS, new Tizen.NUI.PropertyValue((bool)newValue));
 278             }
 279         },
 280         defaultValueCreator:(bindable) =>
 281         {
 282             var slider = (Slider)bindable;
 283             bool temp = false;
 284             Tizen.NUI.Object.GetProperty(slider.swigCPtr, Slider.Property.SNAP_TO_MARKS).Get(out temp);
 285             return temp;
 286         });
 287
 288         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 289         private EventHandlerWithReturnType<object, ValueChangedEventArgs, bool> _sliderValueChangedEventHandler;
 290         private ValueChangedCallbackDelegate _sliderValueChangedCallbackDelegate;
 291         private EventHandlerWithReturnType<object, SlidingFinishedEventArgs, bool> _sliderSlidingFinishedEventHandler;
 292         private SlidingFinishedCallbackDelegate _sliderSlidingFinishedCallbackDelegate;
 293         private EventHandlerWithReturnType<object, MarkReachedEventArgs, bool> _sliderMarkReachedEventHandler;
 294         private MarkReachedCallbackDelegate _sliderMarkReachedCallbackDelegate;
 295
 296         /// <summary>
 297         /// Creates the slider control.
 298         /// </summary>
 299         /// <since_tizen> 3 </since_tizen>
 300         public Slider() : this(Interop.Slider.Slider_New(), true)
 301         {
 302             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 303         }
 304
 305         internal Slider(global::System.IntPtr cPtr, bool cMemoryOwn) : base(Interop.Slider.Slider_SWIGUpcast(cPtr), cMemoryOwn)
 306         {
 307             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 308         }
 309
 310         internal Slider(Slider handle) : this(Interop.Slider.new_Slider__SWIG_1(Slider.getCPtr(handle)), true)
 311         {
 312             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 313         }
 314
 315         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 316         private delegate bool ValueChangedCallbackDelegate(IntPtr slider, float slideValue);
 317         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 318         private delegate bool SlidingFinishedCallbackDelegate(IntPtr slider, float slideValue);
 319         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 320         private delegate bool MarkReachedCallbackDelegate(IntPtr slider, int slideValue);
 321
 322         /// <summary>
 323         /// An event emitted when the slider value changes.
 324         /// </summary>
 325         /// <since_tizen> 3 </since_tizen>
 326         public event EventHandlerWithReturnType<object, ValueChangedEventArgs, bool> ValueChanged
 327         {
 328             add
 329             {
 330                 if (_sliderValueChangedEventHandler == null)
 331                 {
 332                     _sliderValueChangedCallbackDelegate = (OnValueChanged);
 333                     ValueChangedSignal().Connect(_sliderValueChangedCallbackDelegate);
 334                 }
 335                 _sliderValueChangedEventHandler += value;
 336             }
 337             remove
 338             {
 339                 _sliderValueChangedEventHandler -= value;
 340                 if (_sliderValueChangedEventHandler == null && ValueChangedSignal().Empty() == false)
 341                 {
 342                     ValueChangedSignal().Disconnect(_sliderValueChangedCallbackDelegate);
 343                 }
 344             }
 345         }
 346
 347         /// <summary>
 348         /// An event emitted when the sliding is finished.
 349         /// </summary>
 350         /// <since_tizen> 3 </since_tizen>
 351         public event EventHandlerWithReturnType<object, SlidingFinishedEventArgs, bool> SlidingFinished
 352         {
 353             add
 354             {
 355                 if (_sliderSlidingFinishedEventHandler == null)
 356                 {
 357                     _sliderSlidingFinishedCallbackDelegate = (OnSlidingFinished);
 358                     SlidingFinishedSignal().Connect(_sliderSlidingFinishedCallbackDelegate);
 359                 }
 360                 _sliderSlidingFinishedEventHandler += value;
 361             }
 362             remove
 363             {
 364                 _sliderSlidingFinishedEventHandler -= value;
 365                 if (_sliderSlidingFinishedEventHandler == null && SlidingFinishedSignal().Empty() == false)
 366                 {
 367                     SlidingFinishedSignal().Disconnect(_sliderSlidingFinishedCallbackDelegate);
 368                 }
 369             }
 370         }
 371
 372         /// <summary>
 373         /// An event emitted when the slider handle reaches a mark.
 374         /// </summary>
 375         /// <since_tizen> 3 </since_tizen>
 376         public event EventHandlerWithReturnType<object, MarkReachedEventArgs, bool> MarkReached
 377         {
 378             add
 379             {
 380                 if (_sliderMarkReachedEventHandler == null)
 381                 {
 382                     _sliderMarkReachedCallbackDelegate = (OnMarkReached);
 383                     MarkReachedSignal().Connect(_sliderMarkReachedCallbackDelegate);
 384                 }
 385                 _sliderMarkReachedEventHandler += value;
 386             }
 387             remove
 388             {
 389                 _sliderMarkReachedEventHandler -= value;
 390                 if (_sliderMarkReachedEventHandler == null && MarkReachedSignal().Empty() == false)
 391                 {
 392                     MarkReachedSignal().Disconnect(_sliderMarkReachedCallbackDelegate);
 393                 }
 394             }
 395         }
 396
 397         /// <summary>
 398         /// The lower bound property.
 399         /// </summary>
 400         /// <since_tizen> 3 </since_tizen>
 401         public float LowerBound
 402         {
 403             get
 404             {
 405                 return (float)GetValue(LowerBoundProperty);
 406             }
 407             set
 408             {
 409                 SetValue(LowerBoundProperty, value);
 410             }
 411         }
 412
 413         /// <summary>
 414         /// The upper bound property.
 415         /// </summary>
 416         /// <since_tizen> 3 </since_tizen>
 417         public float UpperBound
 418         {
 419             get
 420             {
 421                 return (float)GetValue(UpperBoundProperty);
 422             }
 423             set
 424             {
 425                 SetValue(UpperBoundProperty, value);
 426             }
 427         }
 428
 429         /// <summary>
 430         /// The value property.
 431         /// </summary>
 432         /// <since_tizen> 3 </since_tizen>
 433         public float Value
 434         {
 435             get
 436             {
 437                 return (float)GetValue(ValueProperty);
 438             }
 439             set
 440             {
 441                 SetValueAndForceSendChangeSignal(ValueProperty, value);
 442             }
 443         }
 444
 445         /// <summary>
 446         /// The track visual property.
 447         /// </summary>
 448         /// <since_tizen> 3 </since_tizen>
 449         public PropertyMap TrackVisual
 450         {
 451             get
 452             {
 453                 return (PropertyMap)GetValue(TrackVisualProperty);
 454             }
 455             set
 456             {
 457                 SetValue(TrackVisualProperty, value);
 458             }
 459         }
 460
 461         /// <summary>
 462         /// The handle visual property.
 463         /// </summary>
 464         /// <since_tizen> 3 </since_tizen>
 465         public PropertyMap HandleVisual
 466         {
 467             get
 468             {
 469                 return (PropertyMap)GetValue(HandleVisualProperty);
 470             }
 471             set
 472             {
 473                 SetValue(HandleVisualProperty, value);
 474             }
 475         }
 476
 477         /// <summary>
 478         /// The progress visual property.
 479         /// </summary>
 480         /// <since_tizen> 3 </since_tizen>
 481         public PropertyMap ProgressVisual
 482         {
 483             get
 484             {
 485                 return (PropertyMap)GetValue(ProgressVisualProperty);
 486             }
 487             set
 488             {
 489                 SetValue(ProgressVisualProperty, value);
 490             }
 491         }
 492
 493         /// <summary>
 494         /// The popup visual property.
 495         /// </summary>
 496         /// <since_tizen> 3 </since_tizen>
 497         public PropertyMap PopupVisual
 498         {
 499             get
 500             {
 501                 return (PropertyMap)GetValue(PopupVisualProperty);
 502             }
 503             set
 504             {
 505                 SetValue(PopupVisualProperty, value);
 506             }
 507         }
 508
 509         /// <summary>
 510         /// The popup arrow visual property.
 511         /// </summary>
 512         /// <since_tizen> 3 </since_tizen>
 513         public PropertyMap PopupArrowVisual
 514         {
 515             get
 516             {
 517                 return (PropertyMap)GetValue(PopupArrowVisualProperty);
 518             }
 519             set
 520             {
 521                 SetValue(PopupArrowVisualProperty, value);
 522             }
 523         }
 524
 525         /// <summary>
 526         /// The disable color property.
 527         /// </summary>
 528         /// <since_tizen> 3 </since_tizen>
 529         public Vector4 DisabledColor
 530         {
 531             get
 532             {
 533                 return (Vector4)GetValue(DisabledColorProperty);
 534             }
 535             set
 536             {
 537                 SetValue(DisabledColorProperty, value);
 538             }
 539         }
 540
 541         /// <summary>
 542         /// The value precision property.
 543         /// </summary>
 544         /// <since_tizen> 3 </since_tizen>
 545         public int ValuePrecision
 546         {
 547             get
 548             {
 549                 return (int)GetValue(ValuePrecisionProperty);
 550             }
 551             set
 552             {
 553                 SetValue(ValuePrecisionProperty, value);
 554             }
 555         }
 556
 557         /// <summary>
 558         /// The show popup property.
 559         /// </summary>
 560         /// <since_tizen> 3 </since_tizen>
 561         public bool ShowPopup
 562         {
 563             get
 564             {
 565                 return (bool)GetValue(ShowPopupProperty);
 566             }
 567             set
 568             {
 569                 SetValue(ShowPopupProperty, value);
 570             }
 571         }
 572
 573         /// <summary>
 574         /// The show value property.
 575         /// </summary>
 576         /// <since_tizen> 3 </since_tizen>
 577         public bool ShowValue
 578         {
 579             get
 580             {
 581                 return (bool)GetValue(ShowValueProperty);
 582             }
 583             set
 584             {
 585                 SetValue(ShowValueProperty, value);
 586             }
 587         }
 588
 589         /// <summary>
 590         /// The marks property.
 591         /// </summary>
 592         /// <since_tizen> 3 </since_tizen>
 593         public Tizen.NUI.PropertyArray Marks
 594         {
 595             get
 596             {
 597                 return (PropertyArray)GetValue(MarksProperty);
 598             }
 599             set
 600             {
 601                 SetValue(MarksProperty, value);
 602             }
 603         }
 604
 605         /// <summary>
 606         /// The snap to marks property.
 607         /// </summary>
 608         /// <since_tizen> 3 </since_tizen>
 609         public bool SnapToMarks
 610         {
 611             get
 612             {
 613                 return (bool)GetValue(SnapToMarksProperty);
 614             }
 615             set
 616             {
 617                 SetValue(SnapToMarksProperty, value);
 618             }
 619         }
 620
 621         /// <summary>
 622         /// The mark tolerance property.
 623         /// </summary>
 624         /// <since_tizen> 3 </since_tizen>
 625         public float MarkTolerance
 626         {
 627             get
 628             {
 629                 return (float)GetValue(MarkToleranceProperty);
 630             }
 631             set
 632             {
 633                 SetValue(MarkToleranceProperty, value);
 634             }
 635         }
 636
 637         /// Only used by the IL of xaml, will never changed to not hidden.
 638         [EditorBrowsable(EditorBrowsableState.Never)]
 639         public override bool IsCreateByXaml
 640         {
 641             get
 642             {
 643                 return base.IsCreateByXaml;
 644             }
 645             set
 646             {
 647                 base.IsCreateByXaml = value;
 648
 649                 if (value == true)
 650                 {
 651                     this.ValueChanged += (obj, e) => {
 652                         this.Value = e.SlideValue;
 653                         return true;
 654                     };
 655                 }
 656             }
 657         }
 658
 659         /// <summary>
 660         /// Downcasts an object handle to the slider.<br />
 661         /// If the handle points to a slider, then the downcast produces a valid handle.<br />
 662         /// If not, then the returned handle is left uninitialized.<br />
 663         /// </summary>
 664         /// <param name="handle">The handle to an object.</param>
 665         /// <returns>The handle to a slider or an uninitialized handle.</returns>
 666         /// <since_tizen> 3 </since_tizen>
 667         public static Slider DownCast(BaseHandle handle)
 668         {
 669             Slider ret = Registry.GetManagedBaseHandleFromNativePtr(handle) as Slider;
 670             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 671             return ret;
 672         }
 673
 674         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Slider obj)
 675         {
 676             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 677         }
 678
 679         /// <summary>
 680         /// Gets the slider from the pointer.
 681         /// </summary>
 682         /// <param name="cPtr">The pointer of the slider.</param>
 683         /// <returns>The object of the slider type.</returns>
 684         internal static Slider GetSliderFromPtr(global::System.IntPtr cPtr)
 685         {
 686             Slider ret = new Slider(cPtr, false);
 687             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 688             return ret;
 689         }
 690
 691         internal Slider Assign(Slider handle)
 692         {
 693             Slider ret = new Slider(Interop.Slider.Slider_Assign(swigCPtr, Slider.getCPtr(handle)), false);
 694             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 695             return ret;
 696         }
 697
 698         internal SliderValueChangedSignal ValueChangedSignal()
 699         {
 700             SliderValueChangedSignal ret = new SliderValueChangedSignal(Interop.Slider.Slider_ValueChangedSignal(swigCPtr), false);
 701             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 702             return ret;
 703         }
 704
 705         internal SliderValueChangedSignal SlidingFinishedSignal()
 706         {
 707             SliderValueChangedSignal ret = new SliderValueChangedSignal(Interop.Slider.Slider_SlidingFinishedSignal(swigCPtr), false);
 708             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 709             return ret;
 710         }
 711
 712         internal SliderMarkReachedSignal MarkReachedSignal()
 713         {
 714             SliderMarkReachedSignal ret = new SliderMarkReachedSignal(Interop.Slider.Slider_MarkReachedSignal(swigCPtr), false);
 715             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 716             return ret;
 717         }
 718
 719         /// <summary>
 720         /// Dispose.
 721         /// </summary>
 722         /// <since_tizen> 3 </since_tizen>
 723         protected override void Dispose(DisposeTypes type)
 724         {
 725             if (disposed)
 726             {
 727                 return;
 728             }
 729
 730             if (type == DisposeTypes.Explicit)
 731             {
 732                 //Called by User
 733                 //Release your own managed resources here.
 734                 //You should release all of your own disposable objects here.
 735
 736             }
 737
 738             //Release your own unmanaged resources here.
 739             //You should not access any managed member here except static instance.
 740             //because the execution order of Finalizes is non-deterministic.
 741             if (this != null)
 742             {
 743                 if (_sliderValueChangedCallbackDelegate != null)
 744                 {
 745                     ValueChangedSignal().Disconnect(_sliderValueChangedCallbackDelegate);
 746                 }
 747
 748                 if (_sliderSlidingFinishedCallbackDelegate != null)
 749                 {
 750                     SlidingFinishedSignal().Disconnect(_sliderSlidingFinishedCallbackDelegate);
 751                 }
 752
 753                 if (_sliderMarkReachedCallbackDelegate != null)
 754                 {
 755                     MarkReachedSignal().Disconnect(_sliderMarkReachedCallbackDelegate);
 756                 }
 757             }
 758
 759             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 760             {
 761                 if (swigCMemOwn)
 762                 {
 763                     swigCMemOwn = false;
 764                     Interop.Slider.delete_Slider(swigCPtr);
 765                 }
 766                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 767             }
 768
 769             base.Dispose(type);
 770         }
 771
 772         // Callback for Slider ValueChanged signal
 773         private bool OnValueChanged(IntPtr slider, float slideValue)
 774         {
 775             ValueChangedEventArgs e = new ValueChangedEventArgs();
 776
 777             // Populate all members of "e" (ValueChangedEventArgs) with real page
 778             e.Slider = Slider.GetSliderFromPtr(slider);
 779             e.SlideValue = slideValue;
 780
 781             if (_sliderValueChangedEventHandler != null)
 782             {
 783                 //here we send all page to user event handlers
 784                 return _sliderValueChangedEventHandler(this, e);
 785             }
 786             return false;
 787         }
 788
 789         // Callback for Slider SlidingFinished signal
 790         private bool OnSlidingFinished(IntPtr slider, float slideValue)
 791         {
 792             SlidingFinishedEventArgs e = new SlidingFinishedEventArgs();
 793
 794             // Populate all members of "e" (SlidingFinishedEventArgs) with real page
 795             e.Slider = Slider.GetSliderFromPtr(slider);
 796             e.SlideValue = slideValue;
 797
 798             if (_sliderSlidingFinishedEventHandler != null)
 799             {
 800                 //here we send all page to user event handlers
 801                 return _sliderSlidingFinishedEventHandler(this, e);
 802             }
 803             return false;
 804         }
 805
 806         // Callback for Slider MarkReached signal
 807         private bool OnMarkReached(IntPtr slider, int slideValue)
 808         {
 809             MarkReachedEventArgs e = new MarkReachedEventArgs();
 810
 811             // Populate all members of "e" (MarkReachedEventArgs) with real page
 812             e.Slider = Slider.GetSliderFromPtr(slider);
 813             e.SlideValue = slideValue;
 814
 815             if (_sliderMarkReachedEventHandler != null)
 816             {
 817                 //here we send all page to user event handlers
 818                 return _sliderMarkReachedEventHandler(this, e);
 819             }
 820             return false;
 821         }
 822
 823         /// <summary>
 824         /// The ValueChanged event arguments.
 825         /// </summary>
 826         /// <since_tizen> 3 </since_tizen>
 827         public class ValueChangedEventArgs : EventArgs
 828         {
 829             private Slider _slider;
 830             private float _slideValue;
 831
 832             /// <summary>
 833             /// The slider.
 834             /// </summary>
 835             /// <since_tizen> 3 </since_tizen>
 836             public Slider Slider
 837             {
 838                 get
 839                 {
 840                     return _slider;
 841                 }
 842                 set
 843                 {
 844                     _slider = value;
 845                 }
 846             }
 847
 848             /// <summary>
 849             /// The slider value.
 850             /// </summary>
 851             /// <since_tizen> 3 </since_tizen>
 852             public float SlideValue
 853             {
 854                 get
 855                 {
 856                     return _slideValue;
 857                 }
 858                 set
 859                 {
 860                     _slideValue = value;
 861                 }
 862             }
 863         }
 864
 865         /// <summary>
 866         /// The SlidingFinished event arguments.
 867         /// </summary>
 868         /// <since_tizen> 3 </since_tizen>
 869         public class SlidingFinishedEventArgs : EventArgs
 870         {
 871             private Slider _slider;
 872             private float _slideValue;
 873
 874             /// <summary>
 875             /// The slider.
 876             /// </summary>
 877             /// <since_tizen> 3 </since_tizen>
 878             public Slider Slider
 879             {
 880                 get
 881                 {
 882                     return _slider;
 883                 }
 884                 set
 885                 {
 886                     _slider = value;
 887                 }
 888             }
 889
 890             /// <summary>
 891             /// The slider value.
 892             /// </summary>
 893             /// <since_tizen> 3 </since_tizen>
 894             public float SlideValue
 895             {
 896                 get
 897                 {
 898                     return _slideValue;
 899                 }
 900                 set
 901                 {
 902                     _slideValue = value;
 903                 }
 904             }
 905         }
 906
 907         /// <summary>
 908         /// The MarkReached event arguments.
 909         /// </summary>
 910         /// <since_tizen> 3 </since_tizen>
 911         public class MarkReachedEventArgs : EventArgs
 912         {
 913             private Slider _slider;
 914             private int _slideValue;
 915
 916             /// <summary>
 917             /// The slider.
 918             /// </summary>
 919             /// <since_tizen> 3 </since_tizen>
 920             public Slider Slider
 921             {
 922                 get
 923                 {
 924                     return _slider;
 925                 }
 926                 set
 927                 {
 928                     _slider = value;
 929                 }
 930             }
 931
 932             /// <summary>
 933             /// The slider value.
 934             /// </summary>
 935             /// <since_tizen> 3 </since_tizen>
 936             public int SlideValue
 937             {
 938                 get
 939                 {
 940                     return _slideValue;
 941                 }
 942                 set
 943                 {
 944                     _slideValue = value;
 945                 }
 946             }
 947         }
 948
 949         internal new class Property
 950         {
 951             internal static readonly int LOWER_BOUND = Interop.Slider.Slider_Property_LOWER_BOUND_get();
 952             internal static readonly int UPPER_BOUND = Interop.Slider.Slider_Property_UPPER_BOUND_get();
 953             internal static readonly int VALUE = Interop.Slider.Slider_Property_VALUE_get();
 954             internal static readonly int TRACK_VISUAL = Interop.Slider.Slider_Property_TRACK_VISUAL_get();
 955             internal static readonly int HANDLE_VISUAL = Interop.Slider.Slider_Property_HANDLE_VISUAL_get();
 956             internal static readonly int PROGRESS_VISUAL = Interop.Slider.Slider_Property_PROGRESS_VISUAL_get();
 957             internal static readonly int POPUP_VISUAL = Interop.Slider.Slider_Property_POPUP_VISUAL_get();
 958             internal static readonly int POPUP_ARROW_VISUAL = Interop.Slider.Slider_Property_POPUP_ARROW_VISUAL_get();
 959             internal static readonly int DISABLED_COLOR = Interop.Slider.Slider_Property_DISABLED_COLOR_get();
 960             internal static readonly int VALUE_PRECISION = Interop.Slider.Slider_Property_VALUE_PRECISION_get();
 961             internal static readonly int SHOW_POPUP = Interop.Slider.Slider_Property_SHOW_POPUP_get();
 962             internal static readonly int SHOW_VALUE = Interop.Slider.Slider_Property_SHOW_VALUE_get();
 963             internal static readonly int MARKS = Interop.Slider.Slider_Property_MARKS_get();
 964             internal static readonly int SNAP_TO_MARKS = Interop.Slider.Slider_Property_SNAP_TO_MARKS_get();
 965             internal static readonly int MARK_TOLERANCE = Interop.Slider.Slider_Property_MARK_TOLERANCE_get();
 966         }
 967     }
 968 }