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 %}
 286
 287 %enddef
 288
 289
 290 %define DALI_SLIDER_EVENTHANDLER_PARAM( NameSpace, ClassName)
 291
 292   SLIDER_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
 293   SLIDER_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
 294
 295 %enddef
 296
 297 namespace Dali
 298 {
 299   DALI_SLIDER_EVENTHANDLER_PARAM( Dali::Toolkit, Slider);
 300 }