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