dali-csharp-binder/src/application.cpp

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