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_InitSignal(void * jarg1) {
 848   void * jresult ;
 849   Dali::Application *arg1 = (Dali::Application *) 0 ;
 850   Dali::Application::AppSignalType *result = 0 ;
 851
 852   arg1 = (Dali::Application *)jarg1;
 853   {
 854     try {
 855       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
 856     } catch (std::out_of_range& e) {
 857       {
 858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 859       };
 860     } catch (std::exception& e) {
 861       {
 862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 863       };
 864     } catch (Dali::DaliException e) {
 865       {
 866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 867       };
 868     } catch (...) {
 869       {
 870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 871       };
 872     }
 873   }
 874
 875   jresult = (void *)result;
 876   return jresult;
 877 }
 878
 879
 880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
 881   void * jresult ;
 882   Dali::Application *arg1 = (Dali::Application *) 0 ;
 883   Dali::Application::AppSignalType *result = 0 ;
 884
 885   arg1 = (Dali::Application *)jarg1;
 886   {
 887     try {
 888       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
 889     } catch (std::out_of_range& e) {
 890       {
 891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 892       };
 893     } catch (std::exception& e) {
 894       {
 895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 896       };
 897     } catch (Dali::DaliException e) {
 898       {
 899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 900       };
 901     } catch (...) {
 902       {
 903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 904       };
 905     }
 906   }
 907
 908   jresult = (void *)result;
 909   return jresult;
 910 }
 911
 912
 913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
 914   void * jresult ;
 915   Dali::Application *arg1 = (Dali::Application *) 0 ;
 916   Dali::Application::AppSignalType *result = 0 ;
 917
 918   arg1 = (Dali::Application *)jarg1;
 919   {
 920     try {
 921       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
 922     } catch (std::out_of_range& e) {
 923       {
 924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 925       };
 926     } catch (std::exception& e) {
 927       {
 928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 929       };
 930     } catch (Dali::DaliException e) {
 931       {
 932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 933       };
 934     } catch (...) {
 935       {
 936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 937       };
 938     }
 939   }
 940
 941   jresult = (void *)result;
 942   return jresult;
 943 }
 944
 945
 946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
 947   void * jresult ;
 948   Dali::Application *arg1 = (Dali::Application *) 0 ;
 949   Dali::Application::AppSignalType *result = 0 ;
 950
 951   arg1 = (Dali::Application *)jarg1;
 952   {
 953     try {
 954       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
 955     } catch (std::out_of_range& e) {
 956       {
 957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 958       };
 959     } catch (std::exception& e) {
 960       {
 961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 962       };
 963     } catch (Dali::DaliException e) {
 964       {
 965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 966       };
 967     } catch (...) {
 968       {
 969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 970       };
 971     }
 972   }
 973
 974   jresult = (void *)result;
 975   return jresult;
 976 }
 977
 978
 979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
 980   void * jresult ;
 981   Dali::Application *arg1 = (Dali::Application *) 0 ;
 982   Dali::Application::AppSignalType *result = 0 ;
 983
 984   arg1 = (Dali::Application *)jarg1;
 985   {
 986     try {
 987       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
 988     } catch (std::out_of_range& e) {
 989       {
 990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 991       };
 992     } catch (std::exception& e) {
 993       {
 994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 995       };
 996     } catch (Dali::DaliException e) {
 997       {
 998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 999       };
1000     } catch (...) {
1001       {
1002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1003       };
1004     }
1005   }
1006
1007   jresult = (void *)result;
1008   return jresult;
1009 }
1010
1011
1012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
1013   void * jresult ;
1014   Dali::Application *arg1 = (Dali::Application *) 0 ;
1015   Dali::Application::AppSignalType *result = 0 ;
1016
1017   arg1 = (Dali::Application *)jarg1;
1018   {
1019     try {
1020       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
1021     } catch (std::out_of_range& e) {
1022       {
1023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1024       };
1025     } catch (std::exception& e) {
1026       {
1027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1028       };
1029     } catch (Dali::DaliException e) {
1030       {
1031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1032       };
1033     } catch (...) {
1034       {
1035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1036       };
1037     }
1038   }
1039
1040   jresult = (void *)result;
1041   return jresult;
1042 }
1043
1044
1045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
1046   void * jresult ;
1047   Dali::Application *arg1 = (Dali::Application *) 0 ;
1048   Dali::Application::AppControlSignalType *result = 0 ;
1049
1050   arg1 = (Dali::Application *)jarg1;
1051   {
1052     try {
1053       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
1054     } catch (std::out_of_range& e) {
1055       {
1056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1057       };
1058     } catch (std::exception& e) {
1059       {
1060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1061       };
1062     } catch (Dali::DaliException e) {
1063       {
1064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1065       };
1066     } catch (...) {
1067       {
1068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1069       };
1070     }
1071   }
1072
1073   jresult = (void *)result;
1074   return jresult;
1075 }
1076
1077
1078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
1079   void * jresult ;
1080   Dali::Application *arg1 = (Dali::Application *) 0 ;
1081   Dali::Application::AppSignalType *result = 0 ;
1082
1083   arg1 = (Dali::Application *)jarg1;
1084   {
1085     try {
1086       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
1087     } catch (std::out_of_range& e) {
1088       {
1089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1090       };
1091     } catch (std::exception& e) {
1092       {
1093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1094       };
1095     } catch (Dali::DaliException e) {
1096       {
1097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1098       };
1099     } catch (...) {
1100       {
1101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1102       };
1103     }
1104   }
1105
1106   jresult = (void *)result;
1107   return jresult;
1108 }
1109
1110
1111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
1112   void * jresult ;
1113   Dali::Application *arg1 = (Dali::Application *) 0 ;
1114   Dali::Application::AppSignalType *result = 0 ;
1115
1116   arg1 = (Dali::Application *)jarg1;
1117   {
1118     try {
1119       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
1120     } catch (std::out_of_range& e) {
1121       {
1122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1123       };
1124     } catch (std::exception& e) {
1125       {
1126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1127       };
1128     } catch (Dali::DaliException e) {
1129       {
1130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1131       };
1132     } catch (...) {
1133       {
1134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1135       };
1136     }
1137   }
1138
1139   jresult = (void *)result;
1140   return jresult;
1141 }
1142
1143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LowBatterySignal(void * jarg1) {
1144   void * jresult ;
1145   Dali::Application *arg1 = (Dali::Application *) 0 ;
1146   Dali::Application::LowBatterySignalType *result = 0 ;
1147
1148   arg1 = (Dali::Application *)jarg1;
1149   {
1150     try {
1151       result = (Dali::Application::LowBatterySignalType *) &(arg1)->LowBatterySignal();
1152     } catch (std::out_of_range& e) {
1153       {
1154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1155       };
1156     } catch (std::exception& e) {
1157       {
1158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1159       };
1160     } catch (Dali::DaliException e) {
1161       {
1162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1163       };
1164     } catch (...) {
1165       {
1166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1167       };
1168     }
1169   }
1170
1171   jresult = (void *)result;
1172   return jresult;
1173 }
1174
1175
1176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LowMemorySignal(void * jarg1) {
1177   void * jresult ;
1178   Dali::Application *arg1 = (Dali::Application *) 0 ;
1179   Dali::Application::LowMemorySignalType *result = 0 ;
1180
1181   arg1 = (Dali::Application *)jarg1;
1182   {
1183     try {
1184       result = (Dali::Application::LowMemorySignalType *) &(arg1)->LowMemorySignal();
1185     } catch (std::out_of_range& e) {
1186       {
1187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1188       };
1189     } catch (std::exception& e) {
1190       {
1191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1192       };
1193     } catch (Dali::DaliException e) {
1194       {
1195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1196       };
1197     } catch (...) {
1198       {
1199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1200       };
1201     }
1202   }
1203   jresult = (void *)result;
1204   return jresult;
1205 }
1206
1207
1208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Empty(void * jarg1) {
1209   unsigned int jresult ;
1210   Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
1211   bool result;
1212
1213   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
1214   {
1215     try {
1216       result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Empty((Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > const *)arg1);
1217     } catch (std::out_of_range& e) {
1218       {
1219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1220       };
1221     } catch (std::exception& e) {
1222       {
1223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1224       };
1225     } catch (Dali::DaliException e) {
1226       {
1227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1228       };
1229     } catch (...) {
1230       {
1231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1232       };
1233     }
1234   }
1235
1236   jresult = result;
1237   return jresult;
1238 }
1239
1240
1241 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_GetConnectionCount(void * jarg1) {
1242   unsigned long jresult ;
1243   Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
1244   std::size_t result;
1245
1246   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
1247   {
1248     try {
1249       result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > const *)arg1);
1250     } catch (std::out_of_range& e) {
1251       {
1252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1253       };
1254     } catch (std::exception& e) {
1255       {
1256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1257       };
1258     } catch (Dali::DaliException e) {
1259       {
1260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1261       };
1262     } catch (...) {
1263       {
1264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1265       };
1266     }
1267   }
1268   jresult = (unsigned long)result;
1269   return jresult;
1270 }
1271
1272
1273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Connect(void * jarg1, void * jarg2) {
1274   Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
1275   void (*arg2)(Dali::DeviceStatus::Battery::Status) = (void (*)(Dali::DeviceStatus::Battery::Status)) 0 ;
1276
1277   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
1278   arg2 = (void (*)(Dali::DeviceStatus::Battery::Status))jarg2;
1279   {
1280     try {
1281       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Connect(arg1,arg2);
1282     } catch (std::out_of_range& e) {
1283       {
1284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1285       };
1286     } catch (std::exception& e) {
1287       {
1288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1289       };
1290     } catch (Dali::DaliException e) {
1291       {
1292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1293       };
1294     } catch (...) {
1295       {
1296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1297       };
1298     }
1299   }
1300 }
1301
1302
1303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Disconnect(void * jarg1, void * jarg2) {
1304   Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
1305   void (*arg2)(Dali::DeviceStatus::Battery::Status) = (void (*)(Dali::DeviceStatus::Battery::Status)) 0 ;
1306
1307   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
1308   arg2 = (void (*)(Dali::DeviceStatus::Battery::Status))jarg2;
1309   {
1310     try {
1311       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Disconnect(arg1,arg2);
1312     } catch (std::out_of_range& e) {
1313       {
1314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1315       };
1316     } catch (std::exception& e) {
1317       {
1318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1319       };
1320     } catch (Dali::DaliException e) {
1321       {
1322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1323       };
1324     } catch (...) {
1325       {
1326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1327       };
1328     }
1329   }
1330 }
1331
1332
1333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Emit(void * jarg1, void * jarg2) {
1334   Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
1335   Dali::DeviceStatus::Battery::Status arg2 ;
1336   Dali::DeviceStatus::Battery::Status *argp2 ;
1337
1338   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
1339   argp2 = (Dali::DeviceStatus::Battery::Status *)jarg2;
1340   if (!argp2) {
1341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Battery::Status", 0);
1342     return ;
1343   }
1344   arg2 = *argp2;
1345   {
1346     try {
1347       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Emit(arg1,arg2);
1348     } catch (std::out_of_range& e) {
1349       {
1350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1351       };
1352     } catch (std::exception& e) {
1353       {
1354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1355       };
1356     } catch (Dali::DaliException e) {
1357       {
1358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1359       };
1360     } catch (...) {
1361       {
1362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1363       };
1364     }
1365   }
1366 }
1367
1368
1369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_new_LowBatterySignalType() {
1370   void * jresult ;
1371   Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *result = 0 ;
1372
1373   {
1374     try {
1375       result = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)new Dali::Signal< void (Dali::DeviceStatus::Battery::Status) >();
1376     } catch (std::out_of_range& e) {
1377       {
1378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1379       };
1380     } catch (std::exception& e) {
1381       {
1382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1383       };
1384     } catch (Dali::DaliException e) {
1385       {
1386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1387       };
1388     } catch (...) {
1389       {
1390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1391       };
1392     }
1393   }
1394
1395   jresult = (void *)result;
1396   return jresult;
1397 }
1398
1399
1400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_LowBatterySignalType(void * jarg1) {
1401   Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
1402
1403   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
1404   {
1405     try {
1406       delete arg1;
1407     } catch (std::out_of_range& e) {
1408       {
1409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1410       };
1411     } catch (std::exception& e) {
1412       {
1413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1414       };
1415     } catch (Dali::DaliException e) {
1416       {
1417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1418       };
1419     } catch (...) {
1420       {
1421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1422       };
1423     }
1424   }
1425 }
1426
1427
1428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Empty(void * jarg1) {
1429   unsigned int jresult ;
1430   Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
1431   bool result;
1432
1433   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
1434   {
1435     try {
1436       result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Empty((Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > const *)arg1);
1437     } catch (std::out_of_range& e) {
1438       {
1439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1440       };
1441     } catch (std::exception& e) {
1442       {
1443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1444       };
1445     } catch (Dali::DaliException e) {
1446       {
1447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1448       };
1449     } catch (...) {
1450       {
1451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1452       };
1453     }
1454   }
1455   jresult = result;
1456   return jresult;
1457 }
1458
1459
1460 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_GetConnectionCount(void * jarg1) {
1461   unsigned long jresult ;
1462   Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
1463   std::size_t result;
1464
1465   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
1466   {
1467     try {
1468       result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > const *)arg1);
1469     } catch (std::out_of_range& e) {
1470       {
1471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1472       };
1473     } catch (std::exception& e) {
1474       {
1475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1476       };
1477     } catch (Dali::DaliException e) {
1478       {
1479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1480       };
1481     } catch (...) {
1482       {
1483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1484       };
1485     }
1486   }
1487   jresult = (unsigned long)result;
1488   return jresult;
1489 }
1490
1491
1492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Connect(void * jarg1, void * jarg2) {
1493   Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
1494   void (*arg2)(Dali::DeviceStatus::Memory::Status) = (void (*)(Dali::DeviceStatus::Memory::Status)) 0 ;
1495
1496   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
1497   arg2 = (void (*)(Dali::DeviceStatus::Memory::Status))jarg2;
1498   {
1499     try {
1500       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Connect(arg1,arg2);
1501     } catch (std::out_of_range& e) {
1502       {
1503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1504       };
1505     } catch (std::exception& e) {
1506       {
1507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1508       };
1509     } catch (Dali::DaliException e) {
1510       {
1511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1512       };
1513     } catch (...) {
1514       {
1515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1516       };
1517     }
1518   }
1519 }
1520
1521
1522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Disconnect(void * jarg1, void * jarg2) {
1523   Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
1524   void (*arg2)(Dali::DeviceStatus::Memory::Status) = (void (*)(Dali::DeviceStatus::Memory::Status)) 0 ;
1525
1526   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
1527   arg2 = (void (*)(Dali::DeviceStatus::Memory::Status))jarg2;
1528   {
1529     try {
1530       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Disconnect(arg1,arg2);
1531     } catch (std::out_of_range& e) {
1532       {
1533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1534       };
1535     } catch (std::exception& e) {
1536       {
1537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1538       };
1539     } catch (Dali::DaliException e) {
1540       {
1541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1542       };
1543     } catch (...) {
1544       {
1545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1546       };
1547     }
1548   }
1549 }
1550
1551
1552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Emit(void * jarg1, void * jarg2) {
1553   Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
1554   Dali::DeviceStatus::Memory::Status arg2 ;
1555   Dali::DeviceStatus::Memory::Status *argp2 ;
1556
1557   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
1558   argp2 = (Dali::DeviceStatus::Memory::Status *)jarg2;
1559   if (!argp2) {
1560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Memory::Status", 0);
1561     return ;
1562   }
1563   arg2 = *argp2;
1564   {
1565     try {
1566       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Emit(arg1,arg2);
1567     } catch (std::out_of_range& e) {
1568       {
1569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1570       };
1571     } catch (std::exception& e) {
1572       {
1573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1574       };
1575     } catch (Dali::DaliException e) {
1576       {
1577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1578       };
1579     } catch (...) {
1580       {
1581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1582       };
1583     }
1584   }
1585 }
1586
1587
1588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_new_LowMemorySignalType() {
1589   void * jresult ;
1590   Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *result = 0 ;
1591
1592   {
1593     try {
1594       result = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)new Dali::Signal< void (Dali::DeviceStatus::Memory::Status) >();
1595     } catch (std::out_of_range& e) {
1596       {
1597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1598       };
1599     } catch (std::exception& e) {
1600       {
1601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1602       };
1603     } catch (Dali::DaliException e) {
1604       {
1605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1606       };
1607     } catch (...) {
1608       {
1609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1610       };
1611     }
1612   }
1613   jresult = (void *)result;
1614   return jresult;
1615 }
1616
1617
1618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_LowMemorySignalType(void * jarg1) {
1619   Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
1620
1621   arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
1622   {
1623     try {
1624       delete arg1;
1625     } catch (std::out_of_range& e) {
1626       {
1627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1628       };
1629     } catch (std::exception& e) {
1630       {
1631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1632       };
1633     } catch (Dali::DaliException e) {
1634       {
1635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1636       };
1637     } catch (...) {
1638       {
1639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1640       };
1641     }
1642   }
1643 }
1644
1645
1646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
1647   unsigned int jresult ;
1648   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1649   bool result;
1650
1651   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1652   {
1653     try {
1654       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
1655     } catch (std::out_of_range& e) {
1656       {
1657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1658       };
1659     } catch (std::exception& e) {
1660       {
1661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1662       };
1663     } catch (Dali::DaliException e) {
1664       {
1665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1666       };
1667     } catch (...) {
1668       {
1669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1670       };
1671     }
1672   }
1673
1674   jresult = result;
1675   return jresult;
1676 }
1677
1678
1679 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
1680   unsigned long jresult ;
1681   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1682   std::size_t result;
1683
1684   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1685   {
1686     try {
1687       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
1688     } catch (std::out_of_range& e) {
1689       {
1690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1691       };
1692     } catch (std::exception& e) {
1693       {
1694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1695       };
1696     } catch (Dali::DaliException e) {
1697       {
1698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1699       };
1700     } catch (...) {
1701       {
1702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1703       };
1704     }
1705   }
1706
1707   jresult = (unsigned long)result;
1708   return jresult;
1709 }
1710
1711
1712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
1713   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1714   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
1715
1716   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1717   arg2 = (void (*)(Dali::Application &))jarg2;
1718   {
1719     try {
1720       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
1721     } catch (std::out_of_range& e) {
1722       {
1723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1724       };
1725     } catch (std::exception& e) {
1726       {
1727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1728       };
1729     } catch (Dali::DaliException e) {
1730       {
1731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1732       };
1733     } catch (...) {
1734       {
1735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1736       };
1737     }
1738   }
1739
1740 }
1741
1742
1743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
1744   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1745   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
1746
1747   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1748   arg2 = (void (*)(Dali::Application &))jarg2;
1749   {
1750     try {
1751       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
1752     } catch (std::out_of_range& e) {
1753       {
1754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1755       };
1756     } catch (std::exception& e) {
1757       {
1758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1759       };
1760     } catch (Dali::DaliException e) {
1761       {
1762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1763       };
1764     } catch (...) {
1765       {
1766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1767       };
1768     }
1769   }
1770
1771 }
1772
1773
1774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
1775   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1776   Dali::Application *arg2 = 0 ;
1777
1778   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1779   arg2 = (Dali::Application *)jarg2;
1780   if (!arg2) {
1781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
1782     return ;
1783   }
1784   {
1785     try {
1786       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
1787     } catch (std::out_of_range& e) {
1788       {
1789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1790       };
1791     } catch (std::exception& e) {
1792       {
1793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1794       };
1795     } catch (Dali::DaliException e) {
1796       {
1797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1798       };
1799     } catch (...) {
1800       {
1801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1802       };
1803     }
1804   }
1805
1806 }
1807
1808
1809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
1810   void * jresult ;
1811   Dali::Signal< void (Dali::Application &) > *result = 0 ;
1812
1813   {
1814     try {
1815       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
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 = (void *)result;
1836   return jresult;
1837 }
1838
1839
1840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
1841   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1842
1843   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1844   {
1845     try {
1846       delete arg1;
1847     } catch (std::out_of_range& e) {
1848       {
1849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1850       };
1851     } catch (std::exception& e) {
1852       {
1853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1854       };
1855     } catch (Dali::DaliException e) {
1856       {
1857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1858       };
1859     } catch (...) {
1860       {
1861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1862       };
1863     }
1864   }
1865
1866 }
1867
1868
1869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
1870   unsigned int jresult ;
1871   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
1872   bool result;
1873
1874   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
1875   {
1876     try {
1877       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
1878     } catch (std::out_of_range& e) {
1879       {
1880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1881       };
1882     } catch (std::exception& e) {
1883       {
1884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1885       };
1886     } catch (Dali::DaliException e) {
1887       {
1888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1889       };
1890     } catch (...) {
1891       {
1892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1893       };
1894     }
1895   }
1896
1897   jresult = result;
1898   return jresult;
1899 }
1900
1901
1902 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
1903   unsigned long jresult ;
1904   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
1905   std::size_t result;
1906
1907   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
1908   {
1909     try {
1910       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
1911     } catch (std::out_of_range& e) {
1912       {
1913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1914       };
1915     } catch (std::exception& e) {
1916       {
1917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1918       };
1919     } catch (Dali::DaliException e) {
1920       {
1921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1922       };
1923     } catch (...) {
1924       {
1925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1926       };
1927     }
1928   }
1929
1930   jresult = (unsigned long)result;
1931   return jresult;
1932 }
1933
1934
1935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
1936   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
1937   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
1938
1939   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
1940   arg2 = (void (*)(Dali::Application &,void *))jarg2;
1941   {
1942     try {
1943       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
1944     } catch (std::out_of_range& e) {
1945       {
1946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1947       };
1948     } catch (std::exception& e) {
1949       {
1950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1951       };
1952     } catch (Dali::DaliException e) {
1953       {
1954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1955       };
1956     } catch (...) {
1957       {
1958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1959       };
1960     }
1961   }
1962
1963 }
1964
1965
1966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
1967   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
1968   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
1969
1970   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
1971   arg2 = (void (*)(Dali::Application &,void *))jarg2;
1972   {
1973     try {
1974       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
1998   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
1999   Dali::Application *arg2 = 0 ;
2000   void *arg3 = (void *) 0 ;
2001
2002   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
2003   arg2 = (Dali::Application *)jarg2;
2004   if (!arg2) {
2005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
2006     return ;
2007   }
2008   arg3 = jarg3;
2009   {
2010     try {
2011       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
2012     } catch (std::out_of_range& e) {
2013       {
2014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2015       };
2016     } catch (std::exception& e) {
2017       {
2018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2019       };
2020     } catch (Dali::DaliException e) {
2021       {
2022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2023       };
2024     } catch (...) {
2025       {
2026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2027       };
2028     }
2029   }
2030
2031 }
2032
2033
2034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
2035   void * jresult ;
2036   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
2037
2038   {
2039     try {
2040       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
2041     } catch (std::out_of_range& e) {
2042       {
2043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2044       };
2045     } catch (std::exception& e) {
2046       {
2047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2048       };
2049     } catch (Dali::DaliException e) {
2050       {
2051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2052       };
2053     } catch (...) {
2054       {
2055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2056       };
2057     }
2058   }
2059
2060   jresult = (void *)result;
2061   return jresult;
2062 }
2063
2064
2065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
2066   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
2067
2068   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
2069   {
2070     try {
2071       delete arg1;
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 /*application-devel binding*/
2095
2096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_4(int jarg1, char * jarg3, int jarg4, void * jarg5) {
2097   void * jresult ;
2098   int *arg1 = (int *) 0 ;
2099   char ***arg2 ;
2100   std::string *arg3 = 0 ;
2101   Dali::Application::WINDOW_MODE arg4 ;
2102   Dali::PositionSize arg5 ;
2103   Dali::PositionSize *argp5 ;
2104   Dali::Application result;
2105
2106   {
2107     // Todo generate argv data from the C# args
2108     char **array;         // two dimensional array
2109     int numStrings = 1;     // number of strings
2110     int stringLength = 30;      // max string length.
2111     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
2112     if(!array) {
2113       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "array is null", 0);
2114       return 0;
2115     }
2116     argV = array;
2117
2118     // allocate the string data
2119     for( int i=0; i < numStrings; i++)
2120     {
2121       array[i]=(char *)malloc( stringLength * sizeof(char) );
2122     }
2123     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
2124
2125     std::string temp = "dali-csharp-app";
2126
2127     if(!array[0]) {
2128       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "array[0] is null", 0);
2129       return 0;
2130     }
2131     array[0][temp.copy(array[0], strlen(array[0])-1)] = '\0';
2132
2133     arg1 = &argC;
2134     arg2 = &argV;
2135   }
2136   if (!jarg3) {
2137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
2138     return 0;
2139   }
2140   std::string arg3_str(jarg3);
2141   arg3 = &arg3_str;
2142   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
2143   argp5 = (Dali::PositionSize *)jarg5;
2144   if (!argp5) {
2145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
2146     return 0;
2147   }
2148   arg5 = *argp5;
2149   {
2150     try {
2151       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4,arg5);
2152     } catch (std::out_of_range& e) {
2153       {
2154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2155       };
2156     } catch (std::exception& e) {
2157       {
2158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2159       };
2160     } catch (Dali::DaliException e) {
2161       {
2162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2163       };
2164     } catch (...) {
2165       {
2166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2167       };
2168     }
2169   }
2170
2171   jresult = new Dali::Application((const Dali::Application &)result);
2172
2173   return jresult;
2174 }
2175
2176
2177
2178 #ifdef __cplusplus
2179 }
2180 #endif
2181