dali-csharp-binder/src/adaptor.cpp

   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 #ifndef CSHARP_ADAPTOR
  19 #define CSHARP_ADAPTOR
  20 #endif
  21
  22 #include "common.h"
  23 #include <dali/integration-api/adaptors/adaptor.h>
  24 // #include <dali/public-api/adaptor-framework/application-configuration.h>
  25
  26
  27 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Adaptor &) > const *self){
  28     return self->Empty();
  29 }
  30 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Adaptor &) > const *self){
  31   return self->GetConnectionCount();
  32 }
  33 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Adaptor &) > *self,void (*func)(Dali::Adaptor &)){
  34     self->Connect( func );
  35 }
  36 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Adaptor &) > *self,void (*func)(Dali::Adaptor &)){
  37     self->Disconnect( func );
  38 }
  39 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Adaptor &) > *self,Dali::Adaptor &arg){
  40     self->Emit( arg );
  41 }
  42
  43 #ifdef __cplusplus
  44 extern "C" {
  45 #endif
  46
  47
  48 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Adaptor_New__SWIG_0(void * jarg1) {
  49   void * jresult ;
  50   Dali::Window arg1 ;
  51   Dali::Window *argp1 ;
  52   Dali::Adaptor *result = 0 ;
  53
  54   argp1 = (Dali::Window *)jarg1;
  55   if (!argp1) {
  56     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
  57     return 0;
  58   }
  59   arg1 = *argp1;
  60   {
  61     try {
  62       result = (Dali::Adaptor *) &Dali::Adaptor::New(arg1);
  63     } catch (std::out_of_range& e) {
  64       {
  65         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
  66       };
  67     } catch (std::exception& e) {
  68       {
  69         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
  70       };
  71     } catch (Dali::DaliException e) {
  72       {
  73         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
  74       };
  75     } catch (...) {
  76       {
  77         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
  78       };
  79     }
  80   }
  81
  82   jresult = (void *)result;
  83   return jresult;
  84 }
  85
  86
  87 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Adaptor_New__SWIG_1(void * jarg1, void * jarg2) {
  88   void * jresult ;
  89   Dali::Window arg1 ;
  90   Dali::Configuration::ContextLoss arg2 ;
  91   Dali::Window *argp1 ;
  92   Dali::Configuration::ContextLoss *argp2 ;
  93   Dali::Adaptor *result = 0 ;
  94
  95   argp1 = (Dali::Window *)jarg1;
  96   if (!argp1) {
  97     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
  98     return 0;
  99   }
 100   arg1 = *argp1;
 101   argp2 = (Dali::Configuration::ContextLoss *)jarg2;
 102   if (!argp2) {
 103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Configuration::ContextLoss", 0);
 104     return 0;
 105   }
 106   arg2 = *argp2;
 107   {
 108     try {
 109       result = (Dali::Adaptor *) &Dali::Adaptor::New(arg1,arg2);
 110     } catch (std::out_of_range& e) {
 111       {
 112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 113       };
 114     } catch (std::exception& e) {
 115       {
 116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 117       };
 118     } catch (Dali::DaliException e) {
 119       {
 120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 121       };
 122     } catch (...) {
 123       {
 124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 125       };
 126     }
 127   }
 128
 129   jresult = (void *)result;
 130   return jresult;
 131 }
 132
 133
 134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Adaptor_New__SWIG_2(void * jarg1, void * jarg2) {
 135   void * jresult ;
 136   Dali::Any arg1 ;
 137   Dali::RenderSurfaceInterface *arg2 = 0 ;
 138   Dali::Any *argp1 ;
 139   Dali::Adaptor *result = 0 ;
 140
 141   argp1 = (Dali::Any *)jarg1;
 142   if (!argp1) {
 143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Any", 0);
 144     return 0;
 145   }
 146   arg1 = *argp1;
 147   arg2 = (Dali::RenderSurfaceInterface *)jarg2;
 148   if (!arg2) {
 149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderSurface const & type is null", 0);
 150     return 0;
 151   }
 152   {
 153     try {
 154       result = (Dali::Adaptor *) &Dali::Adaptor::New(arg1,(Dali::RenderSurfaceInterface const &)*arg2,Dali::Configuration::APPLICATION_DOES_NOT_HANDLE_CONTEXT_LOSS);
 155     } catch (std::out_of_range& e) {
 156       {
 157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 158       };
 159     } catch (std::exception& e) {
 160       {
 161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 162       };
 163     } catch (Dali::DaliException e) {
 164       {
 165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 166       };
 167     } catch (...) {
 168       {
 169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 170       };
 171     }
 172   }
 173
 174   jresult = (void *)result;
 175   return jresult;
 176 }
 177
 178
 179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Adaptor_New__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
 180   void * jresult ;
 181   Dali::Any arg1 ;
 182   Dali::RenderSurfaceInterface *arg2 = 0 ;
 183   Dali::Configuration::ContextLoss arg3 ;
 184   Dali::Any *argp1 ;
 185   Dali::Configuration::ContextLoss *argp3 ;
 186   Dali::Adaptor *result = 0 ;
 187
 188   argp1 = (Dali::Any *)jarg1;
 189   if (!argp1) {
 190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Any", 0);
 191     return 0;
 192   }
 193   arg1 = *argp1;
 194   arg2 = (Dali::RenderSurfaceInterface *)jarg2;
 195   if (!arg2) {
 196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderSurface const & type is null", 0);
 197     return 0;
 198   }
 199   argp3 = (Dali::Configuration::ContextLoss *)jarg3;
 200   if (!argp3) {
 201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Configuration::ContextLoss", 0);
 202     return 0;
 203   }
 204   arg3 = *argp3;
 205   {
 206     try {
 207       result = (Dali::Adaptor *) &Dali::Adaptor::New(arg1,(Dali::RenderSurfaceInterface const &)*arg2,arg3);
 208     } catch (std::out_of_range& e) {
 209       {
 210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 211       };
 212     } catch (std::exception& e) {
 213       {
 214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 215       };
 216     } catch (Dali::DaliException e) {
 217       {
 218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 219       };
 220     } catch (...) {
 221       {
 222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 223       };
 224     }
 225   }
 226
 227   jresult = (void *)result;
 228   return jresult;
 229 }
 230
 231
 232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Adaptor(void * jarg1) {
 233   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 234
 235   arg1 = (Dali::Adaptor *)jarg1;
 236   {
 237     try {
 238       delete arg1;
 239     } catch (std::out_of_range& e) {
 240       {
 241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 242       };
 243     } catch (std::exception& e) {
 244       {
 245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 246       };
 247     } catch (Dali::DaliException e) {
 248       {
 249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 250       };
 251     } catch (...) {
 252       {
 253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 254       };
 255     }
 256   }
 257
 258 }
 259
 260
 261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_Start(void * jarg1) {
 262   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 263
 264   arg1 = (Dali::Adaptor *)jarg1;
 265   {
 266     try {
 267       (arg1)->Start();
 268     } catch (std::out_of_range& e) {
 269       {
 270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 271       };
 272     } catch (std::exception& e) {
 273       {
 274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 275       };
 276     } catch (Dali::DaliException e) {
 277       {
 278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 279       };
 280     } catch (...) {
 281       {
 282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 283       };
 284     }
 285   }
 286
 287 }
 288
 289
 290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_Pause(void * jarg1) {
 291   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 292
 293   arg1 = (Dali::Adaptor *)jarg1;
 294   {
 295     try {
 296       (arg1)->Pause();
 297     } catch (std::out_of_range& e) {
 298       {
 299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 300       };
 301     } catch (std::exception& e) {
 302       {
 303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 304       };
 305     } catch (Dali::DaliException e) {
 306       {
 307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 308       };
 309     } catch (...) {
 310       {
 311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 312       };
 313     }
 314   }
 315
 316 }
 317
 318
 319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_Resume(void * jarg1) {
 320   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 321
 322   arg1 = (Dali::Adaptor *)jarg1;
 323   {
 324     try {
 325       (arg1)->Resume();
 326     } catch (std::out_of_range& e) {
 327       {
 328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 329       };
 330     } catch (std::exception& e) {
 331       {
 332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 333       };
 334     } catch (Dali::DaliException e) {
 335       {
 336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 337       };
 338     } catch (...) {
 339       {
 340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 341       };
 342     }
 343   }
 344
 345 }
 346
 347
 348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_Stop(void * jarg1) {
 349   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 350
 351   arg1 = (Dali::Adaptor *)jarg1;
 352   {
 353     try {
 354       (arg1)->Stop();
 355     } catch (std::out_of_range& e) {
 356       {
 357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 358       };
 359     } catch (std::exception& e) {
 360       {
 361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 362       };
 363     } catch (Dali::DaliException e) {
 364       {
 365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 366       };
 367     } catch (...) {
 368       {
 369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 370       };
 371     }
 372   }
 373
 374 }
 375
 376
 377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Adaptor_AddIdle(void * jarg1, void * jarg2) {
 378   unsigned int jresult ;
 379   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 380   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
 381   bool result;
 382
 383   arg1 = (Dali::Adaptor *)jarg1;
 384   arg2 = (Dali::CallbackBase *)jarg2;
 385   {
 386     try {
 387       result = (bool)(arg1)->AddIdle(arg2, false);
 388     } catch (std::out_of_range& e) {
 389       {
 390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 391       };
 392     } catch (std::exception& e) {
 393       {
 394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 395       };
 396     } catch (Dali::DaliException e) {
 397       {
 398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 399       };
 400     } catch (...) {
 401       {
 402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 403       };
 404     }
 405   }
 406
 407   jresult = result;
 408   return jresult;
 409 }
 410
 411
 412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_RemoveIdle(void * jarg1, void * jarg2) {
 413   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 414   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
 415
 416   arg1 = (Dali::Adaptor *)jarg1;
 417   arg2 = (Dali::CallbackBase *)jarg2;
 418   {
 419     try {
 420       (arg1)->RemoveIdle(arg2);
 421     } catch (std::out_of_range& e) {
 422       {
 423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 424       };
 425     } catch (std::exception& e) {
 426       {
 427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 428       };
 429     } catch (Dali::DaliException e) {
 430       {
 431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 432       };
 433     } catch (...) {
 434       {
 435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 436       };
 437     }
 438   }
 439
 440 }
 441
 442
 443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_ReplaceSurface(void * jarg1, void * jarg2, void * jarg3) {
 444   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 445   Dali::Any arg2 ;
 446   Dali::RenderSurfaceInterface *arg3 = 0 ;
 447   Dali::Any *argp2 ;
 448
 449   arg1 = (Dali::Adaptor *)jarg1;
 450   argp2 = (Dali::Any *)jarg2;
 451   if (!argp2) {
 452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Any", 0);
 453     return ;
 454   }
 455   arg2 = *argp2;
 456   arg3 = (Dali::RenderSurfaceInterface *)jarg3;
 457   if (!arg3) {
 458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderSurface & type is null", 0);
 459     return ;
 460   }
 461   {
 462     try {
 463       (arg1)->ReplaceSurface(arg2,*arg3);
 464     } catch (std::out_of_range& e) {
 465       {
 466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 467       };
 468     } catch (std::exception& e) {
 469       {
 470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 471       };
 472     } catch (Dali::DaliException e) {
 473       {
 474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 475       };
 476     } catch (...) {
 477       {
 478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 479       };
 480     }
 481   }
 482
 483 }
 484
 485
 486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Adaptor_GetSurface(void * jarg1) {
 487   void * jresult ;
 488   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 489   Dali::RenderSurfaceInterface *result = 0 ;
 490
 491   arg1 = (Dali::Adaptor *)jarg1;
 492   {
 493     try {
 494       result = (Dali::RenderSurfaceInterface *) &(arg1)->GetSurface();
 495     } catch (std::out_of_range& e) {
 496       {
 497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 498       };
 499     } catch (std::exception& e) {
 500       {
 501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 502       };
 503     } catch (Dali::DaliException e) {
 504       {
 505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 506       };
 507     } catch (...) {
 508       {
 509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 510       };
 511     }
 512   }
 513
 514   jresult = (void *)result;
 515   return jresult;
 516 }
 517
 518
 519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Adaptor_GetNativeWindowHandle(void * jarg1) {
 520   void * jresult ;
 521   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 522   Dali::Any result;
 523
 524   arg1 = (Dali::Adaptor *)jarg1;
 525   {
 526     try {
 527       result = (arg1)->GetNativeWindowHandle();
 528     } catch (std::out_of_range& e) {
 529       {
 530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 531       };
 532     } catch (std::exception& e) {
 533       {
 534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 535       };
 536     } catch (Dali::DaliException e) {
 537       {
 538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 539       };
 540     } catch (...) {
 541       {
 542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 543       };
 544     }
 545   }
 546
 547   jresult = new Dali::Any((const Dali::Any &)result);
 548   return jresult;
 549 }
 550
 551
 552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_ReleaseSurfaceLock(void * jarg1) {
 553   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 554
 555   arg1 = (Dali::Adaptor *)jarg1;
 556   {
 557     try {
 558       (arg1)->ReleaseSurfaceLock();
 559     } catch (std::out_of_range& e) {
 560       {
 561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 562       };
 563     } catch (std::exception& e) {
 564       {
 565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 566       };
 567     } catch (Dali::DaliException e) {
 568       {
 569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 570       };
 571     } catch (...) {
 572       {
 573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 574       };
 575     }
 576   }
 577
 578 }
 579
 580
 581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_SetRenderRefreshRate(void * jarg1, unsigned int jarg2) {
 582   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 583   unsigned int arg2 ;
 584
 585   arg1 = (Dali::Adaptor *)jarg1;
 586   arg2 = (unsigned int)jarg2;
 587   {
 588     try {
 589       (arg1)->SetRenderRefreshRate(arg2);
 590     } catch (std::out_of_range& e) {
 591       {
 592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 593       };
 594     } catch (std::exception& e) {
 595       {
 596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 597       };
 598     } catch (Dali::DaliException e) {
 599       {
 600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 601       };
 602     } catch (...) {
 603       {
 604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 605       };
 606     }
 607   }
 608
 609 }
 610
 611
 612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_SetUseHardwareVSync(void * jarg1, unsigned int jarg2) {
 613   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 614   bool arg2 ;
 615
 616   arg1 = (Dali::Adaptor *)jarg1;
 617   arg2 = jarg2 ? true : false;
 618   {
 619     try {
 620       (arg1)->SetUseHardwareVSync(arg2);
 621     } catch (std::out_of_range& e) {
 622       {
 623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 624       };
 625     } catch (std::exception& e) {
 626       {
 627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 628       };
 629     } catch (Dali::DaliException e) {
 630       {
 631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 632       };
 633     } catch (...) {
 634       {
 635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 636       };
 637     }
 638   }
 639
 640 }
 641
 642
 643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Adaptor_Get() {
 644   void * jresult ;
 645   Dali::Adaptor *result = 0 ;
 646
 647   {
 648     try {
 649       result = (Dali::Adaptor *) &Dali::Adaptor::Get();
 650     } catch (std::out_of_range& e) {
 651       {
 652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 653       };
 654     } catch (std::exception& e) {
 655       {
 656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 657       };
 658     } catch (Dali::DaliException e) {
 659       {
 660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 661       };
 662     } catch (...) {
 663       {
 664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 665       };
 666     }
 667   }
 668
 669   jresult = (void *)result;
 670   return jresult;
 671 }
 672
 673
 674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Adaptor_IsAvailable() {
 675   unsigned int jresult ;
 676   bool result;
 677
 678   {
 679     try {
 680       result = (bool)Dali::Adaptor::IsAvailable();
 681     } catch (std::out_of_range& e) {
 682       {
 683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 684       };
 685     } catch (std::exception& e) {
 686       {
 687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 688       };
 689     } catch (Dali::DaliException e) {
 690       {
 691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 692       };
 693     } catch (...) {
 694       {
 695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 696       };
 697     }
 698   }
 699
 700   jresult = result;
 701   return jresult;
 702 }
 703
 704
 705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_NotifySceneCreated(void * jarg1) {
 706   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 707
 708   arg1 = (Dali::Adaptor *)jarg1;
 709   {
 710     try {
 711       (arg1)->NotifySceneCreated();
 712     } catch (std::out_of_range& e) {
 713       {
 714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 715       };
 716     } catch (std::exception& e) {
 717       {
 718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 719       };
 720     } catch (Dali::DaliException e) {
 721       {
 722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 723       };
 724     } catch (...) {
 725       {
 726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 727       };
 728     }
 729   }
 730
 731 }
 732
 733
 734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_NotifyLanguageChanged(void * jarg1) {
 735   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 736
 737   arg1 = (Dali::Adaptor *)jarg1;
 738   {
 739     try {
 740       (arg1)->NotifyLanguageChanged();
 741     } catch (std::out_of_range& e) {
 742       {
 743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 744       };
 745     } catch (std::exception& e) {
 746       {
 747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 748       };
 749     } catch (Dali::DaliException e) {
 750       {
 751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 752       };
 753     } catch (...) {
 754       {
 755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 756       };
 757     }
 758   }
 759
 760 }
 761
 762
 763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_SetMinimumPinchDistance(void * jarg1, float jarg2) {
 764   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 765   float arg2 ;
 766
 767   arg1 = (Dali::Adaptor *)jarg1;
 768   arg2 = (float)jarg2;
 769   {
 770     try {
 771       (arg1)->SetMinimumPinchDistance(arg2);
 772     } catch (std::out_of_range& e) {
 773       {
 774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 775       };
 776     } catch (std::exception& e) {
 777       {
 778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 779       };
 780     } catch (Dali::DaliException e) {
 781       {
 782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 783       };
 784     } catch (...) {
 785       {
 786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 787       };
 788     }
 789   }
 790
 791 }
 792
 793
 794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_FeedTouchPoint(void * jarg1, void * jarg2, int jarg3) {
 795   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 796   Dali::TouchPoint *arg2 = 0 ;
 797   int arg3 ;
 798
 799   arg1 = (Dali::Adaptor *)jarg1;
 800   arg2 = (Dali::TouchPoint *)jarg2;
 801   if (!arg2) {
 802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint & type is null", 0);
 803     return ;
 804   }
 805   arg3 = (int)jarg3;
 806   {
 807     try {
 808       (arg1)->FeedTouchPoint(*arg2,arg3);
 809     } catch (std::out_of_range& e) {
 810       {
 811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 812       };
 813     } catch (std::exception& e) {
 814       {
 815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 816       };
 817     } catch (Dali::DaliException e) {
 818       {
 819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 820       };
 821     } catch (...) {
 822       {
 823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 824       };
 825     }
 826   }
 827
 828 }
 829
 830
 831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_FeedWheelEvent(void * jarg1, void * jarg2) {
 832   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 833   Dali::WheelEvent *arg2 = 0 ;
 834
 835   arg1 = (Dali::Adaptor *)jarg1;
 836   arg2 = (Dali::WheelEvent *)jarg2;
 837   if (!arg2) {
 838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent & type is null", 0);
 839     return ;
 840   }
 841   {
 842     try {
 843       (arg1)->FeedWheelEvent(*arg2);
 844     } catch (std::out_of_range& e) {
 845       {
 846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 847       };
 848     } catch (std::exception& e) {
 849       {
 850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 851       };
 852     } catch (Dali::DaliException e) {
 853       {
 854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 855       };
 856     } catch (...) {
 857       {
 858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 859       };
 860     }
 861   }
 862
 863 }
 864
 865
 866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_FeedKeyEvent(void * jarg1, void * jarg2) {
 867   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 868   Dali::KeyEvent *arg2 = 0 ;
 869
 870   arg1 = (Dali::Adaptor *)jarg1;
 871   arg2 = (Dali::KeyEvent *)jarg2;
 872   if (!arg2) {
 873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0);
 874     return ;
 875   }
 876   {
 877     try {
 878       (arg1)->FeedKeyEvent(*arg2);
 879     } catch (std::out_of_range& e) {
 880       {
 881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 882       };
 883     } catch (std::exception& e) {
 884       {
 885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 886       };
 887     } catch (Dali::DaliException e) {
 888       {
 889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 890       };
 891     } catch (...) {
 892       {
 893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 894       };
 895     }
 896   }
 897
 898 }
 899
 900
 901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_SceneCreated(void * jarg1) {
 902   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 903
 904   arg1 = (Dali::Adaptor *)jarg1;
 905   {
 906     try {
 907       (arg1)->SceneCreated();
 908     } catch (std::out_of_range& e) {
 909       {
 910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 911       };
 912     } catch (std::exception& e) {
 913       {
 914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 915       };
 916     } catch (Dali::DaliException e) {
 917       {
 918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 919       };
 920     } catch (...) {
 921       {
 922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 923       };
 924     }
 925   }
 926
 927 }
 928
 929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Adaptor_ResizedSignal(void * jarg1) {
 930   void * jresult ;
 931   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 932   Dali::Adaptor::AdaptorSignalType *result = 0 ;
 933
 934   arg1 = (Dali::Adaptor *)jarg1;
 935   {
 936     try {
 937       result = (Dali::Adaptor::AdaptorSignalType *) &(arg1)->ResizedSignal();
 938     } catch (std::out_of_range& e) {
 939       {
 940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 941       };
 942     } catch (std::exception& e) {
 943       {
 944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 945       };
 946     } catch (Dali::DaliException e) {
 947       {
 948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 949       };
 950     } catch (...) {
 951       {
 952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 953       };
 954     }
 955   }
 956
 957   jresult = (void *)result;
 958   return jresult;
 959 }
 960
 961
 962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Adaptor_LanguageChangedSignal(void * jarg1) {
 963   void * jresult ;
 964   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 965   Dali::Adaptor::AdaptorSignalType *result = 0 ;
 966
 967   arg1 = (Dali::Adaptor *)jarg1;
 968   {
 969     try {
 970       result = (Dali::Adaptor::AdaptorSignalType *) &(arg1)->LanguageChangedSignal();
 971     } catch (std::out_of_range& e) {
 972       {
 973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 974       };
 975     } catch (std::exception& e) {
 976       {
 977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 978       };
 979     } catch (Dali::DaliException e) {
 980       {
 981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 982       };
 983     } catch (...) {
 984       {
 985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 986       };
 987     }
 988   }
 989
 990   jresult = (void *)result;
 991   return jresult;
 992 }
 993
 994
 995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AdaptorSignalType_Empty(void * jarg1) {
 996   unsigned int jresult ;
 997   Dali::Signal< void (Dali::Adaptor &) > *arg1 = (Dali::Signal< void (Dali::Adaptor &) > *) 0 ;
 998   bool result;
 999
1000   arg1 = (Dali::Signal< void (Dali::Adaptor &) > *)jarg1;
1001   {
1002     try {
1003       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Adaptor &) > const *)arg1);
1004     } catch (std::out_of_range& e) {
1005       {
1006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1007       };
1008     } catch (std::exception& e) {
1009       {
1010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1011       };
1012     } catch (Dali::DaliException e) {
1013       {
1014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1015       };
1016     } catch (...) {
1017       {
1018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1019       };
1020     }
1021   }
1022
1023   jresult = result;
1024   return jresult;
1025 }
1026
1027
1028 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AdaptorSignalType_GetConnectionCount(void * jarg1) {
1029   unsigned long jresult ;
1030   Dali::Signal< void (Dali::Adaptor &) > *arg1 = (Dali::Signal< void (Dali::Adaptor &) > *) 0 ;
1031   std::size_t result;
1032
1033   arg1 = (Dali::Signal< void (Dali::Adaptor &) > *)jarg1;
1034   {
1035     try {
1036       result = Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Adaptor &) > const *)arg1);
1037     } catch (std::out_of_range& e) {
1038       {
1039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1040       };
1041     } catch (std::exception& e) {
1042       {
1043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1044       };
1045     } catch (Dali::DaliException e) {
1046       {
1047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1048       };
1049     } catch (...) {
1050       {
1051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1052       };
1053     }
1054   }
1055
1056   jresult = (unsigned long)result;
1057   return jresult;
1058 }
1059
1060
1061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AdaptorSignalType_Connect(void * jarg1, void * jarg2) {
1062   Dali::Signal< void (Dali::Adaptor &) > *arg1 = (Dali::Signal< void (Dali::Adaptor &) > *) 0 ;
1063   void (*arg2)(Dali::Adaptor &) = (void (*)(Dali::Adaptor &)) 0 ;
1064
1065   arg1 = (Dali::Signal< void (Dali::Adaptor &) > *)jarg1;
1066   arg2 = (void (*)(Dali::Adaptor &))jarg2;
1067   {
1068     try {
1069       Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Connect(arg1,arg2);
1070     } catch (std::out_of_range& e) {
1071       {
1072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1073       };
1074     } catch (std::exception& e) {
1075       {
1076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1077       };
1078     } catch (Dali::DaliException e) {
1079       {
1080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1081       };
1082     } catch (...) {
1083       {
1084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1085       };
1086     }
1087   }
1088
1089 }
1090
1091
1092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AdaptorSignalType_Disconnect(void * jarg1, void * jarg2) {
1093   Dali::Signal< void (Dali::Adaptor &) > *arg1 = (Dali::Signal< void (Dali::Adaptor &) > *) 0 ;
1094   void (*arg2)(Dali::Adaptor &) = (void (*)(Dali::Adaptor &)) 0 ;
1095
1096   arg1 = (Dali::Signal< void (Dali::Adaptor &) > *)jarg1;
1097   arg2 = (void (*)(Dali::Adaptor &))jarg2;
1098   {
1099     try {
1100       Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Disconnect(arg1,arg2);
1101     } catch (std::out_of_range& e) {
1102       {
1103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1104       };
1105     } catch (std::exception& e) {
1106       {
1107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1108       };
1109     } catch (Dali::DaliException e) {
1110       {
1111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1112       };
1113     } catch (...) {
1114       {
1115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1116       };
1117     }
1118   }
1119
1120 }
1121
1122
1123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AdaptorSignalType_Emit(void * jarg1, void * jarg2) {
1124   Dali::Signal< void (Dali::Adaptor &) > *arg1 = (Dali::Signal< void (Dali::Adaptor &) > *) 0 ;
1125   Dali::Adaptor *arg2 = 0 ;
1126
1127   arg1 = (Dali::Signal< void (Dali::Adaptor &) > *)jarg1;
1128   arg2 = (Dali::Adaptor *)jarg2;
1129   if (!arg2) {
1130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Adaptor & type is null", 0);
1131     return ;
1132   }
1133   {
1134     try {
1135       Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Emit(arg1,*arg2);
1136     } catch (std::out_of_range& e) {
1137       {
1138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1139       };
1140     } catch (std::exception& e) {
1141       {
1142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1143       };
1144     } catch (Dali::DaliException e) {
1145       {
1146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1147       };
1148     } catch (...) {
1149       {
1150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1151       };
1152     }
1153   }
1154
1155 }
1156
1157
1158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AdaptorSignalType() {
1159   void * jresult ;
1160   Dali::Signal< void (Dali::Adaptor &) > *result = 0 ;
1161
1162   {
1163     try {
1164       result = (Dali::Signal< void (Dali::Adaptor &) > *)new Dali::Signal< void (Dali::Adaptor &) >();
1165     } catch (std::out_of_range& e) {
1166       {
1167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1168       };
1169     } catch (std::exception& e) {
1170       {
1171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1172       };
1173     } catch (Dali::DaliException e) {
1174       {
1175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1176       };
1177     } catch (...) {
1178       {
1179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1180       };
1181     }
1182   }
1183
1184   jresult = (void *)result;
1185   return jresult;
1186 }
1187
1188
1189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AdaptorSignalType(void * jarg1) {
1190   Dali::Signal< void (Dali::Adaptor &) > *arg1 = (Dali::Signal< void (Dali::Adaptor &) > *) 0 ;
1191
1192   arg1 = (Dali::Signal< void (Dali::Adaptor &) > *)jarg1;
1193   {
1194     try {
1195       delete arg1;
1196     } catch (std::out_of_range& e) {
1197       {
1198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1199       };
1200     } catch (std::exception& e) {
1201       {
1202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1203       };
1204     } catch (Dali::DaliException e) {
1205       {
1206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1207       };
1208     } catch (...) {
1209       {
1210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1211       };
1212     }
1213   }
1214
1215 }
1216
1217
1218 #ifdef __cplusplus
1219 }
1220 #endif
1221
1222