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             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
 762         internal override bool IsCreateByXaml
 763         {
 764             get
 765             {
 766                 return base.IsCreateByXaml;
 767             }
 768             set
 769             {
 770                 base.IsCreateByXaml = value;
 771
 772                 if (value == true)
 773                 {
 774                     this.ValueChanged += (obj, e) => {
 775                         this.Value = e.SlideValue;
 776                         return true;
 777                     };
 778                 }
 779             }
 780         }
 781
 782         internal Slider(Slider handle) : this(NDalicPINVOKE.new_Slider__SWIG_1(Slider.getCPtr(handle)), true)
 783         {
 784             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 785         }
 786
 787         internal Slider Assign(Slider handle)
 788         {
 789             Slider ret = new Slider(NDalicPINVOKE.Slider_Assign(swigCPtr, Slider.getCPtr(handle)), false);
 790             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 791             return ret;
 792         }
 793
 794         /// <summary>
 795         /// Downcasts an object handle to the slider.<br />
 796         /// If the handle points to a slider, then the downcast produces a valid handle.<br />
 797         /// If not, then the returned handle is left uninitialized.<br />
 798         /// </summary>
 799         /// <param name="handle">The handle to an object.</param>
 800         /// <returns>The handle to a slider or an uninitialized handle.</returns>
 801         /// <since_tizen> 3 </since_tizen>
 802         public static Slider DownCast(BaseHandle handle)
 803         {
 804             Slider ret =  Registry.GetManagedBaseHandleFromNativePtr(handle) as Slider;
 805             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 806             return ret;
 807         }
 808
 809         internal SliderValueChangedSignal ValueChangedSignal()
 810         {
 811             SliderValueChangedSignal ret = new SliderValueChangedSignal(NDalicPINVOKE.Slider_ValueChangedSignal(swigCPtr), false);
 812             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 813             return ret;
 814         }
 815
 816         internal SliderValueChangedSignal SlidingFinishedSignal()
 817         {
 818             SliderValueChangedSignal ret = new SliderValueChangedSignal(NDalicPINVOKE.Slider_SlidingFinishedSignal(swigCPtr), false);
 819             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 820             return ret;
 821         }
 822
 823         internal SliderMarkReachedSignal MarkReachedSignal()
 824         {
 825             SliderMarkReachedSignal ret = new SliderMarkReachedSignal(NDalicPINVOKE.Slider_MarkReachedSignal(swigCPtr), false);
 826             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 827             return ret;
 828         }
 829
 830         /// <summary>
 831         /// The lower bound property.
 832         /// </summary>
 833         /// <since_tizen> 3 </since_tizen>
 834         public float LowerBound
 835         {
 836             get
 837             {
 838                 return (float)GetValue(LowerBoundProperty);
 839             }
 840             set
 841             {
 842                 SetValue(LowerBoundProperty, value);
 843             }
 844         }
 845
 846         /// <summary>
 847         /// The upper bound property.
 848         /// </summary>
 849         /// <since_tizen> 3 </since_tizen>
 850         public float UpperBound
 851         {
 852             get
 853             {
 854                 return (float)GetValue(UpperBoundProperty);
 855             }
 856             set
 857             {
 858                 SetValue(UpperBoundProperty, value);
 859             }
 860         }
 861
 862         /// <summary>
 863         /// The value property.
 864         /// </summary>
 865         /// <since_tizen> 3 </since_tizen>
 866         public float Value
 867         {
 868             get
 869             {
 870                 return (float)GetValue(ValueProperty);
 871             }
 872             set
 873             {
 874                 SetValueAndForceSendChangeSignal(ValueProperty, value);
 875             }
 876         }
 877
 878         /// <summary>
 879         /// The track visual property.
 880         /// </summary>
 881         /// <since_tizen> 3 </since_tizen>
 882         public PropertyMap TrackVisual
 883         {
 884             get
 885             {
 886                 return (PropertyMap)GetValue(TrackVisualProperty);
 887             }
 888             set
 889             {
 890                 SetValue(TrackVisualProperty, value);
 891             }
 892         }
 893
 894         /// <summary>
 895         /// The handle visual property.
 896         /// </summary>
 897         /// <since_tizen> 3 </since_tizen>
 898         public PropertyMap HandleVisual
 899         {
 900             get
 901             {
 902                 return (PropertyMap)GetValue(HandleVisualProperty);
 903             }
 904             set
 905             {
 906                 SetValue(HandleVisualProperty, value);
 907             }
 908         }
 909
 910         /// <summary>
 911         /// The progress visual property.
 912         /// </summary>
 913         /// <since_tizen> 3 </since_tizen>
 914         public PropertyMap ProgressVisual
 915         {
 916             get
 917             {
 918                 return (PropertyMap)GetValue(ProgressVisualProperty);
 919             }
 920             set
 921             {
 922                 SetValue(ProgressVisualProperty, value);
 923             }
 924         }
 925
 926         /// <summary>
 927         /// The popup visual property.
 928         /// </summary>
 929         /// <since_tizen> 3 </since_tizen>
 930         public PropertyMap PopupVisual
 931         {
 932             get
 933             {
 934                 return (PropertyMap)GetValue(PopupVisualProperty);
 935             }
 936             set
 937             {
 938                 SetValue(PopupVisualProperty, value);
 939             }
 940         }
 941
 942         /// <summary>
 943         /// The popup arrow visual property.
 944         /// </summary>
 945         /// <since_tizen> 3 </since_tizen>
 946         public PropertyMap PopupArrowVisual
 947         {
 948             get
 949             {
 950                 return (PropertyMap)GetValue(PopupArrowVisualProperty);
 951             }
 952             set
 953             {
 954                 SetValue(PopupArrowVisualProperty, value);
 955             }
 956         }
 957
 958         /// <summary>
 959         /// The disable color property.
 960         /// </summary>
 961         /// <since_tizen> 3 </since_tizen>
 962         public Vector4 DisabledColor
 963         {
 964             get
 965             {
 966                 return (Vector4)GetValue(DisabledColorProperty);
 967             }
 968             set
 969             {
 970                 SetValue(DisabledColorProperty, value);
 971             }
 972         }
 973
 974         /// <summary>
 975         /// The value precision property.
 976         /// </summary>
 977         /// <since_tizen> 3 </since_tizen>
 978         public int ValuePrecision
 979         {
 980             get
 981             {
 982                 return (int)GetValue(ValuePrecisionProperty);
 983             }
 984             set
 985             {
 986                 SetValue(ValuePrecisionProperty, value);
 987             }
 988         }
 989
 990         /// <summary>
 991         /// The show popup property.
 992         /// </summary>
 993         /// <since_tizen> 3 </since_tizen>
 994         public bool ShowPopup
 995         {
 996             get
 997             {
 998                 return (bool)GetValue(ShowPopupProperty);
 999             }
1000             set
1001             {
1002                 SetValue(ShowPopupProperty, value);
1003             }
1004         }
1005
1006         /// <summary>
1007         /// The show value property.
1008         /// </summary>
1009         /// <since_tizen> 3 </since_tizen>
1010         public bool ShowValue
1011         {
1012             get
1013             {
1014                 return (bool)GetValue(ShowValueProperty);
1015             }
1016             set
1017             {
1018                 SetValue(ShowValueProperty, value);
1019             }
1020         }
1021
1022         /// <summary>
1023         /// The marks property.
1024         /// </summary>
1025         /// <since_tizen> 3 </since_tizen>
1026         public Tizen.NUI.PropertyArray Marks
1027         {
1028             get
1029             {
1030                 return (PropertyArray)GetValue(MarksProperty);
1031             }
1032             set
1033             {
1034                 SetValue(MarksProperty, value);
1035             }
1036         }
1037
1038         /// <summary>
1039         /// The snap to marks property.
1040         /// </summary>
1041         /// <since_tizen> 3 </since_tizen>
1042         public bool SnapToMarks
1043         {
1044             get
1045             {
1046                 return (bool)GetValue(SnapToMarksProperty);
1047             }
1048             set
1049             {
1050                 SetValue(SnapToMarksProperty, value);
1051             }
1052         }
1053
1054         /// <summary>
1055         /// The mark tolerance property.
1056         /// </summary>
1057         /// <since_tizen> 3 </since_tizen>
1058         public float MarkTolerance
1059         {
1060             get
1061             {
1062                 return (float)GetValue(MarkToleranceProperty);
1063             }
1064             set
1065             {
1066                 SetValue(MarkToleranceProperty, value);
1067             }
1068         }
1069
1070     }
1071
1072 }