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::Window *argp1 ;
  91   Dali::Configuration::ContextLoss arg2 ;
  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::Window arg1 ;
 137   Dali::Window *argp1 ;
 138   Dali::RenderSurfaceInterface *arg2 = 0 ;
 139   Dali::Adaptor *result = 0 ;
 140
 141   argp1 = (Dali::Window *)jarg1;
 142   if (!argp1) {
 143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 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::Window arg1 ;
 182   Dali::Window *argp1 ;
 183   Dali::RenderSurfaceInterface *arg2 = 0 ;
 184   Dali::Configuration::ContextLoss arg3 ;
 185   Dali::Configuration::ContextLoss *argp3 ;
 186   Dali::Adaptor *result = 0 ;
 187
 188   argp1 = (Dali::Window *)jarg1;
 189   if (!argp1) {
 190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 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::Window arg2 ;
 446   Dali::Window *argp2 ;
 447   Dali::RenderSurfaceInterface *arg3 = 0 ;
 448
 449   arg1 = (Dali::Adaptor *)jarg1;
 450   argp2 = (Dali::Window *)jarg2;
 451   if (!argp2) {
 452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 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_FeedTouchPoint(void * jarg1, void * jarg2, int jarg3) {
 764   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 765   Dali::TouchPoint *arg2 = 0 ;
 766   int arg3 ;
 767
 768   arg1 = (Dali::Adaptor *)jarg1;
 769   arg2 = (Dali::TouchPoint *)jarg2;
 770   if (!arg2) {
 771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint & type is null", 0);
 772     return ;
 773   }
 774   arg3 = (int)jarg3;
 775   {
 776     try {
 777       (arg1)->FeedTouchPoint(*arg2,arg3);
 778     } catch (std::out_of_range& e) {
 779       {
 780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 781       };
 782     } catch (std::exception& e) {
 783       {
 784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 785       };
 786     } catch (Dali::DaliException e) {
 787       {
 788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 789       };
 790     } catch (...) {
 791       {
 792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 793       };
 794     }
 795   }
 796
 797 }
 798
 799
 800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_FeedWheelEvent(void * jarg1, void * jarg2) {
 801   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 802   Dali::WheelEvent *arg2 = 0 ;
 803
 804   arg1 = (Dali::Adaptor *)jarg1;
 805   arg2 = (Dali::WheelEvent *)jarg2;
 806   if (!arg2) {
 807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent & type is null", 0);
 808     return ;
 809   }
 810   {
 811     try {
 812       (arg1)->FeedWheelEvent(*arg2);
 813     } catch (std::out_of_range& e) {
 814       {
 815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 816       };
 817     } catch (std::exception& e) {
 818       {
 819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 820       };
 821     } catch (Dali::DaliException e) {
 822       {
 823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 824       };
 825     } catch (...) {
 826       {
 827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 828       };
 829     }
 830   }
 831
 832 }
 833
 834
 835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_FeedKeyEvent(void * jarg1, void * jarg2) {
 836   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 837   Dali::KeyEvent *arg2 = 0 ;
 838
 839   arg1 = (Dali::Adaptor *)jarg1;
 840   arg2 = (Dali::KeyEvent *)jarg2;
 841   if (!arg2) {
 842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0);
 843     return ;
 844   }
 845   {
 846     try {
 847       (arg1)->FeedKeyEvent(*arg2);
 848     } catch (std::out_of_range& e) {
 849       {
 850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 851       };
 852     } catch (std::exception& e) {
 853       {
 854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 855       };
 856     } catch (Dali::DaliException e) {
 857       {
 858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 859       };
 860     } catch (...) {
 861       {
 862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 863       };
 864     }
 865   }
 866
 867 }
 868
 869
 870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_SceneCreated(void * jarg1) {
 871   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 872
 873   arg1 = (Dali::Adaptor *)jarg1;
 874   {
 875     try {
 876       (arg1)->SceneCreated();
 877     } catch (std::out_of_range& e) {
 878       {
 879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 880       };
 881     } catch (std::exception& e) {
 882       {
 883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 884       };
 885     } catch (Dali::DaliException e) {
 886       {
 887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 888       };
 889     } catch (...) {
 890       {
 891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 892       };
 893     }
 894   }
 895
 896 }
 897
 898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Adaptor_ResizedSignal(void * jarg1) {
 899   void * jresult ;
 900   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 901   Dali::Adaptor::AdaptorSignalType *result = 0 ;
 902
 903   arg1 = (Dali::Adaptor *)jarg1;
 904   {
 905     try {
 906       result = (Dali::Adaptor::AdaptorSignalType *) &(arg1)->ResizedSignal();
 907     } catch (std::out_of_range& e) {
 908       {
 909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 910       };
 911     } catch (std::exception& e) {
 912       {
 913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 914       };
 915     } catch (Dali::DaliException e) {
 916       {
 917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 918       };
 919     } catch (...) {
 920       {
 921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 922       };
 923     }
 924   }
 925
 926   jresult = (void *)result;
 927   return jresult;
 928 }
 929
 930
 931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Adaptor_LanguageChangedSignal(void * jarg1) {
 932   void * jresult ;
 933   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 934   Dali::Adaptor::AdaptorSignalType *result = 0 ;
 935
 936   arg1 = (Dali::Adaptor *)jarg1;
 937   {
 938     try {
 939       result = (Dali::Adaptor::AdaptorSignalType *) &(arg1)->LanguageChangedSignal();
 940     } catch (std::out_of_range& e) {
 941       {
 942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 943       };
 944     } catch (std::exception& e) {
 945       {
 946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 947       };
 948     } catch (Dali::DaliException e) {
 949       {
 950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 951       };
 952     } catch (...) {
 953       {
 954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 955       };
 956     }
 957   }
 958
 959   jresult = (void *)result;
 960   return jresult;
 961 }
 962
 963
 964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AdaptorSignalType_Empty(void * jarg1) {
 965   unsigned int jresult ;
 966   Dali::Signal< void (Dali::Adaptor &) > *arg1 = (Dali::Signal< void (Dali::Adaptor &) > *) 0 ;
 967   bool result;
 968
 969   arg1 = (Dali::Signal< void (Dali::Adaptor &) > *)jarg1;
 970   {
 971     try {
 972       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Adaptor &) > const *)arg1);
 973     } catch (std::out_of_range& e) {
 974       {
 975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 976       };
 977     } catch (std::exception& e) {
 978       {
 979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 980       };
 981     } catch (Dali::DaliException e) {
 982       {
 983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 984       };
 985     } catch (...) {
 986       {
 987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 988       };
 989     }
 990   }
 991
 992   jresult = result;
 993   return jresult;
 994 }
 995
 996
 997 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AdaptorSignalType_GetConnectionCount(void * jarg1) {
 998   unsigned long jresult ;
 999   Dali::Signal< void (Dali::Adaptor &) > *arg1 = (Dali::Signal< void (Dali::Adaptor &) > *) 0 ;
1000   std::size_t result;
1001
1002   arg1 = (Dali::Signal< void (Dali::Adaptor &) > *)jarg1;
1003   {
1004     try {
1005       result = Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Adaptor &) > const *)arg1);
1006     } catch (std::out_of_range& e) {
1007       {
1008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1009       };
1010     } catch (std::exception& e) {
1011       {
1012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1013       };
1014     } catch (Dali::DaliException e) {
1015       {
1016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1017       };
1018     } catch (...) {
1019       {
1020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1021       };
1022     }
1023   }
1024
1025   jresult = (unsigned long)result;
1026   return jresult;
1027 }
1028
1029
1030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AdaptorSignalType_Connect(void * jarg1, void * jarg2) {
1031   Dali::Signal< void (Dali::Adaptor &) > *arg1 = (Dali::Signal< void (Dali::Adaptor &) > *) 0 ;
1032   void (*arg2)(Dali::Adaptor &) = (void (*)(Dali::Adaptor &)) 0 ;
1033
1034   arg1 = (Dali::Signal< void (Dali::Adaptor &) > *)jarg1;
1035   arg2 = (void (*)(Dali::Adaptor &))jarg2;
1036   {
1037     try {
1038       Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Connect(arg1,arg2);
1039     } catch (std::out_of_range& e) {
1040       {
1041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1042       };
1043     } catch (std::exception& e) {
1044       {
1045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1046       };
1047     } catch (Dali::DaliException e) {
1048       {
1049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1050       };
1051     } catch (...) {
1052       {
1053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1054       };
1055     }
1056   }
1057
1058 }
1059
1060
1061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AdaptorSignalType_Disconnect(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__Disconnect(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_Emit(void * jarg1, void * jarg2) {
1093   Dali::Signal< void (Dali::Adaptor &) > *arg1 = (Dali::Signal< void (Dali::Adaptor &) > *) 0 ;
1094   Dali::Adaptor *arg2 = 0 ;
1095
1096   arg1 = (Dali::Signal< void (Dali::Adaptor &) > *)jarg1;
1097   arg2 = (Dali::Adaptor *)jarg2;
1098   if (!arg2) {
1099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Adaptor & type is null", 0);
1100     return ;
1101   }
1102   {
1103     try {
1104       Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Emit(arg1,*arg2);
1105     } catch (std::out_of_range& e) {
1106       {
1107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1108       };
1109     } catch (std::exception& e) {
1110       {
1111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1112       };
1113     } catch (Dali::DaliException e) {
1114       {
1115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1116       };
1117     } catch (...) {
1118       {
1119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1120       };
1121     }
1122   }
1123
1124 }
1125
1126
1127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AdaptorSignalType() {
1128   void * jresult ;
1129   Dali::Signal< void (Dali::Adaptor &) > *result = 0 ;
1130
1131   {
1132     try {
1133       result = (Dali::Signal< void (Dali::Adaptor &) > *)new Dali::Signal< void (Dali::Adaptor &) >();
1134     } catch (std::out_of_range& e) {
1135       {
1136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1137       };
1138     } catch (std::exception& e) {
1139       {
1140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1141       };
1142     } catch (Dali::DaliException e) {
1143       {
1144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1145       };
1146     } catch (...) {
1147       {
1148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1149       };
1150     }
1151   }
1152
1153   jresult = (void *)result;
1154   return jresult;
1155 }
1156
1157
1158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AdaptorSignalType(void * jarg1) {
1159   Dali::Signal< void (Dali::Adaptor &) > *arg1 = (Dali::Signal< void (Dali::Adaptor &) > *) 0 ;
1160
1161   arg1 = (Dali::Signal< void (Dali::Adaptor &) > *)jarg1;
1162   {
1163     try {
1164       delete arg1;
1165     } catch (std::out_of_range& e) {
1166       {
1167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1168       };
1169     } catch (std::exception& e) {
1170       {
1171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1172       };
1173     } catch (Dali::DaliException e) {
1174       {
1175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1176       };
1177     } catch (...) {
1178       {
1179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1180       };
1181     }
1182   }
1183
1184 }
1185
1186
1187 #ifdef __cplusplus
1188 }
1189 #endif
1190
1191