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_Get() {
 613   void * jresult ;
 614   Dali::Adaptor *result = 0 ;
 615
 616   {
 617     try {
 618       result = (Dali::Adaptor *) &Dali::Adaptor::Get();
 619     } catch (std::out_of_range& e) {
 620       {
 621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 622       };
 623     } catch (std::exception& e) {
 624       {
 625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 626       };
 627     } catch (Dali::DaliException e) {
 628       {
 629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 630       };
 631     } catch (...) {
 632       {
 633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 634       };
 635     }
 636   }
 637
 638   jresult = (void *)result;
 639   return jresult;
 640 }
 641
 642
 643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Adaptor_IsAvailable() {
 644   unsigned int jresult ;
 645   bool result;
 646
 647   {
 648     try {
 649       result = (bool)Dali::Adaptor::IsAvailable();
 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 = result;
 670   return jresult;
 671 }
 672
 673
 674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_NotifySceneCreated(void * jarg1) {
 675   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 676
 677   arg1 = (Dali::Adaptor *)jarg1;
 678   {
 679     try {
 680       (arg1)->NotifySceneCreated();
 681     } catch (std::out_of_range& e) {
 682       {
 683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 684       };
 685     } catch (std::exception& e) {
 686       {
 687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 688       };
 689     } catch (Dali::DaliException e) {
 690       {
 691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 692       };
 693     } catch (...) {
 694       {
 695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 696       };
 697     }
 698   }
 699
 700 }
 701
 702
 703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_NotifyLanguageChanged(void * jarg1) {
 704   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 705
 706   arg1 = (Dali::Adaptor *)jarg1;
 707   {
 708     try {
 709       (arg1)->NotifyLanguageChanged();
 710     } catch (std::out_of_range& e) {
 711       {
 712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 713       };
 714     } catch (std::exception& e) {
 715       {
 716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 717       };
 718     } catch (Dali::DaliException e) {
 719       {
 720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 721       };
 722     } catch (...) {
 723       {
 724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 725       };
 726     }
 727   }
 728
 729 }
 730
 731
 732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_FeedTouchPoint(void * jarg1, void * jarg2, int jarg3) {
 733   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 734   Dali::TouchPoint *arg2 = 0 ;
 735   int arg3 ;
 736
 737   arg1 = (Dali::Adaptor *)jarg1;
 738   arg2 = (Dali::TouchPoint *)jarg2;
 739   if (!arg2) {
 740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint & type is null", 0);
 741     return ;
 742   }
 743   arg3 = (int)jarg3;
 744   {
 745     try {
 746       (arg1)->FeedTouchPoint(*arg2,arg3);
 747     } catch (std::out_of_range& e) {
 748       {
 749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 750       };
 751     } catch (std::exception& e) {
 752       {
 753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 754       };
 755     } catch (Dali::DaliException e) {
 756       {
 757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 758       };
 759     } catch (...) {
 760       {
 761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 762       };
 763     }
 764   }
 765
 766 }
 767
 768
 769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_FeedWheelEvent(void * jarg1, void * jarg2) {
 770   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 771   Dali::WheelEvent *arg2 = 0 ;
 772
 773   arg1 = (Dali::Adaptor *)jarg1;
 774   arg2 = (Dali::WheelEvent *)jarg2;
 775   if (!arg2) {
 776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent & type is null", 0);
 777     return ;
 778   }
 779   {
 780     try {
 781       (arg1)->FeedWheelEvent(*arg2);
 782     } catch (std::out_of_range& e) {
 783       {
 784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 785       };
 786     } catch (std::exception& e) {
 787       {
 788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 789       };
 790     } catch (Dali::DaliException e) {
 791       {
 792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 793       };
 794     } catch (...) {
 795       {
 796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 797       };
 798     }
 799   }
 800
 801 }
 802
 803
 804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_FeedKeyEvent(void * jarg1, void * jarg2) {
 805   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 806   Dali::KeyEvent *arg2 = 0 ;
 807
 808   arg1 = (Dali::Adaptor *)jarg1;
 809   arg2 = (Dali::KeyEvent *)jarg2;
 810   if (!arg2) {
 811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0);
 812     return ;
 813   }
 814   {
 815     try {
 816       (arg1)->FeedKeyEvent(*arg2);
 817     } catch (std::out_of_range& e) {
 818       {
 819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 820       };
 821     } catch (std::exception& e) {
 822       {
 823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 824       };
 825     } catch (Dali::DaliException e) {
 826       {
 827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 828       };
 829     } catch (...) {
 830       {
 831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 832       };
 833     }
 834   }
 835
 836 }
 837
 838
 839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_SceneCreated(void * jarg1) {
 840   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 841
 842   arg1 = (Dali::Adaptor *)jarg1;
 843   {
 844     try {
 845       (arg1)->SceneCreated();
 846     } catch (std::out_of_range& e) {
 847       {
 848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 849       };
 850     } catch (std::exception& e) {
 851       {
 852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 853       };
 854     } catch (Dali::DaliException e) {
 855       {
 856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 857       };
 858     } catch (...) {
 859       {
 860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 861       };
 862     }
 863   }
 864
 865 }
 866
 867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Adaptor_ResizedSignal(void * jarg1) {
 868   void * jresult ;
 869   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 870   Dali::Adaptor::AdaptorSignalType *result = 0 ;
 871
 872   arg1 = (Dali::Adaptor *)jarg1;
 873   {
 874     try {
 875       result = (Dali::Adaptor::AdaptorSignalType *) &(arg1)->ResizedSignal();
 876     } catch (std::out_of_range& e) {
 877       {
 878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 879       };
 880     } catch (std::exception& e) {
 881       {
 882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 883       };
 884     } catch (Dali::DaliException e) {
 885       {
 886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 887       };
 888     } catch (...) {
 889       {
 890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 891       };
 892     }
 893   }
 894
 895   jresult = (void *)result;
 896   return jresult;
 897 }
 898
 899
 900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Adaptor_LanguageChangedSignal(void * jarg1) {
 901   void * jresult ;
 902   Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ;
 903   Dali::Adaptor::AdaptorSignalType *result = 0 ;
 904
 905   arg1 = (Dali::Adaptor *)jarg1;
 906   {
 907     try {
 908       result = (Dali::Adaptor::AdaptorSignalType *) &(arg1)->LanguageChangedSignal();
 909     } catch (std::out_of_range& e) {
 910       {
 911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 912       };
 913     } catch (std::exception& e) {
 914       {
 915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 916       };
 917     } catch (Dali::DaliException e) {
 918       {
 919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 920       };
 921     } catch (...) {
 922       {
 923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 924       };
 925     }
 926   }
 927
 928   jresult = (void *)result;
 929   return jresult;
 930 }
 931
 932
 933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AdaptorSignalType_Empty(void * jarg1) {
 934   unsigned int jresult ;
 935   Dali::Signal< void (Dali::Adaptor &) > *arg1 = (Dali::Signal< void (Dali::Adaptor &) > *) 0 ;
 936   bool result;
 937
 938   arg1 = (Dali::Signal< void (Dali::Adaptor &) > *)jarg1;
 939   {
 940     try {
 941       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Adaptor &) > const *)arg1);
 942     } catch (std::out_of_range& e) {
 943       {
 944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 945       };
 946     } catch (std::exception& e) {
 947       {
 948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 949       };
 950     } catch (Dali::DaliException e) {
 951       {
 952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 953       };
 954     } catch (...) {
 955       {
 956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 957       };
 958     }
 959   }
 960
 961   jresult = result;
 962   return jresult;
 963 }
 964
 965
 966 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AdaptorSignalType_GetConnectionCount(void * jarg1) {
 967   unsigned long jresult ;
 968   Dali::Signal< void (Dali::Adaptor &) > *arg1 = (Dali::Signal< void (Dali::Adaptor &) > *) 0 ;
 969   std::size_t result;
 970
 971   arg1 = (Dali::Signal< void (Dali::Adaptor &) > *)jarg1;
 972   {
 973     try {
 974       result = Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Adaptor &) > const *)arg1);
 975     } catch (std::out_of_range& e) {
 976       {
 977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 978       };
 979     } catch (std::exception& e) {
 980       {
 981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 982       };
 983     } catch (Dali::DaliException e) {
 984       {
 985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 986       };
 987     } catch (...) {
 988       {
 989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 990       };
 991     }
 992   }
 993
 994   jresult = (unsigned long)result;
 995   return jresult;
 996 }
 997
 998
 999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AdaptorSignalType_Connect(void * jarg1, void * jarg2) {
1000   Dali::Signal< void (Dali::Adaptor &) > *arg1 = (Dali::Signal< void (Dali::Adaptor &) > *) 0 ;
1001   void (*arg2)(Dali::Adaptor &) = (void (*)(Dali::Adaptor &)) 0 ;
1002
1003   arg1 = (Dali::Signal< void (Dali::Adaptor &) > *)jarg1;
1004   arg2 = (void (*)(Dali::Adaptor &))jarg2;
1005   {
1006     try {
1007       Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Connect(arg1,arg2);
1008     } catch (std::out_of_range& e) {
1009       {
1010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1011       };
1012     } catch (std::exception& e) {
1013       {
1014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1015       };
1016     } catch (Dali::DaliException e) {
1017       {
1018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1019       };
1020     } catch (...) {
1021       {
1022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1023       };
1024     }
1025   }
1026
1027 }
1028
1029
1030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AdaptorSignalType_Disconnect(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__Disconnect(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_Emit(void * jarg1, void * jarg2) {
1062   Dali::Signal< void (Dali::Adaptor &) > *arg1 = (Dali::Signal< void (Dali::Adaptor &) > *) 0 ;
1063   Dali::Adaptor *arg2 = 0 ;
1064
1065   arg1 = (Dali::Signal< void (Dali::Adaptor &) > *)jarg1;
1066   arg2 = (Dali::Adaptor *)jarg2;
1067   if (!arg2) {
1068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Adaptor & type is null", 0);
1069     return ;
1070   }
1071   {
1072     try {
1073       Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Emit(arg1,*arg2);
1074     } catch (std::out_of_range& e) {
1075       {
1076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1077       };
1078     } catch (std::exception& e) {
1079       {
1080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1081       };
1082     } catch (Dali::DaliException e) {
1083       {
1084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1085       };
1086     } catch (...) {
1087       {
1088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1089       };
1090     }
1091   }
1092
1093 }
1094
1095
1096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AdaptorSignalType() {
1097   void * jresult ;
1098   Dali::Signal< void (Dali::Adaptor &) > *result = 0 ;
1099
1100   {
1101     try {
1102       result = (Dali::Signal< void (Dali::Adaptor &) > *)new Dali::Signal< void (Dali::Adaptor &) >();
1103     } catch (std::out_of_range& e) {
1104       {
1105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1106       };
1107     } catch (std::exception& e) {
1108       {
1109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1110       };
1111     } catch (Dali::DaliException e) {
1112       {
1113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1114       };
1115     } catch (...) {
1116       {
1117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1118       };
1119     }
1120   }
1121
1122   jresult = (void *)result;
1123   return jresult;
1124 }
1125
1126
1127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AdaptorSignalType(void * jarg1) {
1128   Dali::Signal< void (Dali::Adaptor &) > *arg1 = (Dali::Signal< void (Dali::Adaptor &) > *) 0 ;
1129
1130   arg1 = (Dali::Signal< void (Dali::Adaptor &) > *)jarg1;
1131   {
1132     try {
1133       delete arg1;
1134     } catch (std::out_of_range& e) {
1135       {
1136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1137       };
1138     } catch (std::exception& e) {
1139       {
1140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1141       };
1142     } catch (Dali::DaliException e) {
1143       {
1144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1145       };
1146     } catch (...) {
1147       {
1148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1149       };
1150     }
1151   }
1152
1153 }
1154
1155
1156 #ifdef __cplusplus
1157 }
1158 #endif
1159
1160