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