dali-csharp-binder/src/application.cpp

   1 /** Copyright (c) 2017 Samsung Electronics Co., Ltd.
   2 *
   3 * Licensed under the Apache License, Version 2.0 (the "License");
   4 * you may not use this file except in compliance with the License.
   5 * You may obtain a copy of the License at
   6 *
   7 * http://www.apache.org/licenses/LICENSE-2.0
   8 *
   9 * Unless required by applicable law or agreed to in writing, software
  10 * distributed under the License is distributed on an "AS IS" BASIS,
  11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 * See the License for the specific language governing permissions and
  13 * limitations under the License.
  14 *
  15 */
  16
  17 #ifndef CSHARP_APPLICATION
  18 #define CSHARP_APPLICATION
  19 #endif
  20
  21 #include "common.h"
  22 #include "string"
  23 #include <dali/public-api/adaptor-framework/application.h>
  24 #include <dali/devel-api/adaptor-framework/application-devel.h>
  25
  26 /* Callback for returning strings to C# without leaking memory */
  27 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
  28 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
  29
  30
  31 // keep argcs and argv so they're always available to DALi
  32 int argC = 1;
  33 char **argV = NULL;
  34
  35 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Empty(Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > const *self){
  36   return self->Empty();
  37 }
  38 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > const *self){
  39   return self->GetConnectionCount();
  40 }
  41 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Connect(Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *self,void (*func)(Dali::DeviceStatus::Battery::Status)){
  42   self->Connect( func );
  43 }
  44 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Disconnect(Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *self,void (*func)(Dali::DeviceStatus::Battery::Status)){
  45   self->Disconnect( func );
  46 }
  47 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Emit(Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *self,Dali::DeviceStatus::Battery::Status arg){
  48   self->Emit( arg );
  49 }
  50 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Empty(Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > const *self){
  51   return self->Empty();
  52 }
  53 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > const *self){
  54   return self->GetConnectionCount();
  55 }
  56 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Connect(Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *self,void (*func)(Dali::DeviceStatus::Memory::Status)){
  57   self->Connect( func );
  58 }
  59 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Disconnect(Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *self,void (*func)(Dali::DeviceStatus::Memory::Status)){
  60   self->Disconnect( func );
  61 }
  62 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Emit(Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *self,Dali::DeviceStatus::Memory::Status arg){
  63   self->Emit( arg );
  64 }
  65
  66 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
  67   return self->Empty();
  68 }
  69 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
  70 return self->GetConnectionCount();
  71 }
  72 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
  73   self->Connect( func );
  74 }
  75 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
  76   self->Disconnect( func );
  77 }
  78 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
  79   self->Emit( arg );
  80 }
  81
  82 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
  83   return self->Empty();
  84 }
  85 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,void *) > const *self){
  86 return self->GetConnectionCount();
  87 }
  88 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
  89 self->Connect( func );
  90 }
  91 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
  92 self->Disconnect( func );
  93 }
  94 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::Application &,void *) > *self,Dali::Application &arg1,void *arg2){
  95 self->Emit( arg1, arg2 );
  96 }
  97
  98 #ifdef __cplusplus
  99 extern "C" {
 100 #endif
 101
 102 /*Application binding*/
 103 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
 104   return (Dali::BaseHandle *)jarg1;
 105 }
 106
 107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
 108   void * jresult ;
 109   Dali::Application result;
 110
 111   {
 112     try {
 113       result = Dali::Application::New();
 114     } catch (std::out_of_range& e) {
 115       {
 116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 117       };
 118     } catch (std::exception& e) {
 119       {
 120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 121       };
 122     } catch (Dali::DaliException e) {
 123       {
 124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 125       };
 126     } catch (...) {
 127       {
 128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 129       };
 130     }
 131   }
 132
 133   jresult = new Dali::Application((const Dali::Application &)result);
 134   return jresult;
 135 }
 136
 137
 138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
 139   void * jresult ;
 140   int arg1 = 1;
 141   char ***arg2;
 142
 143   Dali::Application result;
 144   {
 145     std::string app_name = "dali-csharp-app";
 146     int stringLength = app_name.length();
 147     argV = new char*[arg1 + 1];
 148     argV[0] = new char[stringLength + 1];
 149
 150     strncpy(argV[0], app_name.c_str(), stringLength);
 151     argV[0][stringLength] = '\0';
 152     argV[1] = NULL;
 153
 154     arg2 = &argV;
 155   }
 156   {
 157     try {
 158       result = Dali::Application::New(&arg1, arg2);
 159     } catch (std::out_of_range& e) {
 160       {
 161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 162       };
 163     } catch (std::exception& e) {
 164       {
 165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 166       };
 167     } catch (Dali::DaliException e) {
 168       {
 169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 170       };
 171     } catch (...) {
 172       {
 173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 174       };
 175     }
 176   }
 177
 178   jresult = new Dali::Application((const Dali::Application &)result);
 179   return jresult;
 180 }
 181
 182
 183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
 184   void * jresult ;
 185   int arg1 = 1;
 186   char ***arg2;
 187   std::string *arg3 = 0;
 188
 189   Dali::Application result;
 190   {
 191     std::string app_name = "dali-csharp-app";
 192     int stringLength = app_name.length();
 193     argV = new char*[arg1 + 1];
 194     argV[0] = new char[stringLength + 1];
 195
 196     strncpy(argV[0], app_name.c_str(), stringLength);
 197     argV[0][stringLength] = '\0';
 198     argV[1] = NULL;
 199
 200     arg2 = &argV;
 201
 202   }
 203   if (!jarg3) {
 204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 205     delete []argV[0];
 206     delete []argV;
 207     return 0;
 208   }
 209   std::string arg3_str(jarg3);
 210   arg3 = &arg3_str;
 211   {
 212     try {
 213       result = Dali::Application::New(&arg1, arg2,(std::string const &)*arg3);
 214     } catch (std::out_of_range& e) {
 215       {
 216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 217       };
 218     } catch (std::exception& e) {
 219       {
 220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 221       };
 222     } catch (Dali::DaliException e) {
 223       {
 224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 225       };
 226     } catch (...) {
 227       {
 228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 229       };
 230     }
 231   }
 232
 233   jresult = new Dali::Application((const Dali::Application &)result);
 234
 235   //argout typemap for const std::string&
 236
 237   return jresult;
 238 }
 239
 240
 241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
 242   void * jresult ;
 243   int arg1 = 1;
 244   char ***arg2;
 245   std::string *arg3 = 0;
 246   Dali::Application::WINDOW_MODE arg4;
 247
 248   Dali::Application result;
 249   {
 250     std::string app_name = "dali-csharp-app";
 251     int stringLength = app_name.length();
 252     argV = new char*[arg1 + 1];
 253     argV[0] = new char[stringLength + 1];
 254
 255     strncpy(argV[0], app_name.c_str(), stringLength);
 256     argV[0][stringLength] = '\0';
 257     argV[1] = NULL;
 258
 259     arg2 = &argV;
 260   }
 261   if (!jarg3) {
 262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 263     delete []argV[0];
 264     delete []argV;
 265     return 0;
 266   }
 267   std::string arg3_str(jarg3);
 268   arg3 = &arg3_str;
 269   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
 270   {
 271     try {
 272       result = Dali::Application::New(&arg1, arg2,(std::string const &)*arg3,arg4);
 273     } catch (std::out_of_range& e) {
 274       {
 275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 276       };
 277     } catch (std::exception& e) {
 278       {
 279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 280       };
 281     } catch (Dali::DaliException e) {
 282       {
 283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 284       };
 285     } catch (...) {
 286       {
 287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 288       };
 289     }
 290   }
 291
 292   jresult = new Dali::Application((const Dali::Application &)result);
 293
 294   //argout typemap for const std::string&
 295
 296   return jresult;
 297 }
 298
 299
 300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__MANUAL_4(int jarg1, char * jarg2, char * jarg3, int jarg4) {
 301   void * jresult ;
 302   int *arg1 = (int *) 0 ;
 303   char ***arg2 ;
 304   std::string *arg3 = 0 ;
 305   Dali::Application::WINDOW_MODE arg4 ;
 306   Dali::Application result;
 307   {
 308     // Todo generate argv data from the C# args
 309     int index = 0;
 310     int length = 0;
 311     char *retPtr = NULL;
 312     char *nextPtr;
 313
 314     argV = new char*[jarg1 + 1];
 315
 316     for(retPtr = strtok_r(jarg2, " ", &nextPtr);
 317         retPtr != NULL && index < jarg1;
 318         retPtr = strtok_r(NULL, " ", &nextPtr))
 319     {
 320       length = 0;
 321       length = strlen(retPtr);
 322       argV[ index ] = new char[ length + 1 ];
 323       strncpy( argV[ index ], retPtr, length );
 324       argV[ index ][ length ] = '\0';
 325       index++;
 326     }
 327
 328     while( index < jarg1 )
 329     {
 330       //if jarg1 - index >1, maybe cause error.
 331       argV[index] = NULL;
 332       index++;
 333     }
 334
 335     argV[jarg1] = NULL;
 336     argC = jarg1;
 337
 338     arg1 = &argC;
 339     arg2 = &argV;
 340   }
 341
 342   std::string arg3_str(jarg3);
 343   arg3 = &arg3_str;
 344   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
 345   {
 346     try {
 347       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
 348     } catch (std::out_of_range& e) {
 349       {
 350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 351       };
 352     } catch (std::exception& e) {
 353       {
 354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 355       };
 356     } catch (Dali::DaliException e) {
 357       {
 358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 359       };
 360     } catch (...) {
 361       {
 362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 363       };
 364     }
 365   }
 366   jresult = new Dali::Application((const Dali::Application &)result);
 367   return jresult;
 368 }
 369
 370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
 371   void * jresult ;
 372   Dali::Application *result = 0 ;
 373
 374   {
 375     try {
 376       result = (Dali::Application *)new Dali::Application();
 377     } catch (std::out_of_range& e) {
 378       {
 379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 380       };
 381     } catch (std::exception& e) {
 382       {
 383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 384       };
 385     } catch (Dali::DaliException e) {
 386       {
 387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 388       };
 389     } catch (...) {
 390       {
 391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 392       };
 393     }
 394   }
 395
 396   jresult = (void *)result;
 397   return jresult;
 398 }
 399
 400
 401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
 402   void * jresult ;
 403   Dali::Application *arg1 = 0 ;
 404   Dali::Application *result = 0 ;
 405
 406   arg1 = (Dali::Application *)jarg1;
 407   if (!arg1) {
 408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
 409     return 0;
 410   }
 411   {
 412     try {
 413       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
 414     } catch (std::out_of_range& e) {
 415       {
 416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 417       };
 418     } catch (std::exception& e) {
 419       {
 420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 421       };
 422     } catch (Dali::DaliException e) {
 423       {
 424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 425       };
 426     } catch (...) {
 427       {
 428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 429       };
 430     }
 431   }
 432
 433   jresult = (void *)result;
 434   return jresult;
 435 }
 436
 437
 438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
 439   void * jresult ;
 440   Dali::Application *arg1 = (Dali::Application *) 0 ;
 441   Dali::Application *arg2 = 0 ;
 442   Dali::Application *result = 0 ;
 443
 444   arg1 = (Dali::Application *)jarg1;
 445   arg2 = (Dali::Application *)jarg2;
 446   if (!arg2) {
 447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
 448     return 0;
 449   }
 450   {
 451     try {
 452       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
 453     } catch (std::out_of_range& e) {
 454       {
 455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 456       };
 457     } catch (std::exception& e) {
 458       {
 459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 460       };
 461     } catch (Dali::DaliException e) {
 462       {
 463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 464       };
 465     } catch (...) {
 466       {
 467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 468       };
 469     }
 470   }
 471
 472   jresult = (void *)result;
 473   return jresult;
 474 }
 475
 476
 477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
 478   Dali::Application *arg1 = (Dali::Application *) 0 ;
 479
 480   arg1 = (Dali::Application *)jarg1;
 481   {
 482     try {
 483       delete arg1;
 484       if( argV )
 485       {
 486         // free string data
 487         for( int i=0; i < argC+1; i++)
 488         {
 489           delete [] argV[i];
 490         }
 491         delete [] argV;
 492       }
 493     } catch (std::out_of_range& e) {
 494       {
 495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 496       };
 497     } catch (std::exception& e) {
 498       {
 499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 500       };
 501     } catch (Dali::DaliException e) {
 502       {
 503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 504       };
 505     } catch (...) {
 506       {
 507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 508       };
 509     }
 510   }
 511
 512 }
 513
 514
 515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
 516   Dali::Application *arg1 = (Dali::Application *) 0 ;
 517
 518   arg1 = (Dali::Application *)jarg1;
 519   {
 520     try {
 521       (arg1)->MainLoop();
 522     } catch (std::out_of_range& e) {
 523       {
 524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 525       };
 526     } catch (std::exception& e) {
 527       {
 528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 529       };
 530     } catch (Dali::DaliException e) {
 531       {
 532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 533       };
 534     } catch (...) {
 535       {
 536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 537       };
 538     }
 539   }
 540
 541 }
 542
 543
 544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
 545   Dali::Application *arg1 = (Dali::Application *) 0 ;
 546   Dali::Configuration::ContextLoss arg2 ;
 547   Dali::Configuration::ContextLoss *argp2 ;
 548
 549   arg1 = (Dali::Application *)jarg1;
 550   argp2 = (Dali::Configuration::ContextLoss *)jarg2;
 551   if (!argp2) {
 552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
 553     return ;
 554   }
 555   arg2 = *argp2;
 556   {
 557     try {
 558       (arg1)->MainLoop(arg2);
 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_Application_Lower(void * jarg1) {
 582   Dali::Application *arg1 = (Dali::Application *) 0 ;
 583
 584   arg1 = (Dali::Application *)jarg1;
 585   {
 586     try {
 587       (arg1)->Lower();
 588     } catch (std::out_of_range& e) {
 589       {
 590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 591       };
 592     } catch (std::exception& e) {
 593       {
 594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 595       };
 596     } catch (Dali::DaliException e) {
 597       {
 598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 599       };
 600     } catch (...) {
 601       {
 602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 603       };
 604     }
 605   }
 606
 607 }
 608
 609
 610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
 611   Dali::Application *arg1 = (Dali::Application *) 0 ;
 612
 613   arg1 = (Dali::Application *)jarg1;
 614   {
 615     try {
 616       (arg1)->Quit();
 617     } catch (std::out_of_range& e) {
 618       {
 619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 620       };
 621     } catch (std::exception& e) {
 622       {
 623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 624       };
 625     } catch (Dali::DaliException e) {
 626       {
 627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 628       };
 629     } catch (...) {
 630       {
 631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 632       };
 633     }
 634   }
 635
 636 }
 637
 638
 639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
 640   unsigned int jresult ;
 641   Dali::Application *arg1 = (Dali::Application *) 0 ;
 642   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
 643   bool result;
 644
 645   arg1 = (Dali::Application *)jarg1;
 646   arg2 = (Dali::CallbackBase *)jarg2;
 647   {
 648     try {
 649       result = (bool)(arg1)->AddIdle(arg2);
 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_Application_GetWindow(void * jarg1) {
 675   void * jresult ;
 676   Dali::Application *arg1 = (Dali::Application *) 0 ;
 677   Dali::Window result;
 678
 679   arg1 = (Dali::Application *)jarg1;
 680   {
 681     try {
 682       result = (arg1)->GetWindow();
 683     } catch (std::out_of_range& e) {
 684       {
 685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 686       };
 687     } catch (std::exception& e) {
 688       {
 689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 690       };
 691     } catch (Dali::DaliException e) {
 692       {
 693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 694       };
 695     } catch (...) {
 696       {
 697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 698       };
 699     }
 700   }
 701
 702   jresult = new Dali::Window((const Dali::Window &)result);
 703   return jresult;
 704 }
 705
 706
 707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
 708   Dali::Application *arg1 = (Dali::Application *) 0 ;
 709   Dali::PositionSize arg2 ;
 710   std::string *arg3 = 0 ;
 711   Dali::PositionSize *argp2 ;
 712
 713   arg1 = (Dali::Application *)jarg1;
 714   argp2 = (Dali::PositionSize *)jarg2;
 715   if (!argp2) {
 716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
 717     return ;
 718   }
 719   arg2 = *argp2;
 720   if (!jarg3) {
 721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 722     return ;
 723   }
 724   std::string arg3_str(jarg3);
 725   arg3 = &arg3_str;
 726   {
 727     try {
 728       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
 729     } catch (std::out_of_range& e) {
 730       {
 731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 732       };
 733     } catch (std::exception& e) {
 734       {
 735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 736       };
 737     } catch (Dali::DaliException e) {
 738       {
 739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 740       };
 741     } catch (...) {
 742       {
 743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 744       };
 745     }
 746   }
 747
 748
 749   //argout typemap for const std::string&
 750
 751 }
 752
 753
 754 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
 755   char * jresult ;
 756   std::string result;
 757
 758   {
 759     try {
 760       result = Dali::Application::GetResourcePath();
 761     } catch (std::out_of_range& e) {
 762       {
 763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 764       };
 765     } catch (std::exception& e) {
 766       {
 767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 768       };
 769     } catch (Dali::DaliException e) {
 770       {
 771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 772       };
 773     } catch (...) {
 774       {
 775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 776       };
 777     }
 778   }
 779
 780   jresult = SWIG_csharp_string_callback((&result)->c_str());
 781   return jresult;
 782 }
 783
 784 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetRegion(void * jarg1) {
 785   char * jresult ;
 786   Dali::Application *arg1 = (Dali::Application *) 0 ;
 787   std::string result;
 788
 789   arg1 = (Dali::Application *)jarg1;
 790   {
 791     try {
 792       result = (arg1)->GetRegion();
 793     } catch (std::out_of_range& e) {
 794       {
 795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 796       };
 797     } catch (std::exception& e) {
 798       {
 799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 800       };
 801     } catch (Dali::DaliException e) {
 802       {
 803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 804       };
 805     } catch (...) {
 806       {
 807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 808       };
 809     }
 810   }
 811   jresult = SWIG_csharp_string_callback((&result)->c_str());
 812   return jresult;
 813 }
 814
 815
 816 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetLanguage(void * jarg1) {
 817   char * jresult ;
 818   Dali::Application *arg1 = (Dali::Application *) 0 ;
 819   std::string result;
 820
 821   arg1 = (Dali::Application *)jarg1;
 822   {
 823     try {
 824       result = (arg1)->GetLanguage();
 825     } catch (std::out_of_range& e) {
 826       {
 827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 828       };
 829     } catch (std::exception& e) {
 830       {
 831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 832       };
 833     } catch (Dali::DaliException e) {
 834       {
 835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 836       };
 837     } catch (...) {
 838       {
 839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 840       };
 841     }
 842   }
 843   jresult = SWIG_csharp_string_callback((&result)->c_str());
 844   return jresult;
 845 }
 846
 847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
 848   Dali::Application *arg1 = (Dali::Application *) 0 ;
 849   Dali::ViewMode arg2 ;
 850
 851   arg1 = (Dali::Application *)jarg1;
 852   arg2 = (Dali::ViewMode)jarg2;
 853   {
 854     try {
 855       (arg1)->SetViewMode(arg2);
 856     } catch (std::out_of_range& e) {
 857       {
 858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 859       };
 860     } catch (std::exception& e) {
 861       {
 862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 863       };
 864     } catch (Dali::DaliException e) {
 865       {
 866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 867       };
 868     } catch (...) {
 869       {
 870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 871       };
 872     }
 873   }
 874
 875 }
 876
 877
 878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
 879   int jresult ;
 880   Dali::Application *arg1 = (Dali::Application *) 0 ;
 881   Dali::ViewMode result;
 882
 883   arg1 = (Dali::Application *)jarg1;
 884   {
 885     try {
 886       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
 887     } catch (std::out_of_range& e) {
 888       {
 889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 890       };
 891     } catch (std::exception& e) {
 892       {
 893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 894       };
 895     } catch (Dali::DaliException e) {
 896       {
 897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 898       };
 899     } catch (...) {
 900       {
 901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 902       };
 903     }
 904   }
 905
 906   jresult = (int)result;
 907   return jresult;
 908 }
 909
 910
 911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
 912   Dali::Application *arg1 = (Dali::Application *) 0 ;
 913   float arg2 ;
 914
 915   arg1 = (Dali::Application *)jarg1;
 916   arg2 = (float)jarg2;
 917   {
 918     try {
 919       (arg1)->SetStereoBase(arg2);
 920     } catch (std::out_of_range& e) {
 921       {
 922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 923       };
 924     } catch (std::exception& e) {
 925       {
 926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 927       };
 928     } catch (Dali::DaliException e) {
 929       {
 930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 931       };
 932     } catch (...) {
 933       {
 934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 935       };
 936     }
 937   }
 938
 939 }
 940
 941
 942 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
 943   float jresult ;
 944   Dali::Application *arg1 = (Dali::Application *) 0 ;
 945   float result;
 946
 947   arg1 = (Dali::Application *)jarg1;
 948   {
 949     try {
 950       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
 951     } catch (std::out_of_range& e) {
 952       {
 953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 954       };
 955     } catch (std::exception& e) {
 956       {
 957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 958       };
 959     } catch (Dali::DaliException e) {
 960       {
 961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 962       };
 963     } catch (...) {
 964       {
 965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 966       };
 967     }
 968   }
 969
 970   jresult = result;
 971   return jresult;
 972 }
 973
 974
 975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
 976   void * jresult ;
 977   Dali::Application *arg1 = (Dali::Application *) 0 ;
 978   Dali::Application::AppSignalType *result = 0 ;
 979
 980   arg1 = (Dali::Application *)jarg1;
 981   {
 982     try {
 983       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
 984     } catch (std::out_of_range& e) {
 985       {
 986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 987       };
 988     } catch (std::exception& e) {
 989       {
 990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 991       };
 992     } catch (Dali::DaliException e) {
 993       {
 994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 995       };
 996     } catch (...) {
 997       {
 998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 999       };
1000     }
1001   }
1002
1003   jresult = (void *)result;
1004   return jresult;
1005 }
1006
1007
1008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
1009   void * jresult ;
1010   Dali::Application *arg1 = (Dali::Application *) 0 ;
1011   Dali::Application::AppSignalType *result = 0 ;
1012
1013   arg1 = (Dali::Application *)jarg1;
1014   {
1015     try {
1016       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
1017     } catch (std::out_of_range& e) {
1018       {
1019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1020       };
1021     } catch (std::exception& e) {
1022       {
1023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1024       };
1025     } catch (Dali::DaliException e) {
1026       {
1027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1028       };
1029     } catch (...) {
1030       {
1031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1032       };
1033     }
1034   }
1035
1036   jresult = (void *)result;
1037   return jresult;
1038 }
1039
1040
1041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
1042   void * jresult ;
1043   Dali::Application *arg1 = (Dali::Application *) 0 ;
1044   Dali::Application::AppSignalType *result = 0 ;
1045
1046   arg1 = (Dali::Application *)jarg1;
1047   {
1048     try {
1049       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
1050     } catch (std::out_of_range& e) {
1051       {
1052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1053       };
1054     } catch (std::exception& e) {
1055       {
1056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1057       };
1058     } catch (Dali::DaliException e) {
1059       {
1060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1061       };
1062     } catch (...) {
1063       {
1064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1065       };
1066     }
1067   }
1068
1069   jresult = (void *)result;
1070   return jresult;
1071 }
1072
1073
1074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
1075   void * jresult ;
1076   Dali::Application *arg1 = (Dali::Application *) 0 ;
1077   Dali::Application::AppSignalType *result = 0 ;
1078
1079   arg1 = (Dali::Application *)jarg1;
1080   {
1081     try {
1082       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
1083     } catch (std::out_of_range& e) {
1084       {
1085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1086       };
1087     } catch (std::exception& e) {
1088       {
1089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1090       };
1091     } catch (Dali::DaliException e) {
1092       {
1093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1094       };
1095     } catch (...) {
1096       {
1097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1098       };
1099     }
1100   }
1101
1102   jresult = (void *)result;
1103   return jresult;
1104 }
1105
1106
1107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
1108   void * jresult ;
1109   Dali::Application *arg1 = (Dali::Application *) 0 ;
1110   Dali::Application::AppSignalType *result = 0 ;
1111
1112   arg1 = (Dali::Application *)jarg1;
1113   {
1114     try {
1115       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
1116     } catch (std::out_of_range& e) {
1117       {
1118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1119       };
1120     } catch (std::exception& e) {
1121       {
1122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1123       };
1124     } catch (Dali::DaliException e) {
1125       {
1126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1127       };
1128     } catch (...) {
1129       {
1130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1131       };
1132     }
1133   }
1134
1135   jresult = (void *)result;
1136   return jresult;
1137 }
1138
1139
1140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
1141   void * jresult ;
1142   Dali::Application *arg1 = (Dali::Application *) 0 ;
1143   Dali::Application::AppSignalType *result = 0 ;
1144
1145   arg1 = (Dali::Application *)jarg1;
1146   {
1147     try {
1148       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
1149     } catch (std::out_of_range& e) {
1150       {
1151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1152       };
1153     } catch (std::exception& e) {
1154       {
1155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1156       };
1157     } catch (Dali::DaliException e) {
1158       {
1159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1160       };
1161     } catch (...) {
1162       {
1163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1164       };
1165     }
1166   }
1167
1168   jresult = (void *)result;
1169   return jresult;
1170 }
1171
1172
1173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
1174   void * jresult ;
1175   Dali::Application *arg1 = (Dali::Application *) 0 ;
1176   Dali::Application::AppControlSignalType *result = 0 ;
1177
1178   arg1 = (Dali::Application *)jarg1;
1179   {
1180     try {
1181       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
1182     } catch (std::out_of_range& e) {
1183       {
1184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1185       };
1186     } catch (std::exception& e) {
1187       {
1188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1189       };
1190     } catch (Dali::DaliException e) {
1191       {
1192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1193       };
1194     } catch (...) {
1195       {
1196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1197       };
1198     }
1199   }
1200
1201   jresult = (void *)result;
1202   return jresult;
1203 }
1204
1205
1206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
1207   void * jresult ;
1208   Dali::Application *arg1 = (Dali::Application *) 0 ;
1209   Dali::Application::AppSignalType *result = 0 ;
1210
1211   arg1 = (Dali::Application *)jarg1;
1212   {
1213     try {
1214       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
1215     } catch (std::out_of_range& e) {
1216       {
1217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1218       };
1219     } catch (std::exception& e) {
1220       {
1221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1222       };
1223     } catch (Dali::DaliException e) {
1224       {
1225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1226       };
1227     } catch (...) {
1228       {
1229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1230       };
1231     }
1232   }
1233
1234   jresult = (void *)result;
1235   return jresult;
1236 }
1237
1238
1239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
1240   void * jresult ;
1241   Dali::Application *arg1 = (Dali::Application *) 0 ;
1242   Dali::Application::AppSignalType *result = 0 ;
1243
1244   arg1 = (Dali::Application *)jarg1;
1245   {
1246     try {
1247       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
1248     } catch (std::out_of_range& e) {
1249       {
1250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1251       };
1252     } catch (std::exception& e) {
1253       {
1254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1255       };
1256     } catch (Dali::DaliException e) {
1257       {
1258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1259       };
1260     } catch (...) {
1261       {
1262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1263       };
1264     }
1265   }
1266
1267   jresult = (void *)result;
1268   return jresult;
1269 }
1270
1271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LowBatterySignal(void * jarg1) {
1272   void * jresult ;
1273   Dali::Application *arg1 = (Dali::Application *) 0 ;
1274   Dali::Application::LowBatterySignalType *result = 0 ;
1275
1276   arg1 = (Dali::Application *)jarg1;
1277   {
1278     try {
1279       result = (Dali::Application::LowBatterySignalType *) &(arg1)->LowBatterySignal();
1280     } catch (std::out_of_range& e) {
1281       {
1282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1283       };
1284     } catch (std::exception& e) {
1285       {
1286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1287       };
1288     } catch (Dali::DaliException e) {
1289       {
1290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1291       };
1292     } catch (...) {
1293       {
1294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1295       };
1296     }
1297   }
1298
1299   jresult = (void *)result;
1300   return jresult;
1301 }
1302
1303
1304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LowMemorySignal(void * jarg1) {
1305   void * jresult ;
1306   Dali::Application *arg1 = (Dali::Application *) 0 ;
1307   Dali::Application::LowMemorySignalType *result = 0 ;
1308
1309   arg1 = (Dali::Application *)jarg1;
1310   {
1311     try {
1312       result = (Dali::Application::LowMemorySignalType *) &(arg1)->LowMemorySignal();
1313     } catch (std::out_of_range& e) {
1314       {
1315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1316       };
1317     } catch (std::exception& e) {
1318       {
1319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1320       };
1321     } catch (Dali::DaliException e) {
1322       {
1323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1324       };
1325     } catch (...) {
1326       {
1327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1328       };
1329     }
1330   }
1331   jresult = (void *)result;
1332   return jresult;
1333 }
1334
1335
1336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Empty(void * jarg1) {
1337   unsigned int jresult ;
1338   Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
1339   bool result;
1340
1341   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
1342   {
1343     try {
1344       result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Empty((Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > const *)arg1);
1345     } catch (std::out_of_range& e) {
1346       {
1347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1348       };
1349     } catch (std::exception& e) {
1350       {
1351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1352       };
1353     } catch (Dali::DaliException e) {
1354       {
1355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1356       };
1357     } catch (...) {
1358       {
1359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1360       };
1361     }
1362   }
1363
1364   jresult = result;
1365   return jresult;
1366 }
1367
1368
1369 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_GetConnectionCount(void * jarg1) {
1370   unsigned long jresult ;
1371   Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
1372   std::size_t result;
1373
1374   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
1375   {
1376     try {
1377       result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > const *)arg1);
1378     } catch (std::out_of_range& e) {
1379       {
1380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1381       };
1382     } catch (std::exception& e) {
1383       {
1384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1385       };
1386     } catch (Dali::DaliException e) {
1387       {
1388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1389       };
1390     } catch (...) {
1391       {
1392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1393       };
1394     }
1395   }
1396   jresult = (unsigned long)result;
1397   return jresult;
1398 }
1399
1400
1401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Connect(void * jarg1, void * jarg2) {
1402   Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
1403   void (*arg2)(Dali::DeviceStatus::Battery::Status) = (void (*)(Dali::DeviceStatus::Battery::Status)) 0 ;
1404
1405   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
1406   arg2 = (void (*)(Dali::DeviceStatus::Battery::Status))jarg2;
1407   {
1408     try {
1409       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Connect(arg1,arg2);
1410     } catch (std::out_of_range& e) {
1411       {
1412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1413       };
1414     } catch (std::exception& e) {
1415       {
1416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1417       };
1418     } catch (Dali::DaliException e) {
1419       {
1420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1421       };
1422     } catch (...) {
1423       {
1424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1425       };
1426     }
1427   }
1428 }
1429
1430
1431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Disconnect(void * jarg1, void * jarg2) {
1432   Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
1433   void (*arg2)(Dali::DeviceStatus::Battery::Status) = (void (*)(Dali::DeviceStatus::Battery::Status)) 0 ;
1434
1435   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
1436   arg2 = (void (*)(Dali::DeviceStatus::Battery::Status))jarg2;
1437   {
1438     try {
1439       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Disconnect(arg1,arg2);
1440     } catch (std::out_of_range& e) {
1441       {
1442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1443       };
1444     } catch (std::exception& e) {
1445       {
1446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1447       };
1448     } catch (Dali::DaliException e) {
1449       {
1450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1451       };
1452     } catch (...) {
1453       {
1454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1455       };
1456     }
1457   }
1458 }
1459
1460
1461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Emit(void * jarg1, void * jarg2) {
1462   Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
1463   Dali::DeviceStatus::Battery::Status arg2 ;
1464   Dali::DeviceStatus::Battery::Status *argp2 ;
1465
1466   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
1467   argp2 = (Dali::DeviceStatus::Battery::Status *)jarg2;
1468   if (!argp2) {
1469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Battery::Status", 0);
1470     return ;
1471   }
1472   arg2 = *argp2;
1473   {
1474     try {
1475       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Emit(arg1,arg2);
1476     } catch (std::out_of_range& e) {
1477       {
1478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1479       };
1480     } catch (std::exception& e) {
1481       {
1482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1483       };
1484     } catch (Dali::DaliException e) {
1485       {
1486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1487       };
1488     } catch (...) {
1489       {
1490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1491       };
1492     }
1493   }
1494 }
1495
1496
1497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_new_LowBatterySignalType() {
1498   void * jresult ;
1499   Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *result = 0 ;
1500
1501   {
1502     try {
1503       result = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)new Dali::Signal< void (Dali::DeviceStatus::Battery::Status) >();
1504     } catch (std::out_of_range& e) {
1505       {
1506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1507       };
1508     } catch (std::exception& e) {
1509       {
1510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1511       };
1512     } catch (Dali::DaliException e) {
1513       {
1514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1515       };
1516     } catch (...) {
1517       {
1518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1519       };
1520     }
1521   }
1522
1523   jresult = (void *)result;
1524   return jresult;
1525 }
1526
1527
1528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_LowBatterySignalType(void * jarg1) {
1529   Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
1530
1531   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
1532   {
1533     try {
1534       delete arg1;
1535     } catch (std::out_of_range& e) {
1536       {
1537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1538       };
1539     } catch (std::exception& e) {
1540       {
1541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1542       };
1543     } catch (Dali::DaliException e) {
1544       {
1545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1546       };
1547     } catch (...) {
1548       {
1549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1550       };
1551     }
1552   }
1553 }
1554
1555
1556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Empty(void * jarg1) {
1557   unsigned int jresult ;
1558   Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
1559   bool result;
1560
1561   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
1562   {
1563     try {
1564       result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Empty((Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > const *)arg1);
1565     } catch (std::out_of_range& e) {
1566       {
1567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1568       };
1569     } catch (std::exception& e) {
1570       {
1571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1572       };
1573     } catch (Dali::DaliException e) {
1574       {
1575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1576       };
1577     } catch (...) {
1578       {
1579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1580       };
1581     }
1582   }
1583   jresult = result;
1584   return jresult;
1585 }
1586
1587
1588 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_GetConnectionCount(void * jarg1) {
1589   unsigned long jresult ;
1590   Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
1591   std::size_t result;
1592
1593   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
1594   {
1595     try {
1596       result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > const *)arg1);
1597     } catch (std::out_of_range& e) {
1598       {
1599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1600       };
1601     } catch (std::exception& e) {
1602       {
1603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1604       };
1605     } catch (Dali::DaliException e) {
1606       {
1607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1608       };
1609     } catch (...) {
1610       {
1611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1612       };
1613     }
1614   }
1615   jresult = (unsigned long)result;
1616   return jresult;
1617 }
1618
1619
1620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Connect(void * jarg1, void * jarg2) {
1621   Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
1622   void (*arg2)(Dali::DeviceStatus::Memory::Status) = (void (*)(Dali::DeviceStatus::Memory::Status)) 0 ;
1623
1624   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
1625   arg2 = (void (*)(Dali::DeviceStatus::Memory::Status))jarg2;
1626   {
1627     try {
1628       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Connect(arg1,arg2);
1629     } catch (std::out_of_range& e) {
1630       {
1631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1632       };
1633     } catch (std::exception& e) {
1634       {
1635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1636       };
1637     } catch (Dali::DaliException e) {
1638       {
1639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1640       };
1641     } catch (...) {
1642       {
1643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1644       };
1645     }
1646   }
1647 }
1648
1649
1650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Disconnect(void * jarg1, void * jarg2) {
1651   Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
1652   void (*arg2)(Dali::DeviceStatus::Memory::Status) = (void (*)(Dali::DeviceStatus::Memory::Status)) 0 ;
1653
1654   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
1655   arg2 = (void (*)(Dali::DeviceStatus::Memory::Status))jarg2;
1656   {
1657     try {
1658       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Disconnect(arg1,arg2);
1659     } catch (std::out_of_range& e) {
1660       {
1661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1662       };
1663     } catch (std::exception& e) {
1664       {
1665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1666       };
1667     } catch (Dali::DaliException e) {
1668       {
1669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1670       };
1671     } catch (...) {
1672       {
1673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1674       };
1675     }
1676   }
1677 }
1678
1679
1680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Emit(void * jarg1, void * jarg2) {
1681   Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
1682   Dali::DeviceStatus::Memory::Status arg2 ;
1683   Dali::DeviceStatus::Memory::Status *argp2 ;
1684
1685   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
1686   argp2 = (Dali::DeviceStatus::Memory::Status *)jarg2;
1687   if (!argp2) {
1688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Memory::Status", 0);
1689     return ;
1690   }
1691   arg2 = *argp2;
1692   {
1693     try {
1694       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Emit(arg1,arg2);
1695     } catch (std::out_of_range& e) {
1696       {
1697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1698       };
1699     } catch (std::exception& e) {
1700       {
1701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1702       };
1703     } catch (Dali::DaliException e) {
1704       {
1705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1706       };
1707     } catch (...) {
1708       {
1709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1710       };
1711     }
1712   }
1713 }
1714
1715
1716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_new_LowMemorySignalType() {
1717   void * jresult ;
1718   Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *result = 0 ;
1719
1720   {
1721     try {
1722       result = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)new Dali::Signal< void (Dali::DeviceStatus::Memory::Status) >();
1723     } catch (std::out_of_range& e) {
1724       {
1725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1726       };
1727     } catch (std::exception& e) {
1728       {
1729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1730       };
1731     } catch (Dali::DaliException e) {
1732       {
1733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1734       };
1735     } catch (...) {
1736       {
1737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1738       };
1739     }
1740   }
1741   jresult = (void *)result;
1742   return jresult;
1743 }
1744
1745
1746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_LowMemorySignalType(void * jarg1) {
1747   Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
1748
1749   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
1750   {
1751     try {
1752       delete arg1;
1753     } catch (std::out_of_range& e) {
1754       {
1755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1756       };
1757     } catch (std::exception& e) {
1758       {
1759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1760       };
1761     } catch (Dali::DaliException e) {
1762       {
1763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1764       };
1765     } catch (...) {
1766       {
1767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1768       };
1769     }
1770   }
1771 }
1772
1773
1774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
1775   unsigned int jresult ;
1776   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1777   bool result;
1778
1779   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1780   {
1781     try {
1782       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
1783     } catch (std::out_of_range& e) {
1784       {
1785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1786       };
1787     } catch (std::exception& e) {
1788       {
1789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1790       };
1791     } catch (Dali::DaliException e) {
1792       {
1793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1794       };
1795     } catch (...) {
1796       {
1797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1798       };
1799     }
1800   }
1801
1802   jresult = result;
1803   return jresult;
1804 }
1805
1806
1807 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
1808   unsigned long jresult ;
1809   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1810   std::size_t result;
1811
1812   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1813   {
1814     try {
1815       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
1816     } catch (std::out_of_range& e) {
1817       {
1818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1819       };
1820     } catch (std::exception& e) {
1821       {
1822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1823       };
1824     } catch (Dali::DaliException e) {
1825       {
1826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1827       };
1828     } catch (...) {
1829       {
1830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1831       };
1832     }
1833   }
1834
1835   jresult = (unsigned long)result;
1836   return jresult;
1837 }
1838
1839
1840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
1841   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1842   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
1843
1844   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1845   arg2 = (void (*)(Dali::Application &))jarg2;
1846   {
1847     try {
1848       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
1849     } catch (std::out_of_range& e) {
1850       {
1851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1852       };
1853     } catch (std::exception& e) {
1854       {
1855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1856       };
1857     } catch (Dali::DaliException e) {
1858       {
1859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1860       };
1861     } catch (...) {
1862       {
1863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1864       };
1865     }
1866   }
1867
1868 }
1869
1870
1871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
1872   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1873   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
1874
1875   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1876   arg2 = (void (*)(Dali::Application &))jarg2;
1877   {
1878     try {
1879       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
1880     } catch (std::out_of_range& e) {
1881       {
1882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1883       };
1884     } catch (std::exception& e) {
1885       {
1886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1887       };
1888     } catch (Dali::DaliException e) {
1889       {
1890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1891       };
1892     } catch (...) {
1893       {
1894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1895       };
1896     }
1897   }
1898
1899 }
1900
1901
1902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
1903   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1904   Dali::Application *arg2 = 0 ;
1905
1906   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1907   arg2 = (Dali::Application *)jarg2;
1908   if (!arg2) {
1909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
1910     return ;
1911   }
1912   {
1913     try {
1914       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
1915     } catch (std::out_of_range& e) {
1916       {
1917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1918       };
1919     } catch (std::exception& e) {
1920       {
1921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1922       };
1923     } catch (Dali::DaliException e) {
1924       {
1925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1926       };
1927     } catch (...) {
1928       {
1929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1930       };
1931     }
1932   }
1933
1934 }
1935
1936
1937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
1938   void * jresult ;
1939   Dali::Signal< void (Dali::Application &) > *result = 0 ;
1940
1941   {
1942     try {
1943       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
1944     } catch (std::out_of_range& e) {
1945       {
1946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1947       };
1948     } catch (std::exception& e) {
1949       {
1950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1951       };
1952     } catch (Dali::DaliException e) {
1953       {
1954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1955       };
1956     } catch (...) {
1957       {
1958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1959       };
1960     }
1961   }
1962
1963   jresult = (void *)result;
1964   return jresult;
1965 }
1966
1967
1968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
1969   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1970
1971   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1972   {
1973     try {
1974       delete arg1;
1975     } catch (std::out_of_range& e) {
1976       {
1977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1978       };
1979     } catch (std::exception& e) {
1980       {
1981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1982       };
1983     } catch (Dali::DaliException e) {
1984       {
1985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1986       };
1987     } catch (...) {
1988       {
1989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1990       };
1991     }
1992   }
1993
1994 }
1995
1996
1997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
1998   unsigned int jresult ;
1999   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
2000   bool result;
2001
2002   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
2003   {
2004     try {
2005       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
2006     } catch (std::out_of_range& e) {
2007       {
2008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2009       };
2010     } catch (std::exception& e) {
2011       {
2012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2013       };
2014     } catch (Dali::DaliException e) {
2015       {
2016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2017       };
2018     } catch (...) {
2019       {
2020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2021       };
2022     }
2023   }
2024
2025   jresult = result;
2026   return jresult;
2027 }
2028
2029
2030 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
2031   unsigned long jresult ;
2032   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
2033   std::size_t result;
2034
2035   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
2036   {
2037     try {
2038       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
2039     } catch (std::out_of_range& e) {
2040       {
2041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2042       };
2043     } catch (std::exception& e) {
2044       {
2045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2046       };
2047     } catch (Dali::DaliException e) {
2048       {
2049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2050       };
2051     } catch (...) {
2052       {
2053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2054       };
2055     }
2056   }
2057
2058   jresult = (unsigned long)result;
2059   return jresult;
2060 }
2061
2062
2063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
2064   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
2065   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
2066
2067   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
2068   arg2 = (void (*)(Dali::Application &,void *))jarg2;
2069   {
2070     try {
2071       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
2072     } catch (std::out_of_range& e) {
2073       {
2074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2075       };
2076     } catch (std::exception& e) {
2077       {
2078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2079       };
2080     } catch (Dali::DaliException e) {
2081       {
2082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2083       };
2084     } catch (...) {
2085       {
2086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2087       };
2088     }
2089   }
2090
2091 }
2092
2093
2094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
2095   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
2096   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
2097
2098   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
2099   arg2 = (void (*)(Dali::Application &,void *))jarg2;
2100   {
2101     try {
2102       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
2103     } catch (std::out_of_range& e) {
2104       {
2105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2106       };
2107     } catch (std::exception& e) {
2108       {
2109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2110       };
2111     } catch (Dali::DaliException e) {
2112       {
2113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2114       };
2115     } catch (...) {
2116       {
2117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2118       };
2119     }
2120   }
2121
2122 }
2123
2124
2125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
2126   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
2127   Dali::Application *arg2 = 0 ;
2128   void *arg3 = (void *) 0 ;
2129
2130   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
2131   arg2 = (Dali::Application *)jarg2;
2132   if (!arg2) {
2133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
2134     return ;
2135   }
2136   arg3 = jarg3;
2137   {
2138     try {
2139       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
2140     } catch (std::out_of_range& e) {
2141       {
2142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2143       };
2144     } catch (std::exception& e) {
2145       {
2146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2147       };
2148     } catch (Dali::DaliException e) {
2149       {
2150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2151       };
2152     } catch (...) {
2153       {
2154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2155       };
2156     }
2157   }
2158
2159 }
2160
2161
2162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
2163   void * jresult ;
2164   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
2165
2166   {
2167     try {
2168       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
2169     } catch (std::out_of_range& e) {
2170       {
2171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2172       };
2173     } catch (std::exception& e) {
2174       {
2175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2176       };
2177     } catch (Dali::DaliException e) {
2178       {
2179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2180       };
2181     } catch (...) {
2182       {
2183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2184       };
2185     }
2186   }
2187
2188   jresult = (void *)result;
2189   return jresult;
2190 }
2191
2192
2193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
2194   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
2195
2196   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
2197   {
2198     try {
2199       delete arg1;
2200     } catch (std::out_of_range& e) {
2201       {
2202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2203       };
2204     } catch (std::exception& e) {
2205       {
2206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2207       };
2208     } catch (Dali::DaliException e) {
2209       {
2210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2211       };
2212     } catch (...) {
2213       {
2214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2215       };
2216     }
2217   }
2218
2219 }
2220
2221
2222 /*application-devel binding*/
2223
2224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_4(int jarg1, char * jarg3, int jarg4, void * jarg5) {
2225   void * jresult ;
2226   int *arg1 = (int *) 0 ;
2227   char ***arg2 ;
2228   std::string *arg3 = 0 ;
2229   Dali::Application::WINDOW_MODE arg4 ;
2230   Dali::PositionSize arg5 ;
2231   Dali::PositionSize *argp5 ;
2232   Dali::Application result;
2233
2234   {
2235     // Todo generate argv data from the C# args
2236     char **array;         // two dimensional array
2237     int numStrings = 1;     // number of strings
2238     int stringLength = 30;      // max string length.
2239     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
2240     if(!array) {
2241       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "array is null", 0);
2242       return 0;
2243     }
2244     argV = array;
2245
2246     // allocate the string data
2247     for( int i=0; i < numStrings; i++)
2248     {
2249       array[i]=(char *)malloc( stringLength * sizeof(char) );
2250     }
2251     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
2252
2253     std::string temp = "dali-csharp-app";
2254
2255     if(!array[0]) {
2256       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "array[0] is null", 0);
2257       return 0;
2258     }
2259     array[0][temp.copy(array[0], strlen(array[0])-1)] = '\0';
2260
2261     arg1 = &argC;
2262     arg2 = &argV;
2263   }
2264   if (!jarg3) {
2265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
2266     return 0;
2267   }
2268   std::string arg3_str(jarg3);
2269   arg3 = &arg3_str;
2270   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
2271   argp5 = (Dali::PositionSize *)jarg5;
2272   if (!argp5) {
2273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
2274     return 0;
2275   }
2276   arg5 = *argp5;
2277   {
2278     try {
2279       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4,arg5);
2280     } catch (std::out_of_range& e) {
2281       {
2282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2283       };
2284     } catch (std::exception& e) {
2285       {
2286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2287       };
2288     } catch (Dali::DaliException e) {
2289       {
2290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2291       };
2292     } catch (...) {
2293       {
2294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2295       };
2296     }
2297   }
2298
2299   jresult = new Dali::Application((const Dali::Application &)result);
2300
2301   return jresult;
2302 }
2303
2304
2305
2306 #ifdef __cplusplus
2307 }
2308 #endif
2309