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

   1 /** Copyright (c) 2017 Samsung Electronics Co., Ltd.
   2 *
   3 * Licensed under the Apache License, Version 2.0 (the "License");
   4 * you may not use this file except in compliance with the License.
   5 * You may obtain a copy of the License at
   6 *
   7 * http://www.apache.org/licenses/LICENSE-2.0
   8 *
   9 * Unless required by applicable law or agreed to in writing, software
  10 * distributed under the License is distributed on an "AS IS" BASIS,
  11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 * See the License for the specific language governing permissions and
  13 * limitations under the License.
  14 *
  15 */
  16 // This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts
  17 //------------------------------------------------------------------------------
  18 // <auto-generated />
  19 //
  20 // This file was automatically generated by SWIG (http://www.swig.org).
  21 // Version 3.0.9
  22 //
  23 // Do not make changes to this file unless you know what you are doing--modify
  24 // the SWIG interface file instead.
  25 //------------------------------------------------------------------------------
  26
  27 namespace Tizen.NUI
  28 {
  29
  30     using System;
  31     using System.Runtime.InteropServices;
  32
  33
  34     public class Slider : View
  35     {
  36         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  37
  38         internal Slider(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Slider_SWIGUpcast(cPtr), cMemoryOwn)
  39         {
  40             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  41         }
  42
  43         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Slider obj)
  44         {
  45             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  46         }
  47
  48         ~Slider()
  49         {
  50             DisposeQueue.Instance.Add(this);
  51         }
  52
  53         public override void Dispose()
  54         {
  55             if (!Stage.IsInstalled())
  56             {
  57                 DisposeQueue.Instance.Add(this);
  58                 return;
  59             }
  60
  61             lock (this)
  62             {
  63                 if (swigCPtr.Handle != global::System.IntPtr.Zero)
  64                 {
  65                     if (swigCMemOwn)
  66                     {
  67                         swigCMemOwn = false;
  68                         NDalicPINVOKE.delete_Slider(swigCPtr);
  69                     }
  70                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  71                 }
  72                 global::System.GC.SuppressFinalize(this);
  73                 base.Dispose();
  74             }
  75         }
  76
  77
  78
  79         public class ValueChangedEventArgs : EventArgs
  80         {
  81             private Slider _slider;
  82             private float _slideValue;
  83
  84             public Slider Slider
  85             {
  86                 get
  87                 {
  88                     return _slider;
  89                 }
  90                 set
  91                 {
  92                     _slider = value;
  93                 }
  94             }
  95
  96             public float SlideValue
  97             {
  98                 get
  99                 {
 100                     return _slideValue;
 101                 }
 102                 set
 103                 {
 104                     _slideValue = value;
 105                 }
 106             }
 107         }
 108
 109         public class SlidingFinishedEventArgs : EventArgs
 110         {
 111             private Slider _slider;
 112             private float _slideValue;
 113
 114             public Slider Slider
 115             {
 116                 get
 117                 {
 118                     return _slider;
 119                 }
 120                 set
 121                 {
 122                     _slider = value;
 123                 }
 124             }
 125
 126             public float SlideValue
 127             {
 128                 get
 129                 {
 130                     return _slideValue;
 131                 }
 132                 set
 133                 {
 134                     _slideValue = value;
 135                 }
 136             }
 137         }
 138
 139         public class MarkReachedEventArgs : EventArgs
 140         {
 141             private Slider _slider;
 142             private int _slideValue;
 143
 144             public Slider Slider
 145             {
 146                 get
 147                 {
 148                     return _slider;
 149                 }
 150                 set
 151                 {
 152                     _slider = value;
 153                 }
 154             }
 155
 156             public int SlideValue
 157             {
 158                 get
 159                 {
 160                     return _slideValue;
 161                 }
 162                 set
 163                 {
 164                     _slideValue = value;
 165                 }
 166             }
 167         }
 168
 169
 170         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 171         private delegate bool ValueChangedCallbackDelegate(IntPtr slider, float slideValue);
 172         private EventHandlerWithReturnType<object, ValueChangedEventArgs, bool> _sliderValueChangedEventHandler;
 173         private ValueChangedCallbackDelegate _sliderValueChangedCallbackDelegate;
 174
 175         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 176         private delegate bool SlidingFinishedCallbackDelegate(IntPtr slider, float slideValue);
 177         private EventHandlerWithReturnType<object, SlidingFinishedEventArgs, bool> _sliderSlidingFinishedEventHandler;
 178         private SlidingFinishedCallbackDelegate _sliderSlidingFinishedCallbackDelegate;
 179
 180         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 181         private delegate bool MarkReachedCallbackDelegate(IntPtr slider, int slideValue);
 182         private EventHandlerWithReturnType<object, MarkReachedEventArgs, bool> _sliderMarkReachedEventHandler;
 183         private MarkReachedCallbackDelegate _sliderMarkReachedCallbackDelegate;
 184
 185         public event EventHandlerWithReturnType<object, ValueChangedEventArgs, bool> ValueChanged
 186         {
 187             add
 188             {
 189                 if (_sliderValueChangedEventHandler == null)
 190                 {
 191                     _sliderValueChangedCallbackDelegate = (OnValueChanged);
 192                     ValueChangedSignal().Connect(_sliderValueChangedCallbackDelegate);
 193                 }
 194                 _sliderValueChangedEventHandler += value;
 195             }
 196             remove
 197             {
 198                 _sliderValueChangedEventHandler -= value;
 199                 if (_sliderValueChangedEventHandler == null && _sliderValueChangedCallbackDelegate != null)
 200                 {
 201                     ValueChangedSignal().Disconnect(_sliderValueChangedCallbackDelegate);
 202                 }
 203             }
 204         }
 205
 206         // Callback for Slider ValueChanged signal
 207         private bool OnValueChanged(IntPtr slider, float slideValue)
 208         {
 209             ValueChangedEventArgs e = new ValueChangedEventArgs();
 210
 211             // Populate all members of "e" (ValueChangedEventArgs) with real page
 212             e.Slider = Slider.GetSliderFromPtr(slider);
 213             e.SlideValue = slideValue;
 214
 215             if (_sliderValueChangedEventHandler != null)
 216             {
 217                 //here we send all page to user event handlers
 218                 return _sliderValueChangedEventHandler(this, e);
 219             }
 220             return false;
 221         }
 222
 223         public event EventHandlerWithReturnType<object, SlidingFinishedEventArgs, bool> SlidingFinished
 224         {
 225             add
 226             {
 227                 if (_sliderSlidingFinishedEventHandler == null)
 228                 {
 229                     _sliderSlidingFinishedCallbackDelegate = (OnSlidingFinished);
 230                     SlidingFinishedSignal().Connect(_sliderSlidingFinishedCallbackDelegate);
 231                 }
 232                 _sliderSlidingFinishedEventHandler += value;
 233             }
 234             remove
 235             {
 236                 _sliderSlidingFinishedEventHandler -= value;
 237                 if (_sliderSlidingFinishedEventHandler == null && _sliderSlidingFinishedCallbackDelegate != null)
 238                 {
 239                     SlidingFinishedSignal().Disconnect(_sliderSlidingFinishedCallbackDelegate);
 240                 }
 241             }
 242         }
 243
 244         // Callback for Slider SlidingFinished signal
 245         private bool OnSlidingFinished(IntPtr slider, float slideValue)
 246         {
 247             SlidingFinishedEventArgs e = new SlidingFinishedEventArgs();
 248
 249             // Populate all members of "e" (SlidingFinishedEventArgs) with real page
 250             e.Slider = Slider.GetSliderFromPtr(slider);
 251             e.SlideValue = slideValue;
 252
 253             if (_sliderSlidingFinishedEventHandler != null)
 254             {
 255                 //here we send all page to user event handlers
 256                 return _sliderSlidingFinishedEventHandler(this, e);
 257             }
 258             return false;
 259         }
 260
 261         public event EventHandlerWithReturnType<object, MarkReachedEventArgs, bool> MarkReached
 262         {
 263             add
 264             {
 265                 if (_sliderMarkReachedEventHandler == null)
 266                 {
 267                     _sliderMarkReachedCallbackDelegate = (OnMarkReached);
 268                     MarkReachedSignal().Connect(_sliderMarkReachedCallbackDelegate);
 269                 }
 270                 _sliderMarkReachedEventHandler += value;
 271             }
 272             remove
 273             {
 274                 _sliderMarkReachedEventHandler -= value;
 275                 if (_sliderMarkReachedEventHandler == null && _sliderMarkReachedCallbackDelegate != null)
 276                 {
 277                     MarkReachedSignal().Disconnect(_sliderMarkReachedCallbackDelegate);
 278                 }
 279             }
 280         }
 281
 282         // Callback for Slider MarkReached signal
 283         private bool OnMarkReached(IntPtr slider, int slideValue)
 284         {
 285             MarkReachedEventArgs e = new MarkReachedEventArgs();
 286
 287             // Populate all members of "e" (MarkReachedEventArgs) with real page
 288             e.Slider = Slider.GetSliderFromPtr(slider);
 289             e.SlideValue = slideValue;
 290
 291             if (_sliderMarkReachedEventHandler != null)
 292             {
 293                 //here we send all page to user event handlers
 294                 return _sliderMarkReachedEventHandler(this, e);
 295             }
 296             return false;
 297         }
 298
 299         public static Slider GetSliderFromPtr(global::System.IntPtr cPtr)
 300         {
 301             Slider ret = new Slider(cPtr, false);
 302             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 303             return ret;
 304         }
 305
 306
 307         internal class Property : global::System.IDisposable
 308         {
 309             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 310             protected bool swigCMemOwn;
 311
 312             internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)
 313             {
 314                 swigCMemOwn = cMemoryOwn;
 315                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 316             }
 317
 318             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)
 319             {
 320                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 321             }
 322
 323             ~Property()
 324             {
 325                 Dispose();
 326             }
 327
 328             public virtual void Dispose()
 329             {
 330                 lock (this)
 331                 {
 332                     if (swigCPtr.Handle != global::System.IntPtr.Zero)
 333                     {
 334                         if (swigCMemOwn)
 335                         {
 336                             swigCMemOwn = false;
 337                             NDalicPINVOKE.delete_Slider_Property(swigCPtr);
 338                         }
 339                         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 340                     }
 341                     global::System.GC.SuppressFinalize(this);
 342                 }
 343             }
 344
 345             internal Property() : this(NDalicPINVOKE.new_Slider_Property(), true)
 346             {
 347                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 348             }
 349
 350             internal static readonly int LOWER_BOUND = NDalicPINVOKE.Slider_Property_LOWER_BOUND_get();
 351             internal static readonly int UPPER_BOUND = NDalicPINVOKE.Slider_Property_UPPER_BOUND_get();
 352             internal static readonly int VALUE = NDalicPINVOKE.Slider_Property_VALUE_get();
 353             internal static readonly int TRACK_VISUAL = NDalicPINVOKE.Slider_Property_TRACK_VISUAL_get();
 354             internal static readonly int HANDLE_VISUAL = NDalicPINVOKE.Slider_Property_HANDLE_VISUAL_get();
 355             internal static readonly int PROGRESS_VISUAL = NDalicPINVOKE.Slider_Property_PROGRESS_VISUAL_get();
 356             internal static readonly int POPUP_VISUAL = NDalicPINVOKE.Slider_Property_POPUP_VISUAL_get();
 357             internal static readonly int POPUP_ARROW_VISUAL = NDalicPINVOKE.Slider_Property_POPUP_ARROW_VISUAL_get();
 358             internal static readonly int DISABLED_COLOR = NDalicPINVOKE.Slider_Property_DISABLED_COLOR_get();
 359             internal static readonly int VALUE_PRECISION = NDalicPINVOKE.Slider_Property_VALUE_PRECISION_get();
 360             internal static readonly int SHOW_POPUP = NDalicPINVOKE.Slider_Property_SHOW_POPUP_get();
 361             internal static readonly int SHOW_VALUE = NDalicPINVOKE.Slider_Property_SHOW_VALUE_get();
 362             internal static readonly int MARKS = NDalicPINVOKE.Slider_Property_MARKS_get();
 363             internal static readonly int SNAP_TO_MARKS = NDalicPINVOKE.Slider_Property_SNAP_TO_MARKS_get();
 364             internal static readonly int MARK_TOLERANCE = NDalicPINVOKE.Slider_Property_MARK_TOLERANCE_get();
 365
 366         }
 367
 368         public Slider() : this(NDalicPINVOKE.Slider_New(), true)
 369         {
 370             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 371
 372         }
 373         internal Slider(Slider handle) : this(NDalicPINVOKE.new_Slider__SWIG_1(Slider.getCPtr(handle)), true)
 374         {
 375             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 376         }
 377
 378         internal Slider Assign(Slider handle)
 379         {
 380             Slider ret = new Slider(NDalicPINVOKE.Slider_Assign(swigCPtr, Slider.getCPtr(handle)), false);
 381             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 382             return ret;
 383         }
 384
 385         public new static Slider DownCast(BaseHandle handle)
 386         {
 387             Slider ret = new Slider(NDalicPINVOKE.Slider_DownCast(BaseHandle.getCPtr(handle)), true);
 388             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 389             return ret;
 390         }
 391
 392         internal SliderValueChangedSignal ValueChangedSignal()
 393         {
 394             SliderValueChangedSignal ret = new SliderValueChangedSignal(NDalicPINVOKE.Slider_ValueChangedSignal(swigCPtr), false);
 395             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 396             return ret;
 397         }
 398
 399         internal SliderValueChangedSignal SlidingFinishedSignal()
 400         {
 401             SliderValueChangedSignal ret = new SliderValueChangedSignal(NDalicPINVOKE.Slider_SlidingFinishedSignal(swigCPtr), false);
 402             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 403             return ret;
 404         }
 405
 406         internal SliderMarkReachedSignal MarkReachedSignal()
 407         {
 408             SliderMarkReachedSignal ret = new SliderMarkReachedSignal(NDalicPINVOKE.Slider_MarkReachedSignal(swigCPtr), false);
 409             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 410             return ret;
 411         }
 412
 413         internal enum PropertyRange
 414         {
 415             PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX,
 416             PROPERTY_END_INDEX = View.PropertyRange.PROPERTY_START_INDEX + 1000
 417         }
 418
 419         public float LowerBound
 420         {
 421             get
 422             {
 423                 float temp = 0.0f;
 424                 GetProperty(Slider.Property.LOWER_BOUND).Get(ref temp);
 425                 return temp;
 426             }
 427             set
 428             {
 429                 SetProperty(Slider.Property.LOWER_BOUND, new Tizen.NUI.PropertyValue(value));
 430             }
 431         }
 432         public float UpperBound
 433         {
 434             get
 435             {
 436                 float temp = 0.0f;
 437                 GetProperty(Slider.Property.UPPER_BOUND).Get(ref temp);
 438                 return temp;
 439             }
 440             set
 441             {
 442                 SetProperty(Slider.Property.UPPER_BOUND, new Tizen.NUI.PropertyValue(value));
 443             }
 444         }
 445         public float Value
 446         {
 447             get
 448             {
 449                 float temp = 0.0f;
 450                 GetProperty(Slider.Property.VALUE).Get(ref temp);
 451                 return temp;
 452             }
 453             set
 454             {
 455                 SetProperty(Slider.Property.VALUE, new Tizen.NUI.PropertyValue(value));
 456             }
 457         }
 458         public PropertyMap TrackVisual
 459         {
 460             get
 461             {
 462                 PropertyMap temp = new PropertyMap();
 463                 GetProperty(Slider.Property.TRACK_VISUAL).Get(temp);
 464                 return temp;
 465             }
 466             set
 467             {
 468                 SetProperty(Slider.Property.TRACK_VISUAL, new Tizen.NUI.PropertyValue(value));
 469             }
 470         }
 471         public PropertyMap HandleVisual
 472         {
 473             get
 474             {
 475                 PropertyMap temp = new PropertyMap();
 476                 GetProperty(Slider.Property.HANDLE_VISUAL).Get(temp);
 477                 return temp;
 478             }
 479             set
 480             {
 481                 SetProperty(Slider.Property.HANDLE_VISUAL, new Tizen.NUI.PropertyValue(value));
 482             }
 483         }
 484         public PropertyMap ProgressVisual
 485         {
 486             get
 487             {
 488                 PropertyMap temp = new PropertyMap();
 489                 GetProperty(Slider.Property.PROGRESS_VISUAL).Get(temp);
 490                 return temp;
 491             }
 492             set
 493             {
 494                 SetProperty(Slider.Property.PROGRESS_VISUAL, new Tizen.NUI.PropertyValue(value));
 495             }
 496         }
 497         public PropertyMap PopupVisual
 498         {
 499             get
 500             {
 501                 PropertyMap temp = new PropertyMap();
 502                 GetProperty(Slider.Property.POPUP_VISUAL).Get(temp);
 503                 return temp;
 504             }
 505             set
 506             {
 507                 SetProperty(Slider.Property.POPUP_VISUAL, new Tizen.NUI.PropertyValue(value));
 508             }
 509         }
 510         public PropertyMap PopupArrowVisual
 511         {
 512             get
 513             {
 514                 PropertyMap temp = new PropertyMap();
 515                 GetProperty(Slider.Property.POPUP_ARROW_VISUAL).Get(temp);
 516                 return temp;
 517             }
 518             set
 519             {
 520                 SetProperty(Slider.Property.POPUP_ARROW_VISUAL, new Tizen.NUI.PropertyValue(value));
 521             }
 522         }
 523         public Vector4 DisabledColor
 524         {
 525             get
 526             {
 527                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
 528                 GetProperty(Slider.Property.DISABLED_COLOR).Get(temp);
 529                 return temp;
 530             }
 531             set
 532             {
 533                 SetProperty(Slider.Property.DISABLED_COLOR, new Tizen.NUI.PropertyValue(value));
 534             }
 535         }
 536         public int ValuePrecision
 537         {
 538             get
 539             {
 540                 int temp = 0;
 541                 GetProperty(Slider.Property.VALUE_PRECISION).Get(ref temp);
 542                 return temp;
 543             }
 544             set
 545             {
 546                 SetProperty(Slider.Property.VALUE_PRECISION, new Tizen.NUI.PropertyValue(value));
 547             }
 548         }
 549         public bool ShowPopup
 550         {
 551             get
 552             {
 553                 bool temp = false;
 554                 GetProperty(Slider.Property.SHOW_POPUP).Get(ref temp);
 555                 return temp;
 556             }
 557             set
 558             {
 559                 SetProperty(Slider.Property.SHOW_POPUP, new Tizen.NUI.PropertyValue(value));
 560             }
 561         }
 562         public bool ShowValue
 563         {
 564             get
 565             {
 566                 bool temp = false;
 567                 GetProperty(Slider.Property.SHOW_VALUE).Get(ref temp);
 568                 return temp;
 569             }
 570             set
 571             {
 572                 SetProperty(Slider.Property.SHOW_VALUE, new Tizen.NUI.PropertyValue(value));
 573             }
 574         }
 575         public Tizen.NUI.PropertyArray Marks
 576         {
 577             get
 578             {
 579                 Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
 580                 GetProperty(Slider.Property.MARKS).Get(temp);
 581                 return temp;
 582             }
 583             set
 584             {
 585                 SetProperty(Slider.Property.MARKS, new Tizen.NUI.PropertyValue(value));
 586             }
 587         }
 588         public bool SnapToMarks
 589         {
 590             get
 591             {
 592                 bool temp = false;
 593                 GetProperty(Slider.Property.SNAP_TO_MARKS).Get(ref temp);
 594                 return temp;
 595             }
 596             set
 597             {
 598                 SetProperty(Slider.Property.SNAP_TO_MARKS, new Tizen.NUI.PropertyValue(value));
 599             }
 600         }
 601         public float MarkTolerance
 602         {
 603             get
 604             {
 605                 float temp = 0.0f;
 606                 GetProperty(Slider.Property.MARK_TOLERANCE).Get(ref temp);
 607                 return temp;
 608             }
 609             set
 610             {
 611                 SetProperty(Slider.Property.MARK_TOLERANCE, new Tizen.NUI.PropertyValue(value));
 612             }
 613         }
 614
 615     }
 616
 617 }