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

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