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