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 /* Properties earlier added by Ruby Script */
 317
 318   public bool Disabled
 319   {
 320     get
 321     {
 322       bool temp = false;
 323       GetProperty( Button.Property.DISABLED).Get( ref temp );
 324       return temp;
 325     }
 326     set
 327     {
 328       SetProperty( Button.Property.DISABLED, new Dali.Property.Value( value ) );
 329     }
 330   }
 331   public bool AutoRepeating
 332   {
 333     get
 334     {
 335       bool temp = false;
 336       GetProperty( Button.Property.AUTO_REPEATING).Get( ref temp );
 337       return temp;
 338     }
 339     set
 340     {
 341       SetProperty( Button.Property.AUTO_REPEATING, new Dali.Property.Value( value ) );
 342     }
 343   }
 344   public float InitialAutoRepeatingDelay
 345   {
 346     get
 347     {
 348       float temp = 0.0f;
 349       GetProperty( Button.Property.INITIAL_AUTO_REPEATING_DELAY).Get( ref temp );
 350       return temp;
 351     }
 352     set
 353     {
 354       SetProperty( Button.Property.INITIAL_AUTO_REPEATING_DELAY, new Dali.Property.Value( value ) );
 355     }
 356   }
 357   public float NextAutoRepeatingDelay
 358   {
 359     get
 360     {
 361       float temp = 0.0f;
 362       GetProperty( Button.Property.NEXT_AUTO_REPEATING_DELAY).Get( ref temp );
 363       return temp;
 364     }
 365     set
 366     {
 367       SetProperty( Button.Property.NEXT_AUTO_REPEATING_DELAY, new Dali.Property.Value( value ) );
 368     }
 369   }
 370   public bool Togglable
 371   {
 372     get
 373     {
 374       bool temp = false;
 375       GetProperty( Button.Property.TOGGLABLE).Get( ref temp );
 376       return temp;
 377     }
 378     set
 379     {
 380       SetProperty( Button.Property.TOGGLABLE, new Dali.Property.Value( value ) );
 381     }
 382   }
 383   public bool Selected
 384   {
 385     get
 386     {
 387       bool temp = false;
 388       GetProperty( Button.Property.SELECTED).Get( ref temp );
 389       return temp;
 390     }
 391     set
 392     {
 393       SetProperty( Button.Property.SELECTED, new Dali.Property.Value( value ) );
 394     }
 395   }
 396   public string UnselectedStateImage
 397   {
 398     get
 399     {
 400       string temp;
 401       GetProperty( Button.Property.UNSELECTED_STATE_IMAGE).Get( out temp );
 402       return temp;
 403     }
 404     set
 405     {
 406       SetProperty( Button.Property.UNSELECTED_STATE_IMAGE, new Dali.Property.Value( value ) );
 407     }
 408   }
 409   public string SelectedStateImage
 410   {
 411     get
 412     {
 413       string temp;
 414       GetProperty( Button.Property.SELECTED_STATE_IMAGE).Get( out temp );
 415       return temp;
 416     }
 417     set
 418     {
 419       SetProperty( Button.Property.SELECTED_STATE_IMAGE, new Dali.Property.Value( value ) );
 420     }
 421   }
 422   public string DisabledStateImage
 423   {
 424     get
 425     {
 426       string temp;
 427       GetProperty( Button.Property.DISABLED_STATE_IMAGE).Get( out temp );
 428       return temp;
 429     }
 430     set
 431     {
 432       SetProperty( Button.Property.DISABLED_STATE_IMAGE, new Dali.Property.Value( value ) );
 433     }
 434   }
 435   public Dali.CSharp.Color UnselectedColor
 436   {
 437     get
 438     {
 439       Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
 440       GetProperty( Button.Property.UNSELECTED_COLOR).Get(  temp );
 441       Dali.CSharp.Color ret = new Dali.CSharp.Color(temp.r, temp.g, temp.b, temp.a);
 442       return ret;
 443     }
 444     set
 445     {
 446       SetProperty( Button.Property.UNSELECTED_COLOR, new Dali.Property.Value( value ) );
 447     }
 448   }
 449   public Dali.CSharp.Color SelectedColor
 450   {
 451     get
 452     {
 453       Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
 454       GetProperty( Button.Property.SELECTED_COLOR).Get(  temp );
 455       Dali.CSharp.Color ret = new Dali.CSharp.Color(temp.r, temp.g, temp.b, temp.a);
 456       return ret;
 457     }
 458     set
 459     {
 460       SetProperty( Button.Property.SELECTED_COLOR, new Dali.Property.Value( value ) );
 461     }
 462   }
 463   public Dali.Property.Map Label
 464   {
 465     get
 466     {
 467       Dali.Property.Map temp = new Dali.Property.Map();
 468       GetProperty( Button.Property.LABEL).Get(  temp );
 469       return temp;
 470     }
 471     set
 472     {
 473       SetProperty( Button.Property.LABEL, new Dali.Property.Value( value ) );
 474     }
 475   }
 476   public string LabelText
 477   {
 478     get
 479     {
 480       string temp;
 481       GetProperty( Button.Property.LABEL_TEXT).Get( out temp );
 482       return temp;
 483     }
 484     set
 485     {
 486       SetProperty( Button.Property.LABEL_TEXT, new Dali.Property.Value( value ) );
 487     }
 488   }
 489
 490 /* Properties ends */
 491
 492 %}
 493 %enddef
 494
 495
 496 %define BUTTON_EVENTHANDLER_PARAM( NameSpace, ClassName)
 497
 498   BUTTON_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
 499   BUTTON_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
 500
 501 %enddef
 502
 503 namespace Dali
 504 {
 505   BUTTON_EVENTHANDLER_PARAM( Dali::Toolkit, Button);
 506
 507 } // namespace DALi
 508
 509
 510
 511