plugins/dali-swig/SWIG/events/slider-event.i

   1 /*
   2  * Copyright (c) 2016 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
  18 %define SLIDER_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
  19 %typemap(csimports) NameSpace::ClassName %{
  20 using System;
  21 using System.Runtime.InteropServices;
  22
  23 %}
  24 %enddef
  25
  26 %define SLIDER_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
  27 %typemap(cscode) NameSpace::ClassName %{
  28
  29 public class ValueChangedEventArgs : EventArgs
  30 {
  31    private Slider _slider;
  32    private float _slideValue;
  33
  34    public Slider Slider
  35    {
  36       get
  37       {
  38          return _slider;
  39       }
  40       set
  41       {
  42          _slider = value;
  43       }
  44    }
  45
  46    public float SlideValue
  47    {
  48       get
  49       {
  50          return _slideValue;
  51       }
  52       set
  53       {
  54          _slideValue = value;
  55       }
  56    }
  57 }
  58
  59 public class SlidingFinishedEventArgs : EventArgs
  60 {
  61    private Slider _slider;
  62    private float _slideValue;
  63
  64    public Slider Slider
  65    {
  66       get
  67       {
  68          return _slider;
  69       }
  70       set
  71       {
  72          _slider = value;
  73       }
  74    }
  75
  76    public float SlideValue
  77    {
  78       get
  79       {
  80          return _slideValue;
  81       }
  82       set
  83       {
  84          _slideValue = value;
  85       }
  86    }
  87 }
  88
  89 public class MarkReachedEventArgs : EventArgs
  90 {
  91    private Slider _slider;
  92    private int _slideValue;
  93
  94    public Slider Slider
  95    {
  96       get
  97       {
  98          return _slider;
  99       }
 100       set
 101       {
 102          _slider = value;
 103       }
 104    }
 105
 106    public int SlideValue
 107    {
 108       get
 109       {
 110          return _slideValue;
 111       }
 112       set
 113       {
 114          _slideValue = value;
 115       }
 116    }
 117 }
 118
 119
 120   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 121   private delegate bool ValueChangedCallbackDelegate(IntPtr slider, float slideValue);
 122   private DaliEventHandlerWithReturnType<object,ValueChangedEventArgs,bool> _sliderValueChangedEventHandler;
 123   private ValueChangedCallbackDelegate _sliderValueChangedCallbackDelegate;
 124
 125   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 126   private delegate bool SlidingFinishedCallbackDelegate(IntPtr slider, float slideValue);
 127   private DaliEventHandlerWithReturnType<object,SlidingFinishedEventArgs,bool> _sliderSlidingFinishedEventHandler;
 128   private SlidingFinishedCallbackDelegate _sliderSlidingFinishedCallbackDelegate;
 129
 130   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 131   private delegate bool MarkReachedCallbackDelegate(IntPtr slider, int slideValue);
 132   private DaliEventHandlerWithReturnType<object,MarkReachedEventArgs,bool> _sliderMarkReachedEventHandler;
 133   private MarkReachedCallbackDelegate _sliderMarkReachedCallbackDelegate;
 134
 135   public event DaliEventHandlerWithReturnType<object,ValueChangedEventArgs,bool> ValueChanged
 136   {
 137      add
 138      {
 139         lock(this)
 140         {
 141            // Restricted to only one listener
 142            if (_sliderValueChangedEventHandler == null)
 143            {
 144               _sliderValueChangedEventHandler += value;
 145
 146               _sliderValueChangedCallbackDelegate = new ValueChangedCallbackDelegate(OnValueChanged);
 147               this.ValueChangedSignal().Connect(_sliderValueChangedCallbackDelegate);
 148            }
 149         }
 150      }
 151
 152      remove
 153      {
 154         lock(this)
 155         {
 156            if (_sliderValueChangedEventHandler != null)
 157            {
 158               this.ValueChangedSignal().Disconnect(_sliderValueChangedCallbackDelegate);
 159            }
 160
 161            _sliderValueChangedEventHandler -= value;
 162         }
 163      }
 164   }
 165
 166   // Callback for Slider ValueChanged signal
 167   private bool OnValueChanged(IntPtr slider, float slideValue)
 168   {
 169      ValueChangedEventArgs e = new ValueChangedEventArgs();
 170
 171      // Populate all members of "e" (ValueChangedEventArgs) with real page
 172      e.Slider = Slider.GetSliderFromPtr( slider );
 173      e.SlideValue = slideValue;
 174
 175      if (_sliderValueChangedEventHandler != null)
 176      {
 177         //here we send all page to user event handlers
 178       return _sliderValueChangedEventHandler(this, e);
 179      }
 180      return false;
 181   }
 182
 183   public event DaliEventHandlerWithReturnType<object,SlidingFinishedEventArgs,bool> SlidingFinished
 184   {
 185      add
 186      {
 187         lock(this)
 188         {
 189            // Restricted to only one listener
 190            if (_sliderSlidingFinishedEventHandler == null)
 191            {
 192               _sliderSlidingFinishedEventHandler += value;
 193
 194               _sliderSlidingFinishedCallbackDelegate = new SlidingFinishedCallbackDelegate(OnSlidingFinished);
 195               this.SlidingFinishedSignal().Connect(_sliderSlidingFinishedCallbackDelegate);
 196            }
 197         }
 198      }
 199
 200      remove
 201      {
 202         lock(this)
 203         {
 204            if (_sliderSlidingFinishedEventHandler != null)
 205            {
 206               this.SlidingFinishedSignal().Disconnect(_sliderSlidingFinishedCallbackDelegate);
 207            }
 208
 209            _sliderSlidingFinishedEventHandler -= value;
 210         }
 211      }
 212   }
 213
 214   // Callback for Slider SlidingFinished signal
 215   private bool OnSlidingFinished(IntPtr slider, float slideValue)
 216   {
 217      SlidingFinishedEventArgs e = new SlidingFinishedEventArgs();
 218
 219      // Populate all members of "e" (SlidingFinishedEventArgs) with real page
 220      e.Slider = Slider.GetSliderFromPtr( slider );
 221      e.SlideValue = slideValue;
 222
 223      if (_sliderSlidingFinishedEventHandler != null)
 224      {
 225         //here we send all page to user event handlers
 226       return _sliderSlidingFinishedEventHandler(this, e);
 227      }
 228      return false;
 229   }
 230
 231   public event DaliEventHandlerWithReturnType<object,MarkReachedEventArgs,bool> MarkReached
 232   {
 233      add
 234      {
 235         lock(this)
 236         {
 237            // Restricted to only one listener
 238            if (_sliderMarkReachedEventHandler == null)
 239            {
 240               _sliderMarkReachedEventHandler += value;
 241
 242               _sliderMarkReachedCallbackDelegate = new MarkReachedCallbackDelegate(OnMarkReached);
 243               this.MarkReachedSignal().Connect(_sliderMarkReachedCallbackDelegate);
 244            }
 245         }
 246      }
 247
 248      remove
 249      {
 250         lock(this)
 251         {
 252            if (_sliderMarkReachedEventHandler != null)
 253            {
 254               this.MarkReachedSignal().Disconnect(_sliderMarkReachedCallbackDelegate);
 255            }
 256
 257            _sliderMarkReachedEventHandler -= value;
 258         }
 259      }
 260   }
 261
 262   // Callback for Slider MarkReached signal
 263   private bool OnMarkReached(IntPtr slider, int slideValue)
 264   {
 265      MarkReachedEventArgs e = new MarkReachedEventArgs();
 266
 267      // Populate all members of "e" (MarkReachedEventArgs) with real page
 268      e.Slider = Slider.GetSliderFromPtr( slider );
 269      e.SlideValue = slideValue;
 270
 271      if (_sliderMarkReachedEventHandler != null)
 272      {
 273         //here we send all page to user event handlers
 274       return _sliderMarkReachedEventHandler(this, e);
 275      }
 276      return false;
 277   }
 278
 279   public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
 280     ClassName ret = new ClassName(cPtr, false);
 281    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 282     return ret;
 283   }
 284
 285 /* Properties earlier added by Ruby Script */
 286
 287   public float LowerBound
 288   {
 289     get
 290     {
 291       float temp = 0.0f;
 292       GetProperty( Slider.Property.LOWER_BOUND).Get( ref temp );
 293       return temp;
 294     }
 295     set
 296     {
 297       SetProperty( Slider.Property.LOWER_BOUND, new Dali.Property.Value( value ) );
 298     }
 299   }
 300   public float UpperBound
 301   {
 302     get
 303     {
 304       float temp = 0.0f;
 305       GetProperty( Slider.Property.UPPER_BOUND).Get( ref temp );
 306       return temp;
 307     }
 308     set
 309     {
 310       SetProperty( Slider.Property.UPPER_BOUND, new Dali.Property.Value( value ) );
 311     }
 312   }
 313   public float Value
 314   {
 315     get
 316     {
 317       float temp = 0.0f;
 318       GetProperty( Slider.Property.VALUE).Get( ref temp );
 319       return temp;
 320     }
 321     set
 322     {
 323       SetProperty( Slider.Property.VALUE, new Dali.Property.Value( value ) );
 324     }
 325   }
 326   public Dali.Property.Map TrackVisual
 327   {
 328     get
 329     {
 330       Dali.Property.Map temp = new Dali.Property.Map();
 331       GetProperty( Slider.Property.TRACK_VISUAL).Get(  temp );
 332       return temp;
 333     }
 334     set
 335     {
 336       SetProperty( Slider.Property.TRACK_VISUAL, new Dali.Property.Value( value ) );
 337     }
 338   }
 339   public Dali.Property.Map HandleVisual
 340   {
 341     get
 342     {
 343       Dali.Property.Map temp = new Dali.Property.Map();
 344       GetProperty( Slider.Property.HANDLE_VISUAL).Get(  temp );
 345       return temp;
 346     }
 347     set
 348     {
 349       SetProperty( Slider.Property.HANDLE_VISUAL, new Dali.Property.Value( value ) );
 350     }
 351   }
 352   public Dali.Property.Map ProgressVisual
 353   {
 354     get
 355     {
 356       Dali.Property.Map temp = new Dali.Property.Map();
 357       GetProperty( Slider.Property.PROGRESS_VISUAL).Get(  temp );
 358       return temp;
 359     }
 360     set
 361     {
 362       SetProperty( Slider.Property.PROGRESS_VISUAL, new Dali.Property.Value( value ) );
 363     }
 364   }
 365   public Dali.Property.Map PopupVisual
 366   {
 367     get
 368     {
 369       Dali.Property.Map temp = new Dali.Property.Map();
 370       GetProperty( Slider.Property.POPUP_VISUAL).Get(  temp );
 371       return temp;
 372     }
 373     set
 374     {
 375       SetProperty( Slider.Property.POPUP_VISUAL, new Dali.Property.Value( value ) );
 376     }
 377   }
 378   public Dali.Property.Map PopupArrowVisual
 379   {
 380     get
 381     {
 382       Dali.Property.Map temp = new Dali.Property.Map();
 383       GetProperty( Slider.Property.POPUP_ARROW_VISUAL).Get(  temp );
 384       return temp;
 385     }
 386     set
 387     {
 388       SetProperty( Slider.Property.POPUP_ARROW_VISUAL, new Dali.Property.Value( value ) );
 389     }
 390   }
 391   public Dali.CSharp.Color DisabledColor
 392   {
 393     get
 394     {
 395       Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
 396       GetProperty( Slider.Property.DISABLED_COLOR).Get(  temp );
 397       Dali.CSharp.Color ret = new Dali.CSharp.Color(temp.r, temp.g, temp.b, temp.a);
 398       return ret;
 399     }
 400     set
 401     {
 402       SetProperty( Slider.Property.DISABLED_COLOR, new Dali.Property.Value( value ) );
 403     }
 404   }
 405   public int ValuePrecision
 406   {
 407     get
 408     {
 409       int temp = 0;
 410       GetProperty( Slider.Property.VALUE_PRECISION).Get( ref temp );
 411       return temp;
 412     }
 413     set
 414     {
 415       SetProperty( Slider.Property.VALUE_PRECISION, new Dali.Property.Value( value ) );
 416     }
 417   }
 418   public bool ShowPopup
 419   {
 420     get
 421     {
 422       bool temp = false;
 423       GetProperty( Slider.Property.SHOW_POPUP).Get( ref temp );
 424       return temp;
 425     }
 426     set
 427     {
 428       SetProperty( Slider.Property.SHOW_POPUP, new Dali.Property.Value( value ) );
 429     }
 430   }
 431   public bool ShowValue
 432   {
 433     get
 434     {
 435       bool temp = false;
 436       GetProperty( Slider.Property.SHOW_VALUE).Get( ref temp );
 437       return temp;
 438     }
 439     set
 440     {
 441       SetProperty( Slider.Property.SHOW_VALUE, new Dali.Property.Value( value ) );
 442     }
 443   }
 444   public Dali.Property.Array Marks
 445   {
 446     get
 447     {
 448       Dali.Property.Array temp = new Dali.Property.Array();
 449       GetProperty( Slider.Property.MARKS).Get(  temp );
 450       return temp;
 451     }
 452     set
 453     {
 454       SetProperty( Slider.Property.MARKS, new Dali.Property.Value( value ) );
 455     }
 456   }
 457   public bool SnapToMarks
 458   {
 459     get
 460     {
 461       bool temp = false;
 462       GetProperty( Slider.Property.SNAP_TO_MARKS).Get( ref temp );
 463       return temp;
 464     }
 465     set
 466     {
 467       SetProperty( Slider.Property.SNAP_TO_MARKS, new Dali.Property.Value( value ) );
 468     }
 469   }
 470   public float MarkTolerance
 471   {
 472     get
 473     {
 474       float temp = 0.0f;
 475       GetProperty( Slider.Property.MARK_TOLERANCE).Get( ref temp );
 476       return temp;
 477     }
 478     set
 479     {
 480       SetProperty( Slider.Property.MARK_TOLERANCE, new Dali.Property.Value( value ) );
 481     }
 482   }
 483
 484 /* Properties ends */
 485
 486 %}
 487
 488 %enddef
 489
 490
 491 %define DALI_SLIDER_EVENTHANDLER_PARAM( NameSpace, ClassName)
 492
 493   SLIDER_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
 494   SLIDER_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
 495
 496 %enddef
 497
 498 namespace Dali
 499 {
 500   DALI_SLIDER_EVENTHANDLER_PARAM( Dali::Toolkit, Slider);
 501 }