DALi C# binding - Write pure C# Color & Position classes and use typemaps to do the...
[platform/core/uifw/dali-toolkit.git] / 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 }