dali-csharp-binder/src/gestures.cpp

   1 /*
   2  * Copyright (c) 2019 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 #ifndef CSHARP_GESTURES
  19 #define CSHARP_GESTURES
  20 #endif
  21
  22 #include "common.h"
  23 #include <dali/devel-api/events/gesture-devel.h>
  24 #include <dali/devel-api/events/rotation-gesture.h>
  25 #include <dali/devel-api/events/rotation-gesture-detector.h>
  26
  27 #ifdef __cplusplus
  28 extern "C" {
  29 #endif
  30
  31 using namespace Dali;
  32
  33 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > const *self)
  34 {
  35   return self->Empty();
  36 }
  37
  38 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > const *self)
  39 {
  40   return self->GetConnectionCount();
  41 }
  42
  43 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *self,void (*func)(Dali::Actor,Dali::RotationGesture const &))
  44 {
  45   self->Connect( func );
  46 }
  47
  48 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *self,void (*func)(Dali::Actor,Dali::RotationGesture const &))
  49 {
  50   self->Disconnect( func );
  51 }
  52
  53 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *self,Dali::Actor arg1,Dali::RotationGesture const &arg2)
  54 {
  55   self->Emit( arg1, arg2 );
  56 }
  57
  58 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RotationGestureDetector__SWIG_0()
  59 {
  60   void * jresult ;
  61   Dali::RotationGestureDetector *result = 0 ;
  62
  63   {
  64     try {
  65       result = (Dali::RotationGestureDetector *)new Dali::RotationGestureDetector();
  66     } catch (std::out_of_range& e) {
  67       {
  68         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
  69       };
  70     } catch (std::exception& e) {
  71       {
  72         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
  73       };
  74     } catch (Dali::DaliException& e) {
  75       {
  76         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
  77       };
  78     } catch (...) {
  79       {
  80         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
  81       };
  82     }
  83   }
  84
  85   jresult = (void *)result;
  86   return jresult;
  87 }
  88
  89 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGestureDetector_New() {
  90   void * jresult ;
  91   Dali::RotationGestureDetector result;
  92
  93   {
  94     try {
  95       result = Dali::RotationGestureDetector::New();
  96     } catch (std::out_of_range& e) {
  97       {
  98         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
  99       };
 100     } catch (std::exception& e) {
 101       {
 102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 103       };
 104     } catch (Dali::DaliException& e) {
 105       {
 106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 107       };
 108     } catch (...) {
 109       {
 110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 111       };
 112     }
 113   }
 114
 115   jresult = new Dali::RotationGestureDetector((const Dali::RotationGestureDetector &)result);
 116   return jresult;
 117 }
 118
 119
 120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGestureDetector_DownCast(void * jarg1) {
 121   void * jresult ;
 122   Dali::BaseHandle arg1 ;
 123   Dali::BaseHandle *argp1 ;
 124   Dali::RotationGestureDetector result;
 125
 126   argp1 = (Dali::BaseHandle *)jarg1;
 127   if (!argp1) {
 128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
 129     return 0;
 130   }
 131   arg1 = *argp1;
 132   {
 133     try {
 134       result = Dali::RotationGestureDetector::DownCast(arg1);
 135     } catch (std::out_of_range& e) {
 136       {
 137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 138       };
 139     } catch (std::exception& e) {
 140       {
 141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 142       };
 143     } catch (Dali::DaliException& e) {
 144       {
 145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 146       };
 147     } catch (...) {
 148       {
 149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 150       };
 151     }
 152   }
 153
 154   jresult = new Dali::RotationGestureDetector((const Dali::RotationGestureDetector &)result);
 155   return jresult;
 156 }
 157
 158
 159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RotationGestureDetector(void * jarg1) {
 160   Dali::RotationGestureDetector *arg1 = (Dali::RotationGestureDetector *) 0 ;
 161
 162   arg1 = (Dali::RotationGestureDetector *)jarg1;
 163   {
 164     try {
 165       delete arg1;
 166     } catch (std::out_of_range& e) {
 167       {
 168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 169       };
 170     } catch (std::exception& e) {
 171       {
 172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 173       };
 174     } catch (Dali::DaliException& e) {
 175       {
 176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 177       };
 178     } catch (...) {
 179       {
 180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 181       };
 182     }
 183   }
 184
 185 }
 186
 187
 188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RotationGestureDetector__SWIG_1(void * jarg1) {
 189   void * jresult ;
 190   Dali::RotationGestureDetector *arg1 = 0 ;
 191   Dali::RotationGestureDetector *result = 0 ;
 192
 193   arg1 = (Dali::RotationGestureDetector *)jarg1;
 194   if (!arg1) {
 195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RotationGestureDetector const & type is null", 0);
 196     return 0;
 197   }
 198   {
 199     try {
 200       result = (Dali::RotationGestureDetector *)new Dali::RotationGestureDetector((Dali::RotationGestureDetector const &)*arg1);
 201     } catch (std::out_of_range& e) {
 202       {
 203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 204       };
 205     } catch (std::exception& e) {
 206       {
 207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 208       };
 209     } catch (Dali::DaliException& e) {
 210       {
 211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 212       };
 213     } catch (...) {
 214       {
 215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 216       };
 217     }
 218   }
 219
 220   jresult = (void *)result;
 221   return jresult;
 222 }
 223
 224
 225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGestureDetector_Assign(void * jarg1, void * jarg2) {
 226   void * jresult ;
 227   Dali::RotationGestureDetector *arg1 = (Dali::RotationGestureDetector *) 0 ;
 228   Dali::RotationGestureDetector *arg2 = 0 ;
 229   Dali::RotationGestureDetector *result = 0 ;
 230
 231   arg1 = (Dali::RotationGestureDetector *)jarg1;
 232   arg2 = (Dali::RotationGestureDetector *)jarg2;
 233   if (!arg2) {
 234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RotationGestureDetector const & type is null", 0);
 235     return 0;
 236   }
 237   {
 238     try {
 239       result = (Dali::RotationGestureDetector *) &(arg1)->operator =((Dali::RotationGestureDetector const &)*arg2);
 240     } catch (std::out_of_range& e) {
 241       {
 242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 243       };
 244     } catch (std::exception& e) {
 245       {
 246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 247       };
 248     } catch (Dali::DaliException& e) {
 249       {
 250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 251       };
 252     } catch (...) {
 253       {
 254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 255       };
 256     }
 257   }
 258
 259   jresult = (void *)result;
 260   return jresult;
 261 }
 262
 263
 264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGestureDetector_DetectedSignal(void * jarg1) {
 265   void * jresult ;
 266   Dali::RotationGestureDetector *arg1 = (Dali::RotationGestureDetector *) 0 ;
 267   Dali::RotationGestureDetector::DetectedSignalType *result = 0 ;
 268
 269   arg1 = (Dali::RotationGestureDetector *)jarg1;
 270   {
 271     try {
 272       result = (Dali::RotationGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
 273     } catch (std::out_of_range& e) {
 274       {
 275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 276       };
 277     } catch (std::exception& e) {
 278       {
 279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 280       };
 281     } catch (Dali::DaliException& e) {
 282       {
 283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 284       };
 285     } catch (...) {
 286       {
 287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 288       };
 289     }
 290   }
 291
 292   jresult = (void *)result;
 293   return jresult;
 294 }
 295
 296
 297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RotationGesture__SWIG_0(int jarg1) {
 298   void * jresult ;
 299   Dali::Gesture::State arg1 ;
 300   Dali::RotationGesture *result = 0 ;
 301
 302   arg1 = (Dali::Gesture::State)jarg1;
 303   {
 304     try {
 305       result = (Dali::RotationGesture *)new Dali::RotationGesture(arg1);
 306     } catch (std::out_of_range& e) {
 307       {
 308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 309       };
 310     } catch (std::exception& e) {
 311       {
 312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 313       };
 314     } catch (Dali::DaliException& e) {
 315       {
 316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 317       };
 318     } catch (...) {
 319       {
 320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 321       };
 322     }
 323   }
 324
 325   jresult = (void *)result;
 326   return jresult;
 327 }
 328
 329
 330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RotationGesture__SWIG_1(void * jarg1) {
 331   void * jresult ;
 332   Dali::RotationGesture *arg1 = 0 ;
 333   Dali::RotationGesture *result = 0 ;
 334
 335   arg1 = (Dali::RotationGesture *)jarg1;
 336   if (!arg1) {
 337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RotationGesture const & type is null", 0);
 338     return 0;
 339   }
 340   {
 341     try {
 342       result = (Dali::RotationGesture *)new Dali::RotationGesture((Dali::RotationGesture const &)*arg1);
 343     } catch (std::out_of_range& e) {
 344       {
 345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 346       };
 347     } catch (std::exception& e) {
 348       {
 349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 350       };
 351     } catch (Dali::DaliException& e) {
 352       {
 353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 354       };
 355     } catch (...) {
 356       {
 357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 358       };
 359     }
 360   }
 361
 362   jresult = (void *)result;
 363   return jresult;
 364 }
 365
 366
 367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGesture_Assign(void * jarg1, void * jarg2) {
 368   void * jresult ;
 369   Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ;
 370   Dali::RotationGesture *arg2 = 0 ;
 371   Dali::RotationGesture *result = 0 ;
 372
 373   arg1 = (Dali::RotationGesture *)jarg1;
 374   arg2 = (Dali::RotationGesture *)jarg2;
 375   if (!arg2) {
 376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RotationGesture const & type is null", 0);
 377     return 0;
 378   }
 379   {
 380     try {
 381       result = (Dali::RotationGesture *) &(arg1)->operator =((Dali::RotationGesture const &)*arg2);
 382     } catch (std::out_of_range& e) {
 383       {
 384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 385       };
 386     } catch (std::exception& e) {
 387       {
 388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 389       };
 390     } catch (Dali::DaliException& e) {
 391       {
 392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 393       };
 394     } catch (...) {
 395       {
 396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 397       };
 398     }
 399   }
 400
 401   jresult = (void *)result;
 402   return jresult;
 403 }
 404
 405
 406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RotationGesture(void * jarg1) {
 407   Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ;
 408
 409   arg1 = (Dali::RotationGesture *)jarg1;
 410   {
 411     try {
 412       delete arg1;
 413     } catch (std::out_of_range& e) {
 414       {
 415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 416       };
 417     } catch (std::exception& e) {
 418       {
 419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 420       };
 421     } catch (Dali::DaliException& e) {
 422       {
 423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 424       };
 425     } catch (...) {
 426       {
 427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 428       };
 429     }
 430   }
 431
 432 }
 433
 434
 435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RotationGesture_rotation_set(void * jarg1, float jarg2) {
 436   Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ;
 437   float arg2 ;
 438
 439   arg1 = (Dali::RotationGesture *)jarg1;
 440   arg2 = (float)jarg2;
 441   if (arg1) (arg1)->rotation = arg2;
 442 }
 443
 444
 445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RotationGesture_rotation_get(void * jarg1) {
 446   float jresult ;
 447   Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ;
 448   float result;
 449
 450   arg1 = (Dali::RotationGesture *)jarg1;
 451   result = (float) ((arg1)->rotation.radian);
 452   jresult = result;
 453   return jresult;
 454 }
 455
 456
 457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RotationGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
 458   Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ;
 459   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
 460
 461   arg1 = (Dali::RotationGesture *)jarg1;
 462   arg2 = (Dali::Vector2 *)jarg2;
 463   if (arg1) (arg1)->screenCenterPoint = *arg2;
 464 }
 465
 466
 467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGesture_screenCenterPoint_get(void * jarg1) {
 468   void * jresult ;
 469   Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ;
 470   Dali::Vector2 *result = 0 ;
 471
 472   arg1 = (Dali::RotationGesture *)jarg1;
 473   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
 474   jresult = (void *)result;
 475   return jresult;
 476 }
 477
 478
 479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RotationGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
 480   Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ;
 481   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
 482
 483   arg1 = (Dali::RotationGesture *)jarg1;
 484   arg2 = (Dali::Vector2 *)jarg2;
 485   if (arg1) (arg1)->localCenterPoint = *arg2;
 486 }
 487
 488
 489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGesture_localCenterPoint_get(void * jarg1) {
 490   void * jresult ;
 491   Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ;
 492   Dali::Vector2 *result = 0 ;
 493
 494   arg1 = (Dali::RotationGesture *)jarg1;
 495   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
 496   jresult = (void *)result;
 497   return jresult;
 498 }
 499
 500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RotationGestureDetectedSignal_Empty(void * jarg1) {
 501   unsigned int jresult ;
 502   Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ;
 503   bool result;
 504
 505   arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1;
 506   {
 507     try {
 508       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > const *)arg1);
 509     } catch (std::out_of_range& e) {
 510       {
 511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 512       };
 513     } catch (std::exception& e) {
 514       {
 515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 516       };
 517     } catch (Dali::DaliException& e) {
 518       {
 519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 520       };
 521     } catch (...) {
 522       {
 523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 524       };
 525     }
 526   }
 527
 528   jresult = result;
 529   return jresult;
 530 }
 531
 532
 533 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_RotationGestureDetectedSignal_GetConnectionCount(void * jarg1) {
 534   unsigned long jresult ;
 535   Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ;
 536   std::size_t result;
 537
 538   arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1;
 539   {
 540     try {
 541       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > const *)arg1);
 542     } catch (std::out_of_range& e) {
 543       {
 544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 545       };
 546     } catch (std::exception& e) {
 547       {
 548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 549       };
 550     } catch (Dali::DaliException& e) {
 551       {
 552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 553       };
 554     } catch (...) {
 555       {
 556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 557       };
 558     }
 559   }
 560
 561   jresult = (unsigned long)result;
 562   return jresult;
 563 }
 564
 565
 566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RotationGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
 567   Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ;
 568   void (*arg2)(Dali::Actor,Dali::RotationGesture const &) = (void (*)(Dali::Actor,Dali::RotationGesture const &)) 0 ;
 569
 570   arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1;
 571   arg2 = (void (*)(Dali::Actor,Dali::RotationGesture const &))jarg2;
 572   {
 573     try {
 574       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
 575     } catch (std::out_of_range& e) {
 576       {
 577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 578       };
 579     } catch (std::exception& e) {
 580       {
 581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 582       };
 583     } catch (Dali::DaliException& e) {
 584       {
 585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 586       };
 587     } catch (...) {
 588       {
 589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 590       };
 591     }
 592   }
 593
 594 }
 595
 596
 597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RotationGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
 598   Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ;
 599   void (*arg2)(Dali::Actor,Dali::RotationGesture const &) = (void (*)(Dali::Actor,Dali::RotationGesture const &)) 0 ;
 600
 601   arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1;
 602   arg2 = (void (*)(Dali::Actor,Dali::RotationGesture const &))jarg2;
 603   {
 604     try {
 605       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
 606     } catch (std::out_of_range& e) {
 607       {
 608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 609       };
 610     } catch (std::exception& e) {
 611       {
 612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 613       };
 614     } catch (Dali::DaliException& e) {
 615       {
 616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 617       };
 618     } catch (...) {
 619       {
 620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 621       };
 622     }
 623   }
 624
 625 }
 626
 627
 628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RotationGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
 629   Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ;
 630   Dali::Actor arg2 ;
 631   Dali::RotationGesture *arg3 = 0 ;
 632   Dali::Actor *argp2 ;
 633
 634   arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1;
 635   argp2 = (Dali::Actor *)jarg2;
 636   if (!argp2) {
 637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 638     return ;
 639   }
 640   arg2 = *argp2;
 641   arg3 = (Dali::RotationGesture *)jarg3;
 642   if (!arg3) {
 643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RotationGesture const & type is null", 0);
 644     return ;
 645   }
 646   {
 647     try {
 648       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::RotationGesture const &)*arg3);
 649     } catch (std::out_of_range& e) {
 650       {
 651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 652       };
 653     } catch (std::exception& e) {
 654       {
 655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 656       };
 657     } catch (Dali::DaliException& e) {
 658       {
 659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 660       };
 661     } catch (...) {
 662       {
 663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 664       };
 665     }
 666   }
 667
 668 }
 669
 670
 671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RotationGestureDetectedSignal() {
 672   void * jresult ;
 673   Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *result = 0 ;
 674
 675   {
 676     try {
 677       result = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) >();
 678     } catch (std::out_of_range& e) {
 679       {
 680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 681       };
 682     } catch (std::exception& e) {
 683       {
 684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 685       };
 686     } catch (Dali::DaliException& e) {
 687       {
 688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 689       };
 690     } catch (...) {
 691       {
 692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 693       };
 694     }
 695   }
 696
 697   jresult = (void *)result;
 698   return jresult;
 699 }
 700
 701
 702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RotationGestureDetectedSignal(void * jarg1) {
 703   Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ;
 704
 705   arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1;
 706   {
 707     try {
 708       delete arg1;
 709     } catch (std::out_of_range& e) {
 710       {
 711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 712       };
 713     } catch (std::exception& e) {
 714       {
 715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 716       };
 717     } catch (Dali::DaliException& e) {
 718       {
 719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 720       };
 721     } catch (...) {
 722       {
 723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 724       };
 725     }
 726   }
 727
 728 }
 729
 730 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_RotationGestureDetector_SWIGUpcast(Dali::RotationGestureDetector *jarg1) {
 731     return (Dali::GestureDetector *)jarg1;
 732 }
 733
 734 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_RotationGesture_SWIGUpcast(Dali::RotationGesture *jarg1) {
 735     return (Dali::Gesture *)jarg1;
 736 }
 737
 738 #ifdef __cplusplus
 739 }
 740 #endif
 741