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