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   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 138   public delegate void TouchEventHandler(object source, TouchEventArgs e);
 139
 140   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 141   public delegate void WheelEventHandler(object source, WheelEventArgs e);
 142
 143   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 144   public delegate void KeyEventHandler(object source, KeyEventArgs e);
 145
 146   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 147   public delegate void EventProcessingFinishedEventHandler(object source, EventProcessingFinishedEventArgs e);
 148
 149   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 150   public delegate void ContextLostEventHandler(object source, ContextLostEventArgs e);
 151
 152   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 153   public delegate void ContextRegainedEventHandler(object source, ContextRegainedEventArgs e);
 154
 155   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 156   public delegate void SceneCreatedEventHandler(object source, SceneCreatedEventArgs e);
 157
 158   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 159   private delegate void StageTouchCallbackDelegate(IntPtr data);
 160   private TouchEventHandler _stageTouchEventHandler;
 161   private StageTouchCallbackDelegate _stageTouchCallbackDelegate;
 162
 163   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 164   private delegate void WheelCallbackDelegate(IntPtr data);
 165   private WheelEventHandler _stageWheelEventHandler;
 166   private WheelCallbackDelegate _stageWheelCallbackDelegate;
 167
 168   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 169   private delegate void KeyCallbackDelegate(IntPtr data);
 170   private KeyEventHandler _stageKeyEventHandler;
 171   private KeyCallbackDelegate _stageKeyCallbackDelegate;
 172
 173   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 174   private delegate void EventProcessingFinishedEventCallbackDelegate();
 175   private EventProcessingFinishedEventHandler _stageEventProcessingFinishedEventHandler;
 176   private EventProcessingFinishedEventCallbackDelegate _stageEventProcessingFinishedEventCallbackDelegate;
 177
 178   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 179   private delegate void ContextLostEventCallbackDelegate();
 180   private ContextLostEventHandler _stageContextLostEventHandler;
 181   private ContextLostEventCallbackDelegate _stageContextLostEventCallbackDelegate;
 182
 183   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 184   private delegate void ContextRegainedEventCallbackDelegate();
 185   private ContextRegainedEventHandler _stageContextRegainedEventHandler;
 186   private ContextRegainedEventCallbackDelegate _stageContextRegainedEventCallbackDelegate;
 187
 188   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 189   private delegate void SceneCreatedEventCallbackDelegate();
 190   private SceneCreatedEventHandler _stageSceneCreatedEventHandler;
 191   private SceneCreatedEventCallbackDelegate _stageSceneCreatedEventCallbackDelegate;
 192
 193   /**
 194     * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler
 195     * (in the type of TouchEventHandler) provided by the user.
 196     * Touched signal is emitted when the screen is touched and when the touch ends
 197     * (i.e. the down & up touch events only).
 198     *
 199     */
 200   public event TouchEventHandler Touched
 201   {
 202      add
 203      {
 204         lock(this)
 205         {
 206            // Restricted to only one listener
 207            if (_stageTouchEventHandler == null)
 208            {
 209               _stageTouchEventHandler += value;
 210
 211               _stageTouchCallbackDelegate = new StageTouchCallbackDelegate(OnStageTouch);
 212               this.TouchSignal().Connect(_stageTouchCallbackDelegate);
 213            }
 214         }
 215      }
 216
 217      remove
 218      {
 219         lock(this)
 220         {
 221            if (_stageTouchEventHandler != null)
 222            {
 223               this.TouchSignal().Disconnect(_stageTouchCallbackDelegate);
 224            }
 225
 226            _stageTouchEventHandler -= value;
 227         }
 228      }
 229   }
 230
 231   // Callback for Stage Touch signal
 232   private void OnStageTouch(IntPtr data)
 233   {
 234      TouchEventArgs e = new TouchEventArgs();
 235
 236      // Populate all members of "e" (TouchEventArgs) with real data
 237      e.TouchData = TouchData.GetTouchDataFromPtr( data );
 238
 239      if (_stageTouchEventHandler != null)
 240      {
 241         //here we send all data to user event handlers
 242         _stageTouchEventHandler(this, e);
 243      }
 244   }
 245
 246   /**
 247     * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
 248     * (in the type of WheelEventHandler) provided by the user.
 249     * WheelMoved signal is emitted is emitted when wheel event is received.
 250     *
 251     */
 252   public event WheelEventHandler WheelMoved
 253   {
 254      add
 255      {
 256         lock(this)
 257         {
 258            // Restricted to only one listener
 259            if (_stageWheelEventHandler == null)
 260            {
 261               _stageWheelEventHandler += value;
 262
 263               _stageWheelCallbackDelegate = new WheelCallbackDelegate(OnStageWheel);
 264               this.WheelEventSignal().Connect(_stageWheelCallbackDelegate);
 265            }
 266         }
 267      }
 268
 269      remove
 270      {
 271         lock(this)
 272         {
 273            if (_stageWheelEventHandler != null)
 274            {
 275               this.WheelEventSignal().Disconnect(_stageWheelCallbackDelegate);
 276            }
 277
 278            _stageWheelEventHandler -= value;
 279         }
 280      }
 281   }
 282
 283   // Callback for Stage WheelEventsignal
 284   private void OnStageWheel(IntPtr data)
 285   {
 286      WheelEventArgs e = new WheelEventArgs();
 287
 288      // Populate all members of "e" (WheelEventArgs) with real data
 289      e.WheelEvent = Dali.WheelEvent.GetWheelEventFromPtr( data );
 290
 291      if (_stageWheelEventHandler != null)
 292      {
 293         //here we send all data to user event handlers
 294         _stageWheelEventHandler(this, e);
 295      }
 296   }
 297
 298   /**
 299     * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
 300     * (in the type of KeyEventHandler) provided by the user.
 301     * KeyPressed signal is emitted is emitted when key event is received.
 302     *
 303     */
 304   public event KeyEventHandler KeyPressed
 305   {
 306      add
 307      {
 308         lock(this)
 309         {
 310            // Restricted to only one listener
 311            if (_stageKeyEventHandler == null)
 312            {
 313               _stageKeyEventHandler += value;
 314
 315               _stageKeyCallbackDelegate = new KeyCallbackDelegate(OnStageKey);
 316               this.KeyEventSignal().Connect(_stageKeyCallbackDelegate);
 317            }
 318         }
 319      }
 320
 321      remove
 322      {
 323         lock(this)
 324         {
 325            if (_stageKeyEventHandler != null)
 326            {
 327               this.KeyEventSignal().Disconnect(_stageKeyCallbackDelegate);
 328            }
 329
 330            _stageKeyEventHandler -= value;
 331         }
 332      }
 333   }
 334
 335   // Callback for Stage KeyEventsignal
 336   private void OnStageKey(IntPtr keyEvent)
 337   {
 338      KeyEventArgs e = new KeyEventArgs();
 339
 340      // Populate all members of "e" (KeyEventArgs) with real data
 341      e.KeyEvent = Dali.KeyEvent.GetKeyEventFromPtr( keyEvent );
 342
 343      if (_stageKeyEventHandler != null)
 344      {
 345         //here we send all data to user event handlers
 346         _stageKeyEventHandler(this, e);
 347      }
 348   }
 349
 350   /**
 351     * @brief Event for EventProcessingFinished signal which can be used to subscribe/unsubscribe the event handler
 352     * (in the type of EventProcessingFinishedEventHandler) provided by the user.
 353     * EventProcessingFinished signal is emitted just after the event processing is finished.
 354     *
 355     */
 356   public event EventProcessingFinishedEventHandler EventProcessingFinished
 357   {
 358      add
 359      {
 360         lock(this)
 361         {
 362            // Restricted to only one listener
 363            if (_stageEventProcessingFinishedEventHandler == null)
 364            {
 365               _stageEventProcessingFinishedEventHandler += value;
 366
 367               _stageEventProcessingFinishedEventCallbackDelegate = new EventProcessingFinishedEventCallbackDelegate(OnEventProcessingFinished);
 368               this.EventProcessingFinishedSignal().Connect(_stageEventProcessingFinishedEventCallbackDelegate);
 369            }
 370         }
 371      }
 372
 373      remove
 374      {
 375         lock(this)
 376         {
 377            if (_stageEventProcessingFinishedEventHandler != null)
 378            {
 379               this.EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate);
 380            }
 381
 382            _stageEventProcessingFinishedEventHandler -= value;
 383         }
 384      }
 385   }
 386
 387   // Callback for Stage EventProcessingFinishedSignal
 388   private void OnEventProcessingFinished()
 389   {
 390      EventProcessingFinishedEventArgs e = new EventProcessingFinishedEventArgs();
 391
 392      if (_stageEventProcessingFinishedEventHandler != null)
 393      {
 394         //here we send all data to user event handlers
 395         _stageEventProcessingFinishedEventHandler(this, e);
 396      }
 397   }
 398
 399   /**
 400     * @brief Event for ContextLost signal which can be used to subscribe/unsubscribe the event handler
 401     * (in the type of ContextLostEventHandler) provided by the user.
 402     * ContextLost signal is emitted when the GL context is lost (Platform specific behaviour).
 403     *
 404     */
 405   public event ContextLostEventHandler ContextLost
 406   {
 407      add
 408      {
 409         lock(this)
 410         {
 411            // Restricted to only one listener
 412            if (_stageContextLostEventHandler == null)
 413            {
 414               _stageContextLostEventHandler += value;
 415
 416               _stageContextLostEventCallbackDelegate = new ContextLostEventCallbackDelegate(OnContextLost);
 417               this.ContextLostSignal().Connect(_stageContextLostEventCallbackDelegate);
 418            }
 419         }
 420      }
 421
 422      remove
 423      {
 424         lock(this)
 425         {
 426            if (_stageContextLostEventHandler != null)
 427            {
 428               this.ContextLostSignal().Disconnect(_stageContextLostEventCallbackDelegate);
 429            }
 430
 431            _stageContextLostEventHandler -= value;
 432         }
 433      }
 434   }
 435
 436   // Callback for Stage ContextLostSignal
 437   private void OnContextLost()
 438   {
 439      ContextLostEventArgs e = new ContextLostEventArgs();
 440
 441      if (_stageContextLostEventHandler != null)
 442      {
 443         //here we send all data to user event handlers
 444         _stageContextLostEventHandler(this, e);
 445      }
 446   }
 447
 448   /**
 449     * @brief Event for ContextRegained signal which can be used to subscribe/unsubscribe the event handler
 450     * (in the type of ContextRegainedEventHandler) provided by the user.
 451     * ContextRegained signal is emitted when the GL context is regained (Platform specific
 452     * behaviour).
 453     *
 454     */
 455   public event ContextRegainedEventHandler ContextRegained
 456   {
 457      add
 458      {
 459         lock(this)
 460         {
 461            // Restricted to only one listener
 462            if (_stageContextRegainedEventHandler == null)
 463            {
 464               _stageContextRegainedEventHandler += value;
 465
 466               _stageContextRegainedEventCallbackDelegate = new ContextRegainedEventCallbackDelegate(OnContextRegained);
 467               this.ContextRegainedSignal().Connect(_stageContextRegainedEventCallbackDelegate);
 468            }
 469         }
 470      }
 471
 472      remove
 473      {
 474         lock(this)
 475         {
 476            if (_stageContextRegainedEventHandler != null)
 477            {
 478               this.ContextRegainedSignal().Disconnect(_stageContextRegainedEventCallbackDelegate);
 479            }
 480
 481            _stageContextRegainedEventHandler -= value;
 482         }
 483      }
 484   }
 485
 486   // Callback for Stage ContextRegainedSignal
 487   private void OnContextRegained()
 488   {
 489      ContextRegainedEventArgs e = new ContextRegainedEventArgs();
 490
 491      if (_stageContextRegainedEventHandler != null)
 492      {
 493         //here we send all data to user event handlers
 494         _stageContextRegainedEventHandler(this, e);
 495      }
 496   }
 497
 498   /**
 499     * @brief Event for SceneCreated signal which can be used to subscribe/unsubscribe the event handler
 500     * (in the type of SceneCreatedEventHandler) provided by the user.
 501     * SceneCreated signal is emitted after the initial scene is created.
 502     *
 503     */
 504   public event SceneCreatedEventHandler SceneCreated
 505   {
 506      add
 507      {
 508         lock(this)
 509         {
 510            // Restricted to only one listener
 511            if (_stageSceneCreatedEventHandler == null)
 512            {
 513               _stageSceneCreatedEventHandler += value;
 514
 515               _stageSceneCreatedEventCallbackDelegate = new SceneCreatedEventCallbackDelegate(OnSceneCreated);
 516               this.SceneCreatedSignal().Connect(_stageSceneCreatedEventCallbackDelegate);
 517            }
 518         }
 519      }
 520
 521      remove
 522      {
 523         lock(this)
 524         {
 525            if (_stageSceneCreatedEventHandler != null)
 526            {
 527               this.SceneCreatedSignal().Disconnect(_stageSceneCreatedEventCallbackDelegate);
 528            }
 529
 530            _stageSceneCreatedEventHandler -= value;
 531         }
 532      }
 533   }
 534
 535   // Callback for Stage SceneCreatedSignal
 536   private void OnSceneCreated()
 537   {
 538      SceneCreatedEventArgs e = new SceneCreatedEventArgs();
 539
 540      if (_stageSceneCreatedEventHandler != null)
 541      {
 542         //here we send all data to user event handlers
 543         _stageSceneCreatedEventHandler(this, e);
 544      }
 545   }
 546
 547 %}
 548
 549 %enddef
 550
 551
 552 %define DALI_STAGE_EVENTHANDLER_PARAM( NameSpace, ClassName)
 553
 554   STAGE_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
 555   STAGE_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
 556
 557 %enddef
 558
 559 namespace Dali
 560 {
 561   DALI_STAGE_EVENTHANDLER_PARAM( Dali, Stage);
 562 }