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
 101   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 102   private delegate bool ClickedCallbackDelegate(global::System.IntPtr data);
 103   private DaliEventHandlerWithReturnType<object,ClickedEventArgs,bool> _buttonClickedEventHandler;
 104   private ClickedCallbackDelegate _buttonClickedCallbackDelegate;
 105
 106   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 107   private delegate bool PressedCallbackDelegate(global::System.IntPtr data);
 108   private DaliEventHandlerWithReturnType<object,PressedEventArgs,bool> _buttonPressedEventHandler;
 109   private PressedCallbackDelegate _buttonPressedCallbackDelegate;
 110
 111   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 112   private delegate bool ReleasedCallbackDelegate(global::System.IntPtr data);
 113   private DaliEventHandlerWithReturnType<object,ReleasedEventArgs,bool>  _buttonReleasedEventHandler;
 114   private ReleasedCallbackDelegate _buttonReleasedCallbackDelegate;
 115
 116   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 117   private delegate bool StateChangedCallbackDelegate(global::System.IntPtr data);
 118   private DaliEventHandlerWithReturnType<object,StateChangedEventArgs,bool> _buttonStateChangedEventHandler;
 119   private StateChangedCallbackDelegate _buttonStateChangedCallbackDelegate;
 120
 121
 122   public event DaliEventHandlerWithReturnType<object,ClickedEventArgs,bool> Clicked
 123   {
 124      add
 125      {
 126         lock(this)
 127         {
 128            // Restricted to only one listener
 129            if (_buttonClickedEventHandler == null)
 130            {
 131               _buttonClickedEventHandler += value;
 132
 133               _buttonClickedCallbackDelegate = new ClickedCallbackDelegate(OnClicked);
 134               this.ClickedSignal().Connect(_buttonClickedCallbackDelegate);
 135            }
 136         }
 137      }
 138
 139      remove
 140      {
 141         lock(this)
 142         {
 143            if (_buttonClickedEventHandler != null)
 144            {
 145                this.ClickedSignal().Disconnect(_buttonClickedCallbackDelegate);
 146            }
 147
 148            _buttonClickedEventHandler -= value;
 149         }
 150      }
 151   }
 152
 153   // Callback for button click signal
 154   private bool OnClicked (IntPtr data)
 155   {
 156      ClickedEventArgs e = new ClickedEventArgs();
 157
 158      e.Button = Button.GetButtonFromPtr(data);
 159
 160      if (_buttonClickedEventHandler != null)
 161      {
 162         //here we send all data to user event handlers
 163         return _buttonClickedEventHandler(this, e);
 164      }
 165      return false;
 166   }
 167
 168
 169   public event DaliEventHandlerWithReturnType<object,PressedEventArgs,bool> Pressed
 170   {
 171      add
 172      {
 173         lock(this)
 174         {
 175            // Restricted to only one listener
 176            if (_buttonPressedEventHandler == null)
 177            {
 178               _buttonPressedEventHandler += value;
 179
 180               _buttonPressedCallbackDelegate = new PressedCallbackDelegate(OnPressed);
 181               this.PressedSignal().Connect(_buttonPressedCallbackDelegate);
 182            }
 183         }
 184      }
 185
 186      remove
 187      {
 188         lock(this)
 189         {
 190            if (_buttonPressedEventHandler != null)
 191            {
 192                this.PressedSignal().Disconnect(_buttonPressedCallbackDelegate);
 193            }
 194
 195            _buttonPressedEventHandler -= value;
 196         }
 197      }
 198   }
 199
 200   // Callback for button click signal
 201   private bool OnPressed (IntPtr data)
 202   {
 203      PressedEventArgs e = new PressedEventArgs();
 204
 205      e.Button = Button.GetButtonFromPtr(data);
 206
 207      if (_buttonPressedEventHandler != null)
 208      {
 209         //here we send all data to user event handlers
 210        return _buttonPressedEventHandler(this, e);
 211      }
 212      return false;
 213   }
 214
 215
 216   public event DaliEventHandlerWithReturnType<object,ReleasedEventArgs,bool> Released
 217   {
 218      add
 219      {
 220         lock(this)
 221         {
 222            // Restricted to only one listener
 223            if (_buttonReleasedEventHandler == null)
 224            {
 225               _buttonReleasedEventHandler += value;
 226
 227               _buttonReleasedCallbackDelegate = new ReleasedCallbackDelegate(OnReleased);
 228               this.ReleasedSignal().Connect(_buttonReleasedCallbackDelegate);
 229            }
 230         }
 231      }
 232
 233      remove
 234      {
 235         lock(this)
 236         {
 237            if (_buttonReleasedEventHandler != null)
 238            {
 239                this.ReleasedSignal().Disconnect(_buttonReleasedCallbackDelegate);
 240            }
 241
 242            _buttonReleasedEventHandler -= value;
 243         }
 244      }
 245   }
 246
 247   // Callback for button click signal
 248   private bool OnReleased (IntPtr data)
 249   {
 250      ReleasedEventArgs e = new ReleasedEventArgs();
 251
 252      e.Button = Button.GetButtonFromPtr(data);
 253
 254      if (_buttonReleasedEventHandler != null)
 255      {
 256         //here we send all data to user event handlers
 257        return _buttonReleasedEventHandler(this, e);
 258      }
 259      return false;
 260   }
 261
 262
 263   public event DaliEventHandlerWithReturnType<object,StateChangedEventArgs,bool> StateChanged
 264   {
 265      add
 266      {
 267         lock(this)
 268         {
 269            // Restricted to only one listener
 270            if (_buttonStateChangedEventHandler == null)
 271            {
 272               _buttonStateChangedEventHandler += value;
 273
 274               _buttonStateChangedCallbackDelegate = new StateChangedCallbackDelegate(OnStateChanged);
 275               this.StateChangedSignal().Connect(_buttonStateChangedCallbackDelegate);
 276            }
 277         }
 278      }
 279
 280      remove
 281      {
 282         lock(this)
 283         {
 284            if (_buttonStateChangedEventHandler != null)
 285            {
 286                this.StateChangedSignal().Disconnect(_buttonStateChangedCallbackDelegate);
 287            }
 288
 289            _buttonStateChangedEventHandler -= value;
 290         }
 291      }
 292   }
 293
 294   // Callback for button click signal
 295   private bool OnStateChanged (IntPtr data)
 296   {
 297      StateChangedEventArgs e = new StateChangedEventArgs();
 298
 299      e.Button = Button.GetButtonFromPtr(data);
 300
 301      if (_buttonStateChangedEventHandler != null)
 302      {
 303         //here we send all data to user event handlers
 304        return _buttonStateChangedEventHandler(this, e);
 305      }
 306      return false;
 307   }
 308
 309  public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
 310     ClassName ret = new ClassName(cPtr, false);
 311    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 312     return ret;
 313   }
 314
 315 %}
 316 %enddef
 317
 318
 319 %define BUTTON_EVENTHANDLER_PARAM( NameSpace, ClassName)
 320
 321   BUTTON_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
 322   BUTTON_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
 323
 324 %enddef
 325
 326 namespace Dali
 327 {
 328   BUTTON_EVENTHANDLER_PARAM( Dali::Toolkit, Button);
 329
 330 } // namespace DALi
 331
 332
 333
 334