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   /**
  31     * @brief Event arguments that passed via Touch signal
  32     *
  33     */
  34   public class TouchEventArgs : EventArgs
  35   {
  36      private TouchData _touchData;
  37
  38      /**
  39        * @brief TouchData - contains the information of touch points
  40        *
  41        */
  42      public TouchData TouchData
  43      {
  44         get
  45         {
  46            return _touchData;
  47         }
  48         set
  49         {
  50            _touchData = value;
  51         }
  52      }
  53   }
  54
  55   private event EventHandler<TouchEventArgs> _stageTouchEventHandler;
  56   private EventCallbackDelegateType1<IntPtr> _stageTouchCallbackDelegate;
  57
  58   /**
  59     * @brief Event for TouchEvent signal which can be used to subscribe/unsubscribe the event handler
  60     * TouchEvent signal is emitted when the screen is touched and when the touch ends
  61     * (i.e. the down & up touch events only).
  62     *
  63     */
  64   public event EventHandler<TouchEventArgs> TouchEvent
  65   {
  66      add
  67      {
  68         lock(this)
  69         {
  70           _stageTouchEventHandler += value;
  71           _stageTouchCallbackDelegate = OnStageTouch;
  72           this.TouchSignal().Connect(_stageTouchCallbackDelegate);
  73         }
  74      }
  75      remove
  76      {
  77         lock(this)
  78         {
  79            if (_stageTouchEventHandler != null)
  80            {
  81               this.TouchSignal().Disconnect(_stageTouchCallbackDelegate);
  82            }
  83            _stageTouchEventHandler -= value;
  84         }
  85      }
  86   }
  87
  88   private void OnStageTouch(IntPtr data)
  89   {
  90     TouchEventArgs e = new TouchEventArgs();
  91
  92     if( data != null )
  93     {
  94       e.TouchData = TouchData.GetTouchDataFromPtr( data );
  95     }
  96
  97     if (_stageTouchEventHandler != null)
  98     {
  99       _stageTouchEventHandler(this, e);
 100     }
 101   }
 102
 103
 104   /**
 105     * @brief WheelEvent arguments that passed via Wheel signal
 106     *
 107     */
 108   public class WheelEventArgs : EventArgs
 109   {
 110      private WheelEvent _wheelEvent;
 111
 112      /**
 113        * @brief WheelEvent - store a wheel rolling type MOUSE_WHEEL or CUSTOM_WHEEL
 114        *
 115        */
 116      public WheelEvent WheelEvent
 117      {
 118         get
 119         {
 120            return _wheelEvent;
 121         }
 122         set
 123         {
 124            _wheelEvent = value;
 125         }
 126      }
 127   }
 128
 129   private event EventHandler<WheelEventArgs> _stageWheelEventHandler;
 130   private EventCallbackDelegateType1<IntPtr> _stageWheelCallbackDelegate;
 131
 132   /**
 133     * @brief Event for WheelEvent signal which can be used to subscribe/unsubscribe the event handler
 134     * WheelEvent signal is emitted is emitted when wheel event is received.
 135     *
 136     */
 137   public event EventHandler<WheelEventArgs> WheelEvent
 138   {
 139      add
 140      {
 141         lock(this)
 142         {
 143           _stageWheelEventHandler += value;
 144           _stageWheelCallbackDelegate = OnStageWheel;
 145           this.WheelEventSignal().Connect(_stageWheelCallbackDelegate);
 146         }
 147      }
 148      remove
 149      {
 150         lock(this)
 151         {
 152            if (_stageWheelEventHandler != null)
 153            {
 154               this.WheelEventSignal().Disconnect(_stageWheelCallbackDelegate);
 155            }
 156            _stageWheelEventHandler -= value;
 157         }
 158      }
 159   }
 160
 161   private void OnStageWheel(IntPtr data)
 162   {
 163     WheelEventArgs e = new WheelEventArgs();
 164
 165     if( data != null )
 166     {
 167       e.WheelEvent = Dali.WheelEvent.GetWheelEventFromPtr( data );
 168     }
 169
 170     if (_stageWheelEventHandler != null)
 171     {
 172       _stageWheelEventHandler(this, e);
 173     }
 174   }
 175
 176   /**
 177     * @brief Event arguments that passed via KeyEvent signal
 178     *
 179     */
 180   public class KeyEventArgs : EventArgs
 181   {
 182      private KeyEvent _keyEvent;
 183
 184      /**
 185        * @brief KeyEvent - is the keyevent sent to Stage.
 186        *
 187        */
 188      public KeyEvent KeyEvent
 189      {
 190         get
 191         {
 192            return _keyEvent;
 193         }
 194         set
 195         {
 196            _keyEvent = value;
 197         }
 198      }
 199   }
 200
 201   private event EventHandler<KeyEventArgs> _stageKeyEventHandler;
 202   private EventCallbackDelegateType1<IntPtr> _stageKeyCallbackDelegate;
 203
 204   /**
 205     * @brief Event for KeyEvent signal which can be used to subscribe/unsubscribe the event handler
 206     * KeyEvent signal is emitted is emitted when key event is received.
 207     *
 208     */
 209   public event EventHandler<KeyEventArgs> KeyEvent
 210   {
 211      add
 212      {
 213         lock(this)
 214         {
 215             _stageKeyEventHandler += value;
 216             _stageKeyCallbackDelegate = OnStageKey;
 217             this.KeyEventSignal().Connect(_stageKeyCallbackDelegate);
 218         }
 219      }
 220      remove
 221      {
 222         lock(this)
 223         {
 224            if (_stageKeyEventHandler != null)
 225            {
 226               this.KeyEventSignal().Disconnect(_stageKeyCallbackDelegate);
 227            }
 228            _stageKeyEventHandler -= value;
 229         }
 230      }
 231   }
 232
 233   // Callback for Stage KeyEventsignal
 234   private void OnStageKey(IntPtr data)
 235   {
 236     KeyEventArgs e = new KeyEventArgs();
 237
 238     if( data != null )
 239     {
 240       e.KeyEvent = Dali.KeyEvent.GetKeyEventFromPtr( data );
 241     }
 242
 243     if (_stageKeyEventHandler != null)
 244     {
 245       //here we send all data to user event handlers
 246       _stageKeyEventHandler(this, e);
 247     }
 248   }
 249
 250
 251   private event EventHandler _stageEventProcessingFinishedEventHandler;
 252   private EventCallbackDelegateType0 _stageEventProcessingFinishedEventCallbackDelegate;
 253
 254   /**
 255     * @brief Event for EventProcessingFinished signal which can be used to subscribe/unsubscribe the event handler
 256     * provided by the user. EventProcessingFinished signal is emitted just after the event processing is finished.
 257     *
 258     */
 259   public event EventHandler EventProcessingFinished
 260   {
 261      add
 262      {
 263         lock(this)
 264         {
 265           _stageEventProcessingFinishedEventHandler += value;
 266           _stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished;
 267           this.EventProcessingFinishedSignal().Connect(_stageEventProcessingFinishedEventCallbackDelegate);
 268         }
 269      }
 270      remove
 271      {
 272         lock(this)
 273         {
 274            if (_stageEventProcessingFinishedEventHandler != null)
 275            {
 276               this.EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate);
 277            }
 278            _stageEventProcessingFinishedEventHandler -= value;
 279         }
 280      }
 281   }
 282
 283   // Callback for Stage EventProcessingFinishedSignal
 284   private void OnEventProcessingFinished()
 285   {
 286      if (_stageEventProcessingFinishedEventHandler != null)
 287      {
 288         _stageEventProcessingFinishedEventHandler(this, null);
 289      }
 290   }
 291
 292
 293   private EventHandler _stageContextLostEventHandler;
 294   private EventCallbackDelegateType0 _stageContextLostEventCallbackDelegate;
 295
 296   /**
 297     * @brief Event for ContextLost signal which can be used to subscribe/unsubscribe the event handler
 298     * ContextLost signal is emitted when the GL context is lost (Platform specific behaviour).
 299     *
 300     */
 301   public event EventHandler ContextLost
 302   {
 303      add
 304      {
 305         lock(this)
 306         {
 307             _stageContextLostEventHandler += value;
 308             _stageContextLostEventCallbackDelegate = OnContextLost;
 309             this.ContextLostSignal().Connect(_stageContextLostEventCallbackDelegate);
 310         }
 311      }
 312      remove
 313      {
 314         lock(this)
 315         {
 316            if (_stageContextLostEventHandler != null)
 317            {
 318               this.ContextLostSignal().Disconnect(_stageContextLostEventCallbackDelegate);
 319            }
 320
 321            _stageContextLostEventHandler -= value;
 322         }
 323      }
 324   }
 325
 326   // Callback for Stage ContextLostSignal
 327   private void OnContextLost()
 328   {
 329      if (_stageContextLostEventHandler != null)
 330      {
 331         _stageContextLostEventHandler(this, null);
 332      }
 333   }
 334
 335
 336   private EventHandler _stageContextRegainedEventHandler;
 337   private EventCallbackDelegateType0 _stageContextRegainedEventCallbackDelegate;
 338
 339   /**
 340     * @brief Event for ContextRegained signal which can be used to subscribe/unsubscribe the event handler
 341     * provided by the user. ContextRegained signal is emitted when the GL context is regained (Platform specific
 342     * behaviour).
 343     *
 344     */
 345   public event EventHandler ContextRegained
 346   {
 347      add
 348      {
 349         lock(this)
 350         {
 351             _stageContextRegainedEventHandler += value;
 352             _stageContextRegainedEventCallbackDelegate = OnContextRegained;
 353             this.ContextRegainedSignal().Connect(_stageContextRegainedEventCallbackDelegate);
 354         }
 355      }
 356      remove
 357      {
 358         lock(this)
 359         {
 360            if (_stageContextRegainedEventHandler != null)
 361            {
 362               this.ContextRegainedSignal().Disconnect(_stageContextRegainedEventCallbackDelegate);
 363            }
 364
 365            _stageContextRegainedEventHandler -= value;
 366         }
 367      }
 368   }
 369
 370   // Callback for Stage ContextRegainedSignal
 371   private void OnContextRegained()
 372   {
 373      if (_stageContextRegainedEventHandler != null)
 374      {
 375         _stageContextRegainedEventHandler(this, null);
 376      }
 377   }
 378
 379
 380   private EventHandler _stageSceneCreatedEventHandler;
 381   private EventCallbackDelegateType0 _stageSceneCreatedEventCallbackDelegate;
 382
 383   /**
 384     * @brief Event for SceneCreated signal which can be used to subscribe/unsubscribe the event handler
 385     * SceneCreated signal is emitted after the initial scene is created.
 386     *
 387     */
 388   public event EventHandler SceneCreated
 389   {
 390      add
 391      {
 392         lock(this)
 393         {
 394             _stageSceneCreatedEventHandler += value;
 395             _stageSceneCreatedEventCallbackDelegate = OnSceneCreated;
 396             this.SceneCreatedSignal().Connect(_stageSceneCreatedEventCallbackDelegate);
 397         }
 398      }
 399      remove
 400      {
 401         lock(this)
 402         {
 403            if (_stageSceneCreatedEventHandler != null)
 404            {
 405               this.SceneCreatedSignal().Disconnect(_stageSceneCreatedEventCallbackDelegate);
 406            }
 407
 408            _stageSceneCreatedEventHandler -= value;
 409         }
 410      }
 411   }
 412
 413   // Callback for Stage SceneCreatedSignal
 414   private void OnSceneCreated()
 415   {
 416      if (_stageSceneCreatedEventHandler != null)
 417      {
 418         _stageSceneCreatedEventHandler(this, null);
 419      }
 420   }
 421
 422
 423   public Vector2 Size
 424   {
 425      get
 426      {
 427         Vector2 ret = GetSize();
 428         return ret;
 429      }
 430   }
 431
 432   public Vector4 BackgroundColor
 433   {
 434      set
 435      {
 436         SetBackgroundColor(value);
 437      }
 438      get
 439      {
 440         Vector4 ret = GetBackgroundColor();
 441         return ret;
 442      }
 443    }
 444
 445 %}
 446
 447 %enddef
 448
 449
 450 %define DALI_STAGE_EVENTHANDLER_PARAM( NameSpace, ClassName)
 451
 452   STAGE_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
 453   STAGE_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
 454
 455 %enddef
 456
 457 namespace Dali
 458 {
 459   DALI_STAGE_EVENTHANDLER_PARAM( Dali, Stage);
 460 }