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
 290         internal Slider(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Slider_SWIGUpcast(cPtr), cMemoryOwn)
 291         {
 292             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 293         }
 294
 295         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Slider obj)
 296         {
 297             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 298         }
 299
 300         /// <summary>
 301         /// Dispose.
 302         /// </summary>
 303         /// <since_tizen> 3 </since_tizen>
 304         protected override void Dispose(DisposeTypes type)
 305         {
 306             if (disposed)
 307             {
 308                 return;
 309             }
 310
 311             if (type == DisposeTypes.Explicit)
 312             {
 313                 //Called by User
 314                 //Release your own managed resources here.
 315                 //You should release all of your own disposable objects here.
 316
 317             }
 318
 319             //Release your own unmanaged resources here.
 320             //You should not access any managed member here except static instance.
 321             //because the execution order of Finalizes is non-deterministic.
 322             if (this != null)
 323             {
 324                 if (_sliderValueChangedCallbackDelegate != null)
 325                 {
 326                     ValueChangedSignal().Disconnect(_sliderValueChangedCallbackDelegate);
 327                 }
 328
 329                 if (_sliderSlidingFinishedCallbackDelegate != null)
 330                 {
 331                     SlidingFinishedSignal().Disconnect(_sliderSlidingFinishedCallbackDelegate);
 332                 }
 333
 334                 if (_sliderMarkReachedCallbackDelegate != null)
 335                 {
 336                     MarkReachedSignal().Disconnect(_sliderMarkReachedCallbackDelegate);
 337                 }
 338             }
 339
 340             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 341             {
 342                 if (swigCMemOwn)
 343                 {
 344                     swigCMemOwn = false;
 345                     NDalicPINVOKE.delete_Slider(swigCPtr);
 346                 }
 347                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 348             }
 349
 350             base.Dispose(type);
 351         }
 352
 353         /// <summary>
 354         /// The ValueChanged event arguments.
 355         /// </summary>
 356         /// <since_tizen> 3 </since_tizen>
 357         public class ValueChangedEventArgs : EventArgs
 358         {
 359             private Slider _slider;
 360             private float _slideValue;
 361
 362             /// <summary>
 363             /// The slider.
 364             /// </summary>
 365             /// <since_tizen> 3 </since_tizen>
 366             public Slider Slider
 367             {
 368                 get
 369                 {
 370                     return _slider;
 371                 }
 372                 set
 373                 {
 374                     _slider = value;
 375                 }
 376             }
 377
 378             /// <summary>
 379             /// The slider value.
 380             /// </summary>
 381             /// <since_tizen> 3 </since_tizen>
 382             public float SlideValue
 383             {
 384                 get
 385                 {
 386                     return _slideValue;
 387                 }
 388                 set
 389                 {
 390                     _slideValue = value;
 391                 }
 392             }
 393         }
 394
 395         /// <summary>
 396         /// The SlidingFinished event arguments.
 397         /// </summary>
 398         /// <since_tizen> 3 </since_tizen>
 399         public class SlidingFinishedEventArgs : EventArgs
 400         {
 401             private Slider _slider;
 402             private float _slideValue;
 403
 404             /// <summary>
 405             /// The slider.
 406             /// </summary>
 407             /// <since_tizen> 3 </since_tizen>
 408             public Slider Slider
 409             {
 410                 get
 411                 {
 412                     return _slider;
 413                 }
 414                 set
 415                 {
 416                     _slider = value;
 417                 }
 418             }
 419
 420             /// <summary>
 421             /// The slider value.
 422             /// </summary>
 423             /// <since_tizen> 3 </since_tizen>
 424             public float SlideValue
 425             {
 426                 get
 427                 {
 428                     return _slideValue;
 429                 }
 430                 set
 431                 {
 432                     _slideValue = value;
 433                 }
 434             }
 435         }
 436
 437         /// <summary>
 438         /// The MarkReached event arguments.
 439         /// </summary>
 440         /// <since_tizen> 3 </since_tizen>
 441         public class MarkReachedEventArgs : EventArgs
 442         {
 443             private Slider _slider;
 444             private int _slideValue;
 445
 446             /// <summary>
 447             /// The slider.
 448             /// </summary>
 449             /// <since_tizen> 3 </since_tizen>
 450             public Slider Slider
 451             {
 452                 get
 453                 {
 454                     return _slider;
 455                 }
 456                 set
 457                 {
 458                     _slider = value;
 459                 }
 460             }
 461
 462             /// <summary>
 463             /// The slider value.
 464             /// </summary>
 465             /// <since_tizen> 3 </since_tizen>
 466             public int SlideValue
 467             {
 468                 get
 469                 {
 470                     return _slideValue;
 471                 }
 472                 set
 473                 {
 474                     _slideValue = value;
 475                 }
 476             }
 477         }
 478
 479
 480         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 481         private delegate bool ValueChangedCallbackDelegate(IntPtr slider, float slideValue);
 482         private EventHandlerWithReturnType<object, ValueChangedEventArgs, bool> _sliderValueChangedEventHandler;
 483         private ValueChangedCallbackDelegate _sliderValueChangedCallbackDelegate;
 484
 485         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 486         private delegate bool SlidingFinishedCallbackDelegate(IntPtr slider, float slideValue);
 487         private EventHandlerWithReturnType<object, SlidingFinishedEventArgs, bool> _sliderSlidingFinishedEventHandler;
 488         private SlidingFinishedCallbackDelegate _sliderSlidingFinishedCallbackDelegate;
 489
 490         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 491         private delegate bool MarkReachedCallbackDelegate(IntPtr slider, int slideValue);
 492         private EventHandlerWithReturnType<object, MarkReachedEventArgs, bool> _sliderMarkReachedEventHandler;
 493         private MarkReachedCallbackDelegate _sliderMarkReachedCallbackDelegate;
 494
 495         /// <summary>
 496         /// An event emitted when the slider value changes.
 497         /// </summary>
 498         /// <since_tizen> 3 </since_tizen>
 499         public event EventHandlerWithReturnType<object, ValueChangedEventArgs, bool> ValueChanged
 500         {
 501             add
 502             {
 503                 if (_sliderValueChangedEventHandler == null)
 504                 {
 505                     _sliderValueChangedCallbackDelegate = (OnValueChanged);
 506                     ValueChangedSignal().Connect(_sliderValueChangedCallbackDelegate);
 507                 }
 508                 _sliderValueChangedEventHandler += value;
 509             }
 510             remove
 511             {
 512                 _sliderValueChangedEventHandler -= value;
 513                 if (_sliderValueChangedEventHandler == null && ValueChangedSignal().Empty() == false)
 514                 {
 515                     ValueChangedSignal().Disconnect(_sliderValueChangedCallbackDelegate);
 516                 }
 517             }
 518         }
 519
 520         // Callback for Slider ValueChanged signal
 521         private bool OnValueChanged(IntPtr slider, float slideValue)
 522         {
 523             ValueChangedEventArgs e = new ValueChangedEventArgs();
 524
 525             // Populate all members of "e" (ValueChangedEventArgs) with real page
 526             e.Slider = Slider.GetSliderFromPtr(slider);
 527             e.SlideValue = slideValue;
 528
 529             if (_sliderValueChangedEventHandler != null)
 530             {
 531                 //here we send all page to user event handlers
 532                 return _sliderValueChangedEventHandler(this, e);
 533             }
 534             return false;
 535         }
 536
 537         /// <summary>
 538         /// An event emitted when the sliding is finished.
 539         /// </summary>
 540         /// <since_tizen> 3 </since_tizen>
 541         public event EventHandlerWithReturnType<object, SlidingFinishedEventArgs, bool> SlidingFinished
 542         {
 543             add
 544             {
 545                 if (_sliderSlidingFinishedEventHandler == null)
 546                 {
 547                     _sliderSlidingFinishedCallbackDelegate = (OnSlidingFinished);
 548                     SlidingFinishedSignal().Connect(_sliderSlidingFinishedCallbackDelegate);
 549                 }
 550                 _sliderSlidingFinishedEventHandler += value;
 551             }
 552             remove
 553             {
 554                 _sliderSlidingFinishedEventHandler -= value;
 555                 if (_sliderSlidingFinishedEventHandler == null && SlidingFinishedSignal().Empty() == false)
 556                 {
 557                     SlidingFinishedSignal().Disconnect(_sliderSlidingFinishedCallbackDelegate);
 558                 }
 559             }
 560         }
 561
 562         // Callback for Slider SlidingFinished signal
 563         private bool OnSlidingFinished(IntPtr slider, float slideValue)
 564         {
 565             SlidingFinishedEventArgs e = new SlidingFinishedEventArgs();
 566
 567             // Populate all members of "e" (SlidingFinishedEventArgs) with real page
 568             e.Slider = Slider.GetSliderFromPtr(slider);
 569             e.SlideValue = slideValue;
 570
 571             if (_sliderSlidingFinishedEventHandler != null)
 572             {
 573                 //here we send all page to user event handlers
 574                 return _sliderSlidingFinishedEventHandler(this, e);
 575             }
 576             return false;
 577         }
 578
 579         /// <summary>
 580         /// An event emitted when the slider handle reaches a mark.
 581         /// </summary>
 582         /// <since_tizen> 3 </since_tizen>
 583         public event EventHandlerWithReturnType<object, MarkReachedEventArgs, bool> MarkReached
 584         {
 585             add
 586             {
 587                 if (_sliderMarkReachedEventHandler == null)
 588                 {
 589                     _sliderMarkReachedCallbackDelegate = (OnMarkReached);
 590                     MarkReachedSignal().Connect(_sliderMarkReachedCallbackDelegate);
 591                 }
 592                 _sliderMarkReachedEventHandler += value;
 593             }
 594             remove
 595             {
 596                 _sliderMarkReachedEventHandler -= value;
 597                 if (_sliderMarkReachedEventHandler == null && MarkReachedSignal().Empty() == false)
 598                 {
 599                     MarkReachedSignal().Disconnect(_sliderMarkReachedCallbackDelegate);
 600                 }
 601             }
 602         }
 603
 604         // Callback for Slider MarkReached signal
 605         private bool OnMarkReached(IntPtr slider, int slideValue)
 606         {
 607             MarkReachedEventArgs e = new MarkReachedEventArgs();
 608
 609             // Populate all members of "e" (MarkReachedEventArgs) with real page
 610             e.Slider = Slider.GetSliderFromPtr(slider);
 611             e.SlideValue = slideValue;
 612
 613             if (_sliderMarkReachedEventHandler != null)
 614             {
 615                 //here we send all page to user event handlers
 616                 return _sliderMarkReachedEventHandler(this, e);
 617             }
 618             return false;
 619         }
 620
 621         /// <summary>
 622         /// Gets the slider from the pointer.
 623         /// </summary>
 624         /// <param name="cPtr">The pointer of the slider.</param>
 625         /// <returns>The object of the slider type.</returns>
 626         internal static Slider GetSliderFromPtr(global::System.IntPtr cPtr)
 627         {
 628             Slider ret = new Slider(cPtr, false);
 629             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 630             return ret;
 631         }
 632
 633         internal new class Property : global::System.IDisposable
 634         {
 635             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 636             protected bool swigCMemOwn;
 637
 638             internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)
 639             {
 640                 swigCMemOwn = cMemoryOwn;
 641                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 642             }
 643
 644             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)
 645             {
 646                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 647             }
 648
 649             //A Flag to check who called Dispose(). (By User or DisposeQueue)
 650             private bool isDisposeQueued = false;
 651             //A Flat to check if it is already disposed.
 652             protected bool disposed = false;
 653
 654             ~Property()
 655             {
 656                 if (!isDisposeQueued)
 657                 {
 658                     isDisposeQueued = true;
 659                     DisposeQueue.Instance.Add(this);
 660                 }
 661             }
 662
 663             /// <since_tizen> 3 </since_tizen>
 664             public void Dispose()
 665             {
 666                 //Throw excpetion if Dispose() is called in separate thread.
 667                 if (!Window.IsInstalled())
 668                 {
 669                     throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
 670                 }
 671
 672                 if (isDisposeQueued)
 673                 {
 674                     Dispose(DisposeTypes.Implicit);
 675                 }
 676                 else
 677                 {
 678                     Dispose(DisposeTypes.Explicit);
 679                     System.GC.SuppressFinalize(this);
 680                 }
 681             }
 682
 683             protected virtual void Dispose(DisposeTypes type)
 684             {
 685                 if (disposed)
 686                 {
 687                     return;
 688                 }
 689
 690                 if (type == DisposeTypes.Explicit)
 691                 {
 692                     //Called by User
 693                     //Release your own managed resources here.
 694                     //You should release all of your own disposable objects here.
 695
 696                 }
 697
 698                 //Release your own unmanaged resources here.
 699                 //You should not access any managed member here except static instance.
 700                 //because the execution order of Finalizes is non-deterministic.
 701
 702                 if (swigCPtr.Handle != global::System.IntPtr.Zero)
 703                 {
 704                     if (swigCMemOwn)
 705                     {
 706                         swigCMemOwn = false;
 707                         NDalicPINVOKE.delete_Slider_Property(swigCPtr);
 708                     }
 709                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 710                 }
 711
 712                 disposed = true;
 713             }
 714
 715             internal Property() : this(NDalicPINVOKE.new_Slider_Property(), true)
 716             {
 717                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 718             }
 719
 720             internal static readonly int LOWER_BOUND = NDalicPINVOKE.Slider_Property_LOWER_BOUND_get();
 721             internal static readonly int UPPER_BOUND = NDalicPINVOKE.Slider_Property_UPPER_BOUND_get();
 722             internal static readonly int VALUE = NDalicPINVOKE.Slider_Property_VALUE_get();
 723             internal static readonly int TRACK_VISUAL = NDalicPINVOKE.Slider_Property_TRACK_VISUAL_get();
 724             internal static readonly int HANDLE_VISUAL = NDalicPINVOKE.Slider_Property_HANDLE_VISUAL_get();
 725             internal static readonly int PROGRESS_VISUAL = NDalicPINVOKE.Slider_Property_PROGRESS_VISUAL_get();
 726             internal static readonly int POPUP_VISUAL = NDalicPINVOKE.Slider_Property_POPUP_VISUAL_get();
 727             internal static readonly int POPUP_ARROW_VISUAL = NDalicPINVOKE.Slider_Property_POPUP_ARROW_VISUAL_get();
 728             internal static readonly int DISABLED_COLOR = NDalicPINVOKE.Slider_Property_DISABLED_COLOR_get();
 729             internal static readonly int VALUE_PRECISION = NDalicPINVOKE.Slider_Property_VALUE_PRECISION_get();
 730             internal static readonly int SHOW_POPUP = NDalicPINVOKE.Slider_Property_SHOW_POPUP_get();
 731             internal static readonly int SHOW_VALUE = NDalicPINVOKE.Slider_Property_SHOW_VALUE_get();
 732             internal static readonly int MARKS = NDalicPINVOKE.Slider_Property_MARKS_get();
 733             internal static readonly int SNAP_TO_MARKS = NDalicPINVOKE.Slider_Property_SNAP_TO_MARKS_get();
 734             internal static readonly int MARK_TOLERANCE = NDalicPINVOKE.Slider_Property_MARK_TOLERANCE_get();
 735
 736         }
 737
 738         /// <summary>
 739         /// Creates the slider control.
 740         /// </summary>
 741         /// <since_tizen> 3 </since_tizen>
 742         public Slider() : this(NDalicPINVOKE.Slider_New(), true)
 743         {
 744             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 745         }
 746
 747         internal override bool IsCreateByXaml
 748         {
 749             get
 750             {
 751                 return base.IsCreateByXaml;
 752             }
 753             set
 754             {
 755                 base.IsCreateByXaml = value;
 756
 757                 if (value == true)
 758                 {
 759                     this.ValueChanged += (obj, e) => {
 760                         this.Value = e.SlideValue;
 761                         return true;
 762                     };
 763                 }
 764             }
 765         }
 766
 767         internal Slider(Slider handle) : this(NDalicPINVOKE.new_Slider__SWIG_1(Slider.getCPtr(handle)), true)
 768         {
 769             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 770         }
 771
 772         internal Slider Assign(Slider handle)
 773         {
 774             Slider ret = new Slider(NDalicPINVOKE.Slider_Assign(swigCPtr, Slider.getCPtr(handle)), false);
 775             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 776             return ret;
 777         }
 778
 779         /// <summary>
 780         /// Downcasts an object handle to the slider.<br />
 781         /// If the handle points to a slider, then the downcast produces a valid handle.<br />
 782         /// If not, then the returned handle is left uninitialized.<br />
 783         /// </summary>
 784         /// <param name="handle">The handle to an object.</param>
 785         /// <returns>The handle to a slider or an uninitialized handle.</returns>
 786         /// <since_tizen> 3 </since_tizen>
 787         public static Slider DownCast(BaseHandle handle)
 788         {
 789             Slider ret =  Registry.GetManagedBaseHandleFromNativePtr(handle) as Slider;
 790             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 791             return ret;
 792         }
 793
 794         internal SliderValueChangedSignal ValueChangedSignal()
 795         {
 796             SliderValueChangedSignal ret = new SliderValueChangedSignal(NDalicPINVOKE.Slider_ValueChangedSignal(swigCPtr), false);
 797             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 798             return ret;
 799         }
 800
 801         internal SliderValueChangedSignal SlidingFinishedSignal()
 802         {
 803             SliderValueChangedSignal ret = new SliderValueChangedSignal(NDalicPINVOKE.Slider_SlidingFinishedSignal(swigCPtr), false);
 804             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 805             return ret;
 806         }
 807
 808         internal SliderMarkReachedSignal MarkReachedSignal()
 809         {
 810             SliderMarkReachedSignal ret = new SliderMarkReachedSignal(NDalicPINVOKE.Slider_MarkReachedSignal(swigCPtr), false);
 811             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 812             return ret;
 813         }
 814
 815         /// <summary>
 816         /// The lower bound property.
 817         /// </summary>
 818         /// <since_tizen> 3 </since_tizen>
 819         public float LowerBound
 820         {
 821             get
 822             {
 823                 return (float)GetValue(LowerBoundProperty);
 824             }
 825             set
 826             {
 827                 SetValue(LowerBoundProperty, value);
 828             }
 829         }
 830
 831         /// <summary>
 832         /// The upper bound property.
 833         /// </summary>
 834         /// <since_tizen> 3 </since_tizen>
 835         public float UpperBound
 836         {
 837             get
 838             {
 839                 return (float)GetValue(UpperBoundProperty);
 840             }
 841             set
 842             {
 843                 SetValue(UpperBoundProperty, value);
 844             }
 845         }
 846
 847         /// <summary>
 848         /// The value property.
 849         /// </summary>
 850         /// <since_tizen> 3 </since_tizen>
 851         public float Value
 852         {
 853             get
 854             {
 855                 return (float)GetValue(ValueProperty);
 856             }
 857             set
 858             {
 859                 SetValueAndForceSendChangeSignal(ValueProperty, value);
 860             }
 861         }
 862
 863         /// <summary>
 864         /// The track visual property.
 865         /// </summary>
 866         /// <since_tizen> 3 </since_tizen>
 867         public PropertyMap TrackVisual
 868         {
 869             get
 870             {
 871                 return (PropertyMap)GetValue(TrackVisualProperty);
 872             }
 873             set
 874             {
 875                 SetValue(TrackVisualProperty, value);
 876             }
 877         }
 878
 879         /// <summary>
 880         /// The handle visual property.
 881         /// </summary>
 882         /// <since_tizen> 3 </since_tizen>
 883         public PropertyMap HandleVisual
 884         {
 885             get
 886             {
 887                 return (PropertyMap)GetValue(HandleVisualProperty);
 888             }
 889             set
 890             {
 891                 SetValue(HandleVisualProperty, value);
 892             }
 893         }
 894
 895         /// <summary>
 896         /// The progress visual property.
 897         /// </summary>
 898         /// <since_tizen> 3 </since_tizen>
 899         public PropertyMap ProgressVisual
 900         {
 901             get
 902             {
 903                 return (PropertyMap)GetValue(ProgressVisualProperty);
 904             }
 905             set
 906             {
 907                 SetValue(ProgressVisualProperty, value);
 908             }
 909         }
 910
 911         /// <summary>
 912         /// The popup visual property.
 913         /// </summary>
 914         /// <since_tizen> 3 </since_tizen>
 915         public PropertyMap PopupVisual
 916         {
 917             get
 918             {
 919                 return (PropertyMap)GetValue(PopupVisualProperty);
 920             }
 921             set
 922             {
 923                 SetValue(PopupVisualProperty, value);
 924             }
 925         }
 926
 927         /// <summary>
 928         /// The popup arrow visual property.
 929         /// </summary>
 930         /// <since_tizen> 3 </since_tizen>
 931         public PropertyMap PopupArrowVisual
 932         {
 933             get
 934             {
 935                 return (PropertyMap)GetValue(PopupArrowVisualProperty);
 936             }
 937             set
 938             {
 939                 SetValue(PopupArrowVisualProperty, value);
 940             }
 941         }
 942
 943         /// <summary>
 944         /// The disable color property.
 945         /// </summary>
 946         /// <since_tizen> 3 </since_tizen>
 947         public Vector4 DisabledColor
 948         {
 949             get
 950             {
 951                 return (Vector4)GetValue(DisabledColorProperty);
 952             }
 953             set
 954             {
 955                 SetValue(DisabledColorProperty, value);
 956             }
 957         }
 958
 959         /// <summary>
 960         /// The value precision property.
 961         /// </summary>
 962         /// <since_tizen> 3 </since_tizen>
 963         public int ValuePrecision
 964         {
 965             get
 966             {
 967                 return (int)GetValue(ValuePrecisionProperty);
 968             }
 969             set
 970             {
 971                 SetValue(ValuePrecisionProperty, value);
 972             }
 973         }
 974
 975         /// <summary>
 976         /// The show popup property.
 977         /// </summary>
 978         /// <since_tizen> 3 </since_tizen>
 979         public bool ShowPopup
 980         {
 981             get
 982             {
 983                 return (bool)GetValue(ShowPopupProperty);
 984             }
 985             set
 986             {
 987                 SetValue(ShowPopupProperty, value);
 988             }
 989         }
 990
 991         /// <summary>
 992         /// The show value property.
 993         /// </summary>
 994         /// <since_tizen> 3 </since_tizen>
 995         public bool ShowValue
 996         {
 997             get
 998             {
 999                 return (bool)GetValue(ShowValueProperty);
1000             }
1001             set
1002             {
1003                 SetValue(ShowValueProperty, value);
1004             }
1005         }
1006
1007         /// <summary>
1008         /// The marks property.
1009         /// </summary>
1010         /// <since_tizen> 3 </since_tizen>
1011         public Tizen.NUI.PropertyArray Marks
1012         {
1013             get
1014             {
1015                 return (PropertyArray)GetValue(MarksProperty);
1016             }
1017             set
1018             {
1019                 SetValue(MarksProperty, value);
1020             }
1021         }
1022
1023         /// <summary>
1024         /// The snap to marks property.
1025         /// </summary>
1026         /// <since_tizen> 3 </since_tizen>
1027         public bool SnapToMarks
1028         {
1029             get
1030             {
1031                 return (bool)GetValue(SnapToMarksProperty);
1032             }
1033             set
1034             {
1035                 SetValue(SnapToMarksProperty, value);
1036             }
1037         }
1038
1039         /// <summary>
1040         /// The mark tolerance property.
1041         /// </summary>
1042         /// <since_tizen> 3 </since_tizen>
1043         public float MarkTolerance
1044         {
1045             get
1046             {
1047                 return (float)GetValue(MarkToleranceProperty);
1048             }
1049             set
1050             {
1051                 SetValue(MarkToleranceProperty, value);
1052             }
1053         }
1054
1055     }
1056
1057 }