plugins/dali-swig/SWIG/events/stage-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 STAGE_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 STAGE_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
  27 %typemap(cscode) NameSpace::ClassName %{
  28
  29 /**
  30   * @brief Event arguments that passed via Touch signal
  31   *
  32   */
  33 public class TouchEventArgs : EventArgs
  34 {
  35    private TouchData _touchData;
  36
  37    /**
  38      * @brief TouchData - contains the information of touch points
  39      *
  40      */
  41    public TouchData TouchData
  42    {
  43       get
  44       {
  45          return _touchData;
  46       }
  47       set
  48       {
  49          _touchData = value;
  50       }
  51    }
  52 }
  53
  54
  55 /**
  56   * @brief Event arguments that passed via Wheel signal
  57   *
  58   */
  59 public class WheelEventArgs : EventArgs
  60 {
  61    private WheelEvent _wheelEvent;
  62
  63    /**
  64      * @brief WheelEvent - store a wheel rolling type MOUSE_WHEEL or CUSTOM_WHEEL
  65      *
  66      */
  67    public WheelEvent WheelEvent
  68    {
  69       get
  70       {
  71          return _wheelEvent;
  72       }
  73       set
  74       {
  75          _wheelEvent = value;
  76       }
  77    }
  78 }
  79
  80 /**
  81   * @brief Event arguments that passed via KeyEvent signal
  82   *
  83   */
  84 public class KeyEventArgs : EventArgs
  85 {
  86    private KeyEvent _keyEvent;
  87
  88    /**
  89      * @brief KeyEvent - is the keyevent sent to Stage.
  90      *
  91      */
  92    public KeyEvent KeyEvent
  93    {
  94       get
  95       {
  96          return _keyEvent;
  97       }
  98       set
  99       {
 100          _keyEvent = value;
 101       }
 102    }
 103 }
 104
 105 /**
 106   * @brief Event arguments that passed via EventProcessingFinished signal
 107   *
 108   */
 109 public class EventProcessingFinishedEventArgs : EventArgs
 110 {
 111 }
 112
 113 /**
 114   * @brief Event arguments that passed via ContextLost signal
 115   *
 116   */
 117 public class ContextLostEventArgs : EventArgs
 118 {
 119 }
 120
 121 /**
 122   * @brief Event arguments that passed via ContextRegained signal
 123   *
 124   */
 125 public class ContextRegainedEventArgs : EventArgs
 126 {
 127 }
 128
 129 /**
 130   * @brief Event arguments that passed via SceneCreated signal
 131   *
 132   */
 133 public class SceneCreatedEventArgs : EventArgs
 134 {
 135 }
 136
 137
 138   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 139   private delegate void StageTouchCallbackDelegate(IntPtr data);
 140   private DaliEventHandler<object,TouchEventArgs> _stageTouchEventHandler;
 141   private StageTouchCallbackDelegate _stageTouchCallbackDelegate;
 142
 143   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 144   private delegate void WheelCallbackDelegate(IntPtr data);
 145   private DaliEventHandler<object,WheelEventArgs> _stageWheelEventHandler;
 146   private WheelCallbackDelegate _stageWheelCallbackDelegate;
 147
 148   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 149   private delegate void KeyCallbackDelegate(IntPtr data);
 150   private DaliEventHandler<object,KeyEventArgs> _stageKeyEventHandler;
 151   private KeyCallbackDelegate _stageKeyCallbackDelegate;
 152
 153   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 154   private delegate void EventProcessingFinishedEventCallbackDelegate();
 155   private DaliEventHandler<object,EventProcessingFinishedEventArgs> _stageEventProcessingFinishedEventHandler;
 156   private EventProcessingFinishedEventCallbackDelegate _stageEventProcessingFinishedEventCallbackDelegate;
 157
 158   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 159   private delegate void ContextLostEventCallbackDelegate();
 160   private DaliEventHandler<object,ContextLostEventArgs> _stageContextLostEventHandler;
 161   private ContextLostEventCallbackDelegate _stageContextLostEventCallbackDelegate;
 162
 163   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 164   private delegate void ContextRegainedEventCallbackDelegate();
 165   private DaliEventHandler<object,ContextRegainedEventArgs> _stageContextRegainedEventHandler;
 166   private ContextRegainedEventCallbackDelegate _stageContextRegainedEventCallbackDelegate;
 167
 168   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 169   private delegate void SceneCreatedEventCallbackDelegate();
 170   private DaliEventHandler<object,SceneCreatedEventArgs> _stageSceneCreatedEventHandler;
 171   private SceneCreatedEventCallbackDelegate _stageSceneCreatedEventCallbackDelegate;
 172
 173   /**
 174     * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler
 175     * (in the type of TouchEventHandler-DaliEventHandler<object,TouchEventArgs>) provided by the user.
 176     * Touched signal is emitted when the screen is touched and when the touch ends
 177     * (i.e. the down & up touch events only).
 178     *
 179     */
 180   public event DaliEventHandler<object,TouchEventArgs> Touched
 181   {
 182      add
 183      {
 184         lock(this)
 185         {
 186            // Restricted to only one listener
 187            if (_stageTouchEventHandler == null)
 188            {
 189               _stageTouchEventHandler += value;
 190
 191               _stageTouchCallbackDelegate = new StageTouchCallbackDelegate(OnStageTouch);
 192               this.TouchSignal().Connect(_stageTouchCallbackDelegate);
 193            }
 194         }
 195      }
 196
 197      remove
 198      {
 199         lock(this)
 200         {
 201            if (_stageTouchEventHandler != null)
 202            {
 203               this.TouchSignal().Disconnect(_stageTouchCallbackDelegate);
 204            }
 205
 206            _stageTouchEventHandler -= value;
 207         }
 208      }
 209   }
 210
 211   // Callback for Stage Touch signal
 212   private void OnStageTouch(IntPtr data)
 213   {
 214      TouchEventArgs e = new TouchEventArgs();
 215
 216      // Populate all members of "e" (TouchEventArgs) with real data
 217      e.TouchData = TouchData.GetTouchDataFromPtr( data );
 218
 219      if (_stageTouchEventHandler != null)
 220      {
 221         //here we send all data to user event handlers
 222         _stageTouchEventHandler(this, e);
 223      }
 224   }
 225
 226   /**
 227     * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
 228     * (in the type of WheelEventHandler-DaliEventHandler<object,WheelEventArgs>) provided by the user.
 229     * WheelMoved signal is emitted is emitted when wheel event is received.
 230     *
 231     */
 232   public event DaliEventHandler<object,WheelEventArgs> WheelMoved
 233   {
 234      add
 235      {
 236         lock(this)
 237         {
 238            // Restricted to only one listener
 239            if (_stageWheelEventHandler == null)
 240            {
 241               _stageWheelEventHandler += value;
 242
 243               _stageWheelCallbackDelegate = new WheelCallbackDelegate(OnStageWheel);
 244               this.WheelEventSignal().Connect(_stageWheelCallbackDelegate);
 245            }
 246         }
 247      }
 248
 249      remove
 250      {
 251         lock(this)
 252         {
 253            if (_stageWheelEventHandler != null)
 254            {
 255               this.WheelEventSignal().Disconnect(_stageWheelCallbackDelegate);
 256            }
 257
 258            _stageWheelEventHandler -= value;
 259         }
 260      }
 261   }
 262
 263   // Callback for Stage WheelEventsignal
 264   private void OnStageWheel(IntPtr data)
 265   {
 266      WheelEventArgs e = new WheelEventArgs();
 267
 268      // Populate all members of "e" (WheelEventArgs) with real data
 269      e.WheelEvent = Dali.WheelEvent.GetWheelEventFromPtr( data );
 270
 271      if (_stageWheelEventHandler != null)
 272      {
 273         //here we send all data to user event handlers
 274         _stageWheelEventHandler(this, e);
 275      }
 276   }
 277
 278   /**
 279     * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
 280     * (in the type of KeyEventHandler-DaliEventHandler<object,KeyEventArgs>) provided by the user.
 281     * KeyPressed signal is emitted is emitted when key event is received.
 282     *
 283     */
 284   public event DaliEventHandler<object,KeyEventArgs> KeyPressed
 285   {
 286      add
 287      {
 288         lock(this)
 289         {
 290            // Restricted to only one listener
 291            if (_stageKeyEventHandler == null)
 292            {
 293               _stageKeyEventHandler += value;
 294
 295               _stageKeyCallbackDelegate = new KeyCallbackDelegate(OnStageKey);
 296               this.KeyEventSignal().Connect(_stageKeyCallbackDelegate);
 297            }
 298         }
 299      }
 300
 301      remove
 302      {
 303         lock(this)
 304         {
 305            if (_stageKeyEventHandler != null)
 306            {
 307               this.KeyEventSignal().Disconnect(_stageKeyCallbackDelegate);
 308            }
 309
 310            _stageKeyEventHandler -= value;
 311         }
 312      }
 313   }
 314
 315   // Callback for Stage KeyEventsignal
 316   private void OnStageKey(IntPtr keyEvent)
 317   {
 318      KeyEventArgs e = new KeyEventArgs();
 319
 320      // Populate all members of "e" (KeyEventArgs) with real data
 321      e.KeyEvent = Dali.KeyEvent.GetKeyEventFromPtr( keyEvent );
 322
 323      if (_stageKeyEventHandler != null)
 324      {
 325         //here we send all data to user event handlers
 326         _stageKeyEventHandler(this, e);
 327      }
 328   }
 329
 330   /**
 331     * @brief Event for EventProcessingFinished signal which can be used to subscribe/unsubscribe the event handler
 332     * (in the type of EventProcessingFinishedEventHandler-DaliEventHandler<object,EventProcessingFinishedEventArgs>)
 333     * provided by the user. EventProcessingFinished signal is emitted just after the event processing is finished.
 334     *
 335     */
 336   public event DaliEventHandler<object,EventProcessingFinishedEventArgs> EventProcessingFinished
 337   {
 338      add
 339      {
 340         lock(this)
 341         {
 342            // Restricted to only one listener
 343            if (_stageEventProcessingFinishedEventHandler == null)
 344            {
 345               _stageEventProcessingFinishedEventHandler += value;
 346
 347               _stageEventProcessingFinishedEventCallbackDelegate = new EventProcessingFinishedEventCallbackDelegate(OnEventProcessingFinished);
 348               this.EventProcessingFinishedSignal().Connect(_stageEventProcessingFinishedEventCallbackDelegate);
 349            }
 350         }
 351      }
 352
 353      remove
 354      {
 355         lock(this)
 356         {
 357            if (_stageEventProcessingFinishedEventHandler != null)
 358            {
 359               this.EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate);
 360            }
 361
 362            _stageEventProcessingFinishedEventHandler -= value;
 363         }
 364      }
 365   }
 366
 367   // Callback for Stage EventProcessingFinishedSignal
 368   private void OnEventProcessingFinished()
 369   {
 370      EventProcessingFinishedEventArgs e = new EventProcessingFinishedEventArgs();
 371
 372      if (_stageEventProcessingFinishedEventHandler != null)
 373      {
 374         //here we send all data to user event handlers
 375         _stageEventProcessingFinishedEventHandler(this, e);
 376      }
 377   }
 378
 379   /**
 380     * @brief Event for ContextLost signal which can be used to subscribe/unsubscribe the event handler
 381     * (in the type of ContextLostEventHandler-DaliEventHandler<object,ContextLostEventArgs>) provided by the user.
 382     * ContextLost signal is emitted when the GL context is lost (Platform specific behaviour).
 383     *
 384     */
 385   public event DaliEventHandler<object,ContextLostEventArgs> ContextLost
 386   {
 387      add
 388      {
 389         lock(this)
 390         {
 391            // Restricted to only one listener
 392            if (_stageContextLostEventHandler == null)
 393            {
 394               _stageContextLostEventHandler += value;
 395
 396               _stageContextLostEventCallbackDelegate = new ContextLostEventCallbackDelegate(OnContextLost);
 397               this.ContextLostSignal().Connect(_stageContextLostEventCallbackDelegate);
 398            }
 399         }
 400      }
 401
 402      remove
 403      {
 404         lock(this)
 405         {
 406            if (_stageContextLostEventHandler != null)
 407            {
 408               this.ContextLostSignal().Disconnect(_stageContextLostEventCallbackDelegate);
 409            }
 410
 411            _stageContextLostEventHandler -= value;
 412         }
 413      }
 414   }
 415
 416   // Callback for Stage ContextLostSignal
 417   private void OnContextLost()
 418   {
 419      ContextLostEventArgs e = new ContextLostEventArgs();
 420
 421      if (_stageContextLostEventHandler != null)
 422      {
 423         //here we send all data to user event handlers
 424         _stageContextLostEventHandler(this, e);
 425      }
 426   }
 427
 428   /**
 429     * @brief Event for ContextRegained signal which can be used to subscribe/unsubscribe the event handler
 430     * (in the type of ContextRegainedEventHandler-DaliEventHandler<object,ContextRegainedEventArgs>)
 431     * provided by the user. ContextRegained signal is emitted when the GL context is regained (Platform specific
 432     * behaviour).
 433     *
 434     */
 435   public event DaliEventHandler<object,ContextRegainedEventArgs> ContextRegained
 436   {
 437      add
 438      {
 439         lock(this)
 440         {
 441            // Restricted to only one listener
 442            if (_stageContextRegainedEventHandler == null)
 443            {
 444               _stageContextRegainedEventHandler += value;
 445
 446               _stageContextRegainedEventCallbackDelegate = new ContextRegainedEventCallbackDelegate(OnContextRegained);
 447               this.ContextRegainedSignal().Connect(_stageContextRegainedEventCallbackDelegate);
 448            }
 449         }
 450      }
 451
 452      remove
 453      {
 454         lock(this)
 455         {
 456            if (_stageContextRegainedEventHandler != null)
 457            {
 458               this.ContextRegainedSignal().Disconnect(_stageContextRegainedEventCallbackDelegate);
 459            }
 460
 461            _stageContextRegainedEventHandler -= value;
 462         }
 463      }
 464   }
 465
 466   // Callback for Stage ContextRegainedSignal
 467   private void OnContextRegained()
 468   {
 469      ContextRegainedEventArgs e = new ContextRegainedEventArgs();
 470
 471      if (_stageContextRegainedEventHandler != null)
 472      {
 473         //here we send all data to user event handlers
 474         _stageContextRegainedEventHandler(this, e);
 475      }
 476   }
 477
 478   /**
 479     * @brief Event for SceneCreated signal which can be used to subscribe/unsubscribe the event handler
 480     * (in the type of SceneCreatedEventHandler-DaliEventHandler<object,SceneCreatedEventArgs>) provided by the user.
 481     * SceneCreated signal is emitted after the initial scene is created.
 482     *
 483     */
 484   public event DaliEventHandler<object,SceneCreatedEventArgs> SceneCreated
 485   {
 486      add
 487      {
 488         lock(this)
 489         {
 490            // Restricted to only one listener
 491            if (_stageSceneCreatedEventHandler == null)
 492            {
 493               _stageSceneCreatedEventHandler += value;
 494
 495               _stageSceneCreatedEventCallbackDelegate = new SceneCreatedEventCallbackDelegate(OnSceneCreated);
 496               this.SceneCreatedSignal().Connect(_stageSceneCreatedEventCallbackDelegate);
 497            }
 498         }
 499      }
 500
 501      remove
 502      {
 503         lock(this)
 504         {
 505            if (_stageSceneCreatedEventHandler != null)
 506            {
 507               this.SceneCreatedSignal().Disconnect(_stageSceneCreatedEventCallbackDelegate);
 508            }
 509
 510            _stageSceneCreatedEventHandler -= value;
 511         }
 512      }
 513   }
 514
 515   // Callback for Stage SceneCreatedSignal
 516   private void OnSceneCreated()
 517   {
 518      SceneCreatedEventArgs e = new SceneCreatedEventArgs();
 519
 520      if (_stageSceneCreatedEventHandler != null)
 521      {
 522         //here we send all data to user event handlers
 523         _stageSceneCreatedEventHandler(this, e);
 524      }
 525   }
 526
 527   public Vector2 Size
 528   {
 529      get
 530      {
 531         Vector2 ret = GetSize();
 532         return ret;
 533      }
 534   }
 535
 536   public Vector4 BackgroundColor
 537   {
 538      set
 539      {
 540         SetBackgroundColor(value);
 541      }
 542      get
 543      {
 544         Vector4 ret = GetBackgroundColor();
 545         return ret;
 546      }
 547    }
 548
 549 %}
 550
 551 %enddef
 552
 553
 554 %define DALI_STAGE_EVENTHANDLER_PARAM( NameSpace, ClassName)
 555
 556   STAGE_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
 557   STAGE_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
 558
 559 %enddef
 560
 561 namespace Dali
 562 {
 563   DALI_STAGE_EVENTHANDLER_PARAM( Dali, Stage);
 564 }