dali-csharp-binder/src/application.cpp

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