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   public Dali.Property.Map UnselectedVisual
 316   {
 317     get
 318     {
 319       Dali.Property.Map temp = new Dali.Property.Map();
 320       GetProperty( Button.Property.UNSELECTED_VISUAL).Get(  temp );
 321       return temp;
 322     }
 323     set
 324     {
 325       SetProperty( Button.Property.UNSELECTED_VISUAL, new Dali.Property.Value( value ) );
 326     }
 327   }
 328
 329   public Dali.Property.Map SelectedVisual
 330   {
 331     get
 332     {
 333       Dali.Property.Map temp = new Dali.Property.Map();
 334       GetProperty( Button.Property.SELECTED_VISUAL).Get(  temp );
 335       return temp;
 336     }
 337     set
 338     {
 339       SetProperty( Button.Property.SELECTED_VISUAL, new Dali.Property.Value( value ) );
 340     }
 341   }
 342
 343   public Dali.Property.Map DisabledSelectedVisual
 344   {
 345     get
 346     {
 347       Dali.Property.Map temp = new Dali.Property.Map();
 348       GetProperty( Button.Property.DISABLED_SELECTED_VISUAL).Get(  temp );
 349       return temp;
 350     }
 351     set
 352     {
 353       SetProperty( Button.Property.DISABLED_SELECTED_VISUAL, new Dali.Property.Value( value ) );
 354     }
 355   }
 356
 357   public Dali.Property.Map DisabledUnselectedVisual
 358   {
 359     get
 360     {
 361       Dali.Property.Map temp = new Dali.Property.Map();
 362       GetProperty( Button.Property.DISABLED_UNSELECTED_VISUAL).Get(  temp );
 363       return temp;
 364     }
 365     set
 366     {
 367       SetProperty( Button.Property.DISABLED_UNSELECTED_VISUAL, new Dali.Property.Value( value ) );
 368     }
 369   }
 370
 371   public Dali.Property.Map UnselectedBackgroundVisual
 372   {
 373     get
 374     {
 375       Dali.Property.Map temp = new Dali.Property.Map();
 376       GetProperty( Button.Property.UNSELECTED_BACKGROUND_VISUAL).Get(  temp );
 377       return temp;
 378     }
 379     set
 380     {
 381       SetProperty( Button.Property.UNSELECTED_BACKGROUND_VISUAL, new Dali.Property.Value( value ) );
 382     }
 383   }
 384
 385   public Dali.Property.Map SelectedBackgroundVisual
 386   {
 387     get
 388     {
 389       Dali.Property.Map temp = new Dali.Property.Map();
 390       GetProperty( Button.Property.SELECTED_BACKGROUND_VISUAL).Get(  temp );
 391       return temp;
 392     }
 393     set
 394     {
 395       SetProperty( Button.Property.SELECTED_BACKGROUND_VISUAL, new Dali.Property.Value( value ) );
 396     }
 397   }
 398
 399   public Dali.Property.Map DisabledUnselectedBackgroundVisual
 400   {
 401     get
 402     {
 403       Dali.Property.Map temp = new Dali.Property.Map();
 404       GetProperty( Button.Property.DISABLED_UNSELECTED_BACKGROUND_VISUAL).Get(  temp );
 405       return temp;
 406     }
 407     set
 408     {
 409       SetProperty( Button.Property.DISABLED_UNSELECTED_BACKGROUND_VISUAL, new Dali.Property.Value( value ) );
 410     }
 411   }
 412
 413   public Dali.Property.Map DisabledSelectedBackgroundVisual
 414   {
 415     get
 416     {
 417       Dali.Property.Map temp = new Dali.Property.Map();
 418       GetProperty( Button.Property.DISABLED_SELECTED_BACKGROUND_VISUAL).Get(  temp );
 419       return temp;
 420     }
 421     set
 422     {
 423       SetProperty( Button.Property.DISABLED_SELECTED_BACKGROUND_VISUAL, new Dali.Property.Value( value ) );
 424     }
 425   }
 426
 427   public string LabelRelativeAlignment
 428   {
 429     get
 430     {
 431       string temp;
 432       GetProperty( Button.Property.LABEL_RELATIVE_ALIGNMENT).Get( out temp );
 433       return temp;
 434     }
 435     set
 436     {
 437       SetProperty( Button.Property.LABEL_RELATIVE_ALIGNMENT, new Dali.Property.Value( value ) );
 438     }
 439   }
 440
 441   public Vector4 LabelPadding
 442   {
 443     get
 444     {
 445       Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
 446       GetProperty( Button.Property.LABEL_PADDING).Get(  temp );
 447       return temp;
 448     }
 449     set
 450     {
 451       SetProperty( Button.Property.LABEL_PADDING, new Dali.Property.Value( value ) );
 452     }
 453   }
 454
 455   public Vector4 VisualPadding
 456   {
 457     get
 458     {
 459       Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
 460       GetProperty( Button.Property.VISUAL_PADDING).Get(  temp );
 461       return temp;
 462     }
 463     set
 464     {
 465       SetProperty( Button.Property.VISUAL_PADDING, new Dali.Property.Value( value ) );
 466     }
 467   }
 468 %}
 469 %enddef
 470
 471
 472 %define BUTTON_EVENTHANDLER_PARAM( NameSpace, ClassName)
 473
 474   BUTTON_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
 475   BUTTON_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
 476
 477 %enddef
 478
 479 namespace Dali
 480 {
 481   BUTTON_EVENTHANDLER_PARAM( Dali::Toolkit, Button);
 482
 483 } // namespace DALi
 484
 485
 486
 487