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