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   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 120   public delegate bool ValueChangedEventHandler(object source, ValueChangedEventArgs e);
 121
 122   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 123   public delegate bool SlidingFinishedEventHandler(object source, SlidingFinishedEventArgs e);
 124
 125   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 126   public delegate bool MarkReachedEventHandler(object source, MarkReachedEventArgs e);
 127
 128   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 129   private delegate bool ValueChangedCallbackDelegate(IntPtr slider, float slideValue);
 130   private ValueChangedEventHandler _sliderValueChangedEventHandler;
 131   private ValueChangedCallbackDelegate _sliderValueChangedCallbackDelegate;
 132
 133   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 134   private delegate bool SlidingFinishedCallbackDelegate(IntPtr slider, float slideValue);
 135   private SlidingFinishedEventHandler _sliderSlidingFinishedEventHandler;
 136   private SlidingFinishedCallbackDelegate _sliderSlidingFinishedCallbackDelegate;
 137
 138   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 139   private delegate bool MarkReachedCallbackDelegate(IntPtr slider, int slideValue);
 140   private MarkReachedEventHandler _sliderMarkReachedEventHandler;
 141   private MarkReachedCallbackDelegate _sliderMarkReachedCallbackDelegate;
 142
 143   public event ValueChangedEventHandler ValueChanged
 144   {
 145      add
 146      {
 147         lock(this)
 148         {
 149            // Restricted to only one listener
 150            if (_sliderValueChangedEventHandler == null)
 151            {
 152               _sliderValueChangedEventHandler += value;
 153
 154               _sliderValueChangedCallbackDelegate = new ValueChangedCallbackDelegate(OnValueChanged);
 155               this.ValueChangedSignal().Connect(_sliderValueChangedCallbackDelegate);
 156            }
 157         }
 158      }
 159
 160      remove
 161      {
 162         lock(this)
 163         {
 164            if (_sliderValueChangedEventHandler != null)
 165            {
 166               this.ValueChangedSignal().Disconnect(_sliderValueChangedCallbackDelegate);
 167            }
 168
 169            _sliderValueChangedEventHandler -= value;
 170         }
 171      }
 172   }
 173
 174   // Callback for Slider ValueChanged signal
 175   private bool OnValueChanged(IntPtr slider, float slideValue)
 176   {
 177      ValueChangedEventArgs e = new ValueChangedEventArgs();
 178
 179      // Populate all members of "e" (ValueChangedEventArgs) with real page
 180      e.Slider = Slider.GetSliderFromPtr( slider );
 181      e.SlideValue = slideValue;
 182
 183      if (_sliderValueChangedEventHandler != null)
 184      {
 185         //here we send all page to user event handlers
 186       return _sliderValueChangedEventHandler(this, e);
 187      }
 188      return false;
 189   }
 190
 191   public event SlidingFinishedEventHandler SlidingFinished
 192   {
 193      add
 194      {
 195         lock(this)
 196         {
 197            // Restricted to only one listener
 198            if (_sliderSlidingFinishedEventHandler == null)
 199            {
 200               _sliderSlidingFinishedEventHandler += value;
 201
 202               _sliderSlidingFinishedCallbackDelegate = new SlidingFinishedCallbackDelegate(OnSlidingFinished);
 203               this.SlidingFinishedSignal().Connect(_sliderSlidingFinishedCallbackDelegate);
 204            }
 205         }
 206      }
 207
 208      remove
 209      {
 210         lock(this)
 211         {
 212            if (_sliderSlidingFinishedEventHandler != null)
 213            {
 214               this.SlidingFinishedSignal().Disconnect(_sliderSlidingFinishedCallbackDelegate);
 215            }
 216
 217            _sliderSlidingFinishedEventHandler -= value;
 218         }
 219      }
 220   }
 221
 222   // Callback for Slider SlidingFinished signal
 223   private bool OnSlidingFinished(IntPtr slider, float slideValue)
 224   {
 225      SlidingFinishedEventArgs e = new SlidingFinishedEventArgs();
 226
 227      // Populate all members of "e" (SlidingFinishedEventArgs) with real page
 228      e.Slider = Slider.GetSliderFromPtr( slider );
 229      e.SlideValue = slideValue;
 230
 231      if (_sliderSlidingFinishedEventHandler != null)
 232      {
 233         //here we send all page to user event handlers
 234       return _sliderSlidingFinishedEventHandler(this, e);
 235      }
 236      return false;
 237   }
 238
 239   public event MarkReachedEventHandler MarkReached
 240   {
 241      add
 242      {
 243         lock(this)
 244         {
 245            // Restricted to only one listener
 246            if (_sliderMarkReachedEventHandler == null)
 247            {
 248               _sliderMarkReachedEventHandler += value;
 249
 250               _sliderMarkReachedCallbackDelegate = new MarkReachedCallbackDelegate(OnMarkReached);
 251               this.MarkReachedSignal().Connect(_sliderMarkReachedCallbackDelegate);
 252            }
 253         }
 254      }
 255
 256      remove
 257      {
 258         lock(this)
 259         {
 260            if (_sliderMarkReachedEventHandler != null)
 261            {
 262               this.MarkReachedSignal().Disconnect(_sliderMarkReachedCallbackDelegate);
 263            }
 264
 265            _sliderMarkReachedEventHandler -= value;
 266         }
 267      }
 268   }
 269
 270   // Callback for Slider MarkReached signal
 271   private bool OnMarkReached(IntPtr slider, int slideValue)
 272   {
 273      MarkReachedEventArgs e = new MarkReachedEventArgs();
 274
 275      // Populate all members of "e" (MarkReachedEventArgs) with real page
 276      e.Slider = Slider.GetSliderFromPtr( slider );
 277      e.SlideValue = slideValue;
 278
 279      if (_sliderMarkReachedEventHandler != null)
 280      {
 281         //here we send all page to user event handlers
 282       return _sliderMarkReachedEventHandler(this, e);
 283      }
 284      return false;
 285   }
 286
 287   public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
 288     ClassName ret = new ClassName(cPtr, false);
 289    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 290     return ret;
 291   }
 292
 293 %}
 294
 295 %enddef
 296
 297
 298 %define DALI_SLIDER_EVENTHANDLER_PARAM( NameSpace, ClassName)
 299
 300   SLIDER_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
 301   SLIDER_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
 302
 303 %enddef
 304
 305 namespace Dali
 306 {
 307   DALI_SLIDER_EVENTHANDLER_PARAM( Dali::Toolkit, Slider);
 308 }