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 = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as Slider;
 687             if (null == ret)
 688             {
 689                 ret = Registry.GetManagedBaseHandleFromRefObject(cPtr) as Slider;
 690             }
 691
 692             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 693             return ret;
 694         }
 695
 696         internal Slider Assign(Slider handle)
 697         {
 698             Slider ret = new Slider(Interop.Slider.Slider_Assign(swigCPtr, Slider.getCPtr(handle)), false);
 699             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 700             return ret;
 701         }
 702
 703         internal SliderValueChangedSignal ValueChangedSignal()
 704         {
 705             SliderValueChangedSignal ret = new SliderValueChangedSignal(Interop.Slider.Slider_ValueChangedSignal(swigCPtr), false);
 706             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 707             return ret;
 708         }
 709
 710         internal SliderValueChangedSignal SlidingFinishedSignal()
 711         {
 712             SliderValueChangedSignal ret = new SliderValueChangedSignal(Interop.Slider.Slider_SlidingFinishedSignal(swigCPtr), false);
 713             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 714             return ret;
 715         }
 716
 717         internal SliderMarkReachedSignal MarkReachedSignal()
 718         {
 719             SliderMarkReachedSignal ret = new SliderMarkReachedSignal(Interop.Slider.Slider_MarkReachedSignal(swigCPtr), false);
 720             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 721             return ret;
 722         }
 723
 724         /// <summary>
 725         /// Dispose.
 726         /// </summary>
 727         /// <since_tizen> 3 </since_tizen>
 728         protected override void Dispose(DisposeTypes type)
 729         {
 730             if (disposed)
 731             {
 732                 return;
 733             }
 734
 735             if (type == DisposeTypes.Explicit)
 736             {
 737                 //Called by User
 738                 //Release your own managed resources here.
 739                 //You should release all of your own disposable objects here.
 740
 741             }
 742
 743             //Release your own unmanaged resources here.
 744             //You should not access any managed member here except static instance.
 745             //because the execution order of Finalizes is non-deterministic.
 746             if (this != null)
 747             {
 748                 if (_sliderValueChangedCallbackDelegate != null)
 749                 {
 750                     ValueChangedSignal().Disconnect(_sliderValueChangedCallbackDelegate);
 751                 }
 752
 753                 if (_sliderSlidingFinishedCallbackDelegate != null)
 754                 {
 755                     SlidingFinishedSignal().Disconnect(_sliderSlidingFinishedCallbackDelegate);
 756                 }
 757
 758                 if (_sliderMarkReachedCallbackDelegate != null)
 759                 {
 760                     MarkReachedSignal().Disconnect(_sliderMarkReachedCallbackDelegate);
 761                 }
 762             }
 763
 764             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 765             {
 766                 if (swigCMemOwn)
 767                 {
 768                     swigCMemOwn = false;
 769                     Interop.Slider.delete_Slider(swigCPtr);
 770                 }
 771                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 772             }
 773
 774             base.Dispose(type);
 775         }
 776
 777         // Callback for Slider ValueChanged signal
 778         private bool OnValueChanged(IntPtr slider, float slideValue)
 779         {
 780             ValueChangedEventArgs e = new ValueChangedEventArgs();
 781
 782             // Populate all members of "e" (ValueChangedEventArgs) with real page
 783             e.Slider = Slider.GetSliderFromPtr(slider);
 784             e.SlideValue = slideValue;
 785
 786             if (_sliderValueChangedEventHandler != null)
 787             {
 788                 //here we send all page to user event handlers
 789                 return _sliderValueChangedEventHandler(this, e);
 790             }
 791             return false;
 792         }
 793
 794         // Callback for Slider SlidingFinished signal
 795         private bool OnSlidingFinished(IntPtr slider, float slideValue)
 796         {
 797             SlidingFinishedEventArgs e = new SlidingFinishedEventArgs();
 798
 799             // Populate all members of "e" (SlidingFinishedEventArgs) with real page
 800             e.Slider = Slider.GetSliderFromPtr(slider);
 801             e.SlideValue = slideValue;
 802
 803             if (_sliderSlidingFinishedEventHandler != null)
 804             {
 805                 //here we send all page to user event handlers
 806                 return _sliderSlidingFinishedEventHandler(this, e);
 807             }
 808             return false;
 809         }
 810
 811         // Callback for Slider MarkReached signal
 812         private bool OnMarkReached(IntPtr slider, int slideValue)
 813         {
 814             MarkReachedEventArgs e = new MarkReachedEventArgs();
 815
 816             // Populate all members of "e" (MarkReachedEventArgs) with real page
 817             e.Slider = Slider.GetSliderFromPtr(slider);
 818             e.SlideValue = slideValue;
 819
 820             if (_sliderMarkReachedEventHandler != null)
 821             {
 822                 //here we send all page to user event handlers
 823                 return _sliderMarkReachedEventHandler(this, e);
 824             }
 825             return false;
 826         }
 827
 828         /// <summary>
 829         /// The ValueChanged event arguments.
 830         /// </summary>
 831         /// <since_tizen> 3 </since_tizen>
 832         public class ValueChangedEventArgs : EventArgs
 833         {
 834             private Slider _slider;
 835             private float _slideValue;
 836
 837             /// <summary>
 838             /// The slider.
 839             /// </summary>
 840             /// <since_tizen> 3 </since_tizen>
 841             public Slider Slider
 842             {
 843                 get
 844                 {
 845                     return _slider;
 846                 }
 847                 set
 848                 {
 849                     _slider = value;
 850                 }
 851             }
 852
 853             /// <summary>
 854             /// The slider value.
 855             /// </summary>
 856             /// <since_tizen> 3 </since_tizen>
 857             public float SlideValue
 858             {
 859                 get
 860                 {
 861                     return _slideValue;
 862                 }
 863                 set
 864                 {
 865                     _slideValue = value;
 866                 }
 867             }
 868         }
 869
 870         /// <summary>
 871         /// The SlidingFinished event arguments.
 872         /// </summary>
 873         /// <since_tizen> 3 </since_tizen>
 874         public class SlidingFinishedEventArgs : EventArgs
 875         {
 876             private Slider _slider;
 877             private float _slideValue;
 878
 879             /// <summary>
 880             /// The slider.
 881             /// </summary>
 882             /// <since_tizen> 3 </since_tizen>
 883             public Slider Slider
 884             {
 885                 get
 886                 {
 887                     return _slider;
 888                 }
 889                 set
 890                 {
 891                     _slider = value;
 892                 }
 893             }
 894
 895             /// <summary>
 896             /// The slider value.
 897             /// </summary>
 898             /// <since_tizen> 3 </since_tizen>
 899             public float SlideValue
 900             {
 901                 get
 902                 {
 903                     return _slideValue;
 904                 }
 905                 set
 906                 {
 907                     _slideValue = value;
 908                 }
 909             }
 910         }
 911
 912         /// <summary>
 913         /// The MarkReached event arguments.
 914         /// </summary>
 915         /// <since_tizen> 3 </since_tizen>
 916         public class MarkReachedEventArgs : EventArgs
 917         {
 918             private Slider _slider;
 919             private int _slideValue;
 920
 921             /// <summary>
 922             /// The slider.
 923             /// </summary>
 924             /// <since_tizen> 3 </since_tizen>
 925             public Slider Slider
 926             {
 927                 get
 928                 {
 929                     return _slider;
 930                 }
 931                 set
 932                 {
 933                     _slider = value;
 934                 }
 935             }
 936
 937             /// <summary>
 938             /// The slider value.
 939             /// </summary>
 940             /// <since_tizen> 3 </since_tizen>
 941             public int SlideValue
 942             {
 943                 get
 944                 {
 945                     return _slideValue;
 946                 }
 947                 set
 948                 {
 949                     _slideValue = value;
 950                 }
 951             }
 952         }
 953
 954         internal new class Property
 955         {
 956             internal static readonly int LOWER_BOUND = Interop.Slider.Slider_Property_LOWER_BOUND_get();
 957             internal static readonly int UPPER_BOUND = Interop.Slider.Slider_Property_UPPER_BOUND_get();
 958             internal static readonly int VALUE = Interop.Slider.Slider_Property_VALUE_get();
 959             internal static readonly int TRACK_VISUAL = Interop.Slider.Slider_Property_TRACK_VISUAL_get();
 960             internal static readonly int HANDLE_VISUAL = Interop.Slider.Slider_Property_HANDLE_VISUAL_get();
 961             internal static readonly int PROGRESS_VISUAL = Interop.Slider.Slider_Property_PROGRESS_VISUAL_get();
 962             internal static readonly int POPUP_VISUAL = Interop.Slider.Slider_Property_POPUP_VISUAL_get();
 963             internal static readonly int POPUP_ARROW_VISUAL = Interop.Slider.Slider_Property_POPUP_ARROW_VISUAL_get();
 964             internal static readonly int DISABLED_COLOR = Interop.Slider.Slider_Property_DISABLED_COLOR_get();
 965             internal static readonly int VALUE_PRECISION = Interop.Slider.Slider_Property_VALUE_PRECISION_get();
 966             internal static readonly int SHOW_POPUP = Interop.Slider.Slider_Property_SHOW_POPUP_get();
 967             internal static readonly int SHOW_VALUE = Interop.Slider.Slider_Property_SHOW_VALUE_get();
 968             internal static readonly int MARKS = Interop.Slider.Slider_Property_MARKS_get();
 969             internal static readonly int SNAP_TO_MARKS = Interop.Slider.Slider_Property_SNAP_TO_MARKS_get();
 970             internal static readonly int MARK_TOLERANCE = Interop.Slider.Slider_Property_MARK_TOLERANCE_get();
 971         }
 972     }
 973 }