plugins/dali-swig/SWIG/events/button-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 // Example from Swig MACRO
  19
  20 %define BUTTON_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
  21 %typemap(csimports) NameSpace::ClassName %{
  22 using System;
  23 using System.Runtime.InteropServices;
  24
  25 %}
  26
  27 %enddef
  28
  29 %define BUTTON_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
  30 %typemap(cscode) NameSpace::ClassName %{
  31
  32 public class ClickedEventArgs : EventArgs
  33 {
  34    private Button _button;
  35
  36    public Button Button
  37    {
  38       get
  39       {
  40          return _button;
  41       }
  42       set
  43       {
  44          _button = value;
  45       }
  46    }
  47 }
  48
  49 public class PressedEventArgs : EventArgs
  50 {
  51    private Button _button;
  52
  53    public Button Button
  54    {
  55       get
  56       {
  57          return _button;
  58       }
  59       set
  60       {
  61          _button = value;
  62       }
  63    }
  64 }
  65
  66 public class ReleasedEventArgs : EventArgs
  67 {
  68    private Button _button;
  69
  70    public Button Button
  71    {
  72       get
  73       {
  74          return _button;
  75       }
  76       set
  77       {
  78          _button = value;
  79       }
  80    }
  81 }
  82
  83 public class StateChangedEventArgs : EventArgs
  84 {
  85    private Button _button;
  86
  87    public Button Button
  88    {
  89       get
  90       {
  91          return _button;
  92       }
  93       set
  94       {
  95          _button = value;
  96       }
  97    }
  98 }
  99
 100   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 101   public delegate bool ClickedEventHandler(object source, ClickedEventArgs e);
 102
 103   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 104   public delegate bool PressedEventHandler(object source, PressedEventArgs e);
 105
 106   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 107   public delegate bool ReleasedEventHandler(object source, ReleasedEventArgs e);
 108
 109   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 110   public delegate bool StateChangedEventHandler(object source, StateChangedEventArgs e);
 111
 112   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 113   private delegate bool ClickedCallbackDelegate(global::System.IntPtr data);
 114   private ClickedEventHandler   _buttonClickedEventHandler;
 115   private ClickedCallbackDelegate _buttonClickedCallbackDelegate;
 116
 117   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 118   private delegate bool PressedCallbackDelegate(global::System.IntPtr data);
 119   private PressedEventHandler   _buttonPressedEventHandler;
 120   private PressedCallbackDelegate _buttonPressedCallbackDelegate;
 121
 122   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 123   private delegate bool ReleasedCallbackDelegate(global::System.IntPtr data);
 124   private ReleasedEventHandler   _buttonReleasedEventHandler;
 125   private ReleasedCallbackDelegate _buttonReleasedCallbackDelegate;
 126
 127   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 128   private delegate bool StateChangedCallbackDelegate(global::System.IntPtr data);
 129   private StateChangedEventHandler   _buttonStateChangedEventHandler;
 130   private StateChangedCallbackDelegate _buttonStateChangedCallbackDelegate;
 131
 132
 133   public event ClickedEventHandler Clicked
 134   {
 135      add
 136      {
 137         lock(this)
 138         {
 139            // Restricted to only one listener
 140            if (_buttonClickedEventHandler == null)
 141            {
 142               _buttonClickedEventHandler += value;
 143
 144               _buttonClickedCallbackDelegate = new ClickedCallbackDelegate(OnClicked);
 145               this.ClickedSignal().Connect(_buttonClickedCallbackDelegate);
 146            }
 147         }
 148      }
 149
 150      remove
 151      {
 152         lock(this)
 153         {
 154            if (_buttonClickedEventHandler != null)
 155            {
 156                this.ClickedSignal().Disconnect(_buttonClickedCallbackDelegate);
 157            }
 158
 159            _buttonClickedEventHandler -= value;
 160         }
 161      }
 162   }
 163
 164   // Callback for button click signal
 165   private bool OnClicked (IntPtr data)
 166   {
 167      ClickedEventArgs e = new ClickedEventArgs();
 168
 169      e.Button = Button.GetButtonFromPtr(data);
 170
 171      if (_buttonClickedEventHandler != null)
 172      {
 173         //here we send all data to user event handlers
 174         return _buttonClickedEventHandler(this, e);
 175      }
 176      return false;
 177   }
 178
 179
 180   public event PressedEventHandler Pressed
 181   {
 182      add
 183      {
 184         lock(this)
 185         {
 186            // Restricted to only one listener
 187            if (_buttonPressedEventHandler == null)
 188            {
 189               _buttonPressedEventHandler += value;
 190
 191               _buttonPressedCallbackDelegate = new PressedCallbackDelegate(OnPressed);
 192               this.PressedSignal().Connect(_buttonPressedCallbackDelegate);
 193            }
 194         }
 195      }
 196
 197      remove
 198      {
 199         lock(this)
 200         {
 201            if (_buttonPressedEventHandler != null)
 202            {
 203                this.PressedSignal().Disconnect(_buttonPressedCallbackDelegate);
 204            }
 205
 206            _buttonPressedEventHandler -= value;
 207         }
 208      }
 209   }
 210
 211   // Callback for button click signal
 212   private bool OnPressed (IntPtr data)
 213   {
 214      PressedEventArgs e = new PressedEventArgs();
 215
 216      e.Button = Button.GetButtonFromPtr(data);
 217
 218      if (_buttonPressedEventHandler != null)
 219      {
 220         //here we send all data to user event handlers
 221        return _buttonPressedEventHandler(this, e);
 222      }
 223      return false;
 224   }
 225
 226
 227   public event ReleasedEventHandler Released
 228   {
 229      add
 230      {
 231         lock(this)
 232         {
 233            // Restricted to only one listener
 234            if (_buttonReleasedEventHandler == null)
 235            {
 236               _buttonReleasedEventHandler += value;
 237
 238               _buttonReleasedCallbackDelegate = new ReleasedCallbackDelegate(OnReleased);
 239               this.ReleasedSignal().Connect(_buttonReleasedCallbackDelegate);
 240            }
 241         }
 242      }
 243
 244      remove
 245      {
 246         lock(this)
 247         {
 248            if (_buttonReleasedEventHandler != null)
 249            {
 250                this.ReleasedSignal().Disconnect(_buttonReleasedCallbackDelegate);
 251            }
 252
 253            _buttonReleasedEventHandler -= value;
 254         }
 255      }
 256   }
 257
 258   // Callback for button click signal
 259   private bool OnReleased (IntPtr data)
 260   {
 261      ReleasedEventArgs e = new ReleasedEventArgs();
 262
 263      e.Button = Button.GetButtonFromPtr(data);
 264
 265      if (_buttonReleasedEventHandler != null)
 266      {
 267         //here we send all data to user event handlers
 268        return _buttonReleasedEventHandler(this, e);
 269      }
 270      return false;
 271   }
 272
 273
 274   public event StateChangedEventHandler StateChanged
 275   {
 276      add
 277      {
 278         lock(this)
 279         {
 280            // Restricted to only one listener
 281            if (_buttonStateChangedEventHandler == null)
 282            {
 283               _buttonStateChangedEventHandler += value;
 284
 285               _buttonStateChangedCallbackDelegate = new StateChangedCallbackDelegate(OnStateChanged);
 286               this.StateChangedSignal().Connect(_buttonStateChangedCallbackDelegate);
 287            }
 288         }
 289      }
 290
 291      remove
 292      {
 293         lock(this)
 294         {
 295            if (_buttonStateChangedEventHandler != null)
 296            {
 297                this.StateChangedSignal().Disconnect(_buttonStateChangedCallbackDelegate);
 298            }
 299
 300            _buttonStateChangedEventHandler -= value;
 301         }
 302      }
 303   }
 304
 305   // Callback for button click signal
 306   private bool OnStateChanged (IntPtr data)
 307   {
 308      StateChangedEventArgs e = new StateChangedEventArgs();
 309
 310      e.Button = Button.GetButtonFromPtr(data);
 311
 312      if (_buttonStateChangedEventHandler != null)
 313      {
 314         //here we send all data to user event handlers
 315        return _buttonStateChangedEventHandler(this, e);
 316      }
 317      return false;
 318   }
 319
 320  public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
 321     ClassName ret = new ClassName(cPtr, false);
 322    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 323     return ret;
 324   }
 325
 326 %}
 327 %enddef
 328
 329
 330 %define BUTTON_EVENTHANDLER_PARAM( NameSpace, ClassName)
 331
 332   BUTTON_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
 333   BUTTON_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
 334
 335 %enddef
 336
 337 namespace Dali
 338 {
 339   BUTTON_EVENTHANDLER_PARAM( Dali::Toolkit, Button);
 340
 341 } // namespace DALi
 342
 343
 344
 345