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 <dali/public-api/adaptor-framework/application.h>
  23 #include <dali/devel-api/adaptor-framework/application-devel.h>
  24
  25 /* Callback for returning strings to C# without leaking memory */
  26 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
  27 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
  28
  29
  30 // keep argcs and argv so they're always available to DALi
  31 int argC = 1;
  32 char **argV = NULL;
  33
  34 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
  35   return self->Empty();
  36 }
  37 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
  38 return self->GetConnectionCount();
  39 }
  40 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
  41   self->Connect( func );
  42 }
  43 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
  44   self->Disconnect( func );
  45 }
  46 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
  47   self->Emit( arg );
  48 }
  49
  50 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
  51   return self->Empty();
  52 }
  53 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){
  54 return self->GetConnectionCount();
  55 }
  56 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 *)){
  57 self->Connect( func );
  58 }
  59 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 *)){
  60 self->Disconnect( func );
  61 }
  62 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){
  63 self->Emit( arg1, arg2 );
  64 }
  65
  66 #ifdef __cplusplus
  67 extern "C" {
  68 #endif
  69
  70 /*Application binding*/
  71 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
  72   return (Dali::BaseHandle *)jarg1;
  73 }
  74
  75 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
  76   void * jresult ;
  77   Dali::Application result;
  78
  79   {
  80     try {
  81       result = Dali::Application::New();
  82     } catch (std::out_of_range& e) {
  83       {
  84         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
  85       };
  86     } catch (std::exception& e) {
  87       {
  88         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
  89       };
  90     } catch (...) {
  91       {
  92         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
  93       };
  94     }
  95   }
  96   jresult = new Dali::Application((const Dali::Application &)result);
  97   return jresult;
  98 }
  99
 100
 101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
 102   void * jresult ;
 103   int *arg1 = (int *) 0 ;
 104   char ***arg2 ;
 105   Dali::Application result;
 106
 107   {
 108     // Todo generate argv data from the C# args
 109     char **array;         // two dimensional array
 110     int numStrings = 1;     // number of strings
 111     int stringLength = 30;      // max string length.
 112     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
 113     argV = array;
 114
 115     // allocate the string data
 116     for( int i=0; i < numStrings; i++)
 117     {
 118       array[i]=(char *)malloc( stringLength * sizeof(char *) );
 119     }
 120     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
 121
 122     strcpy( array[0], "dali-csharp-app");
 123
 124     arg1 = &argC;
 125     arg2 = &argV;
 126   }
 127   {
 128     try {
 129       result = Dali::Application::New(arg1,arg2);
 130     } catch (std::out_of_range& e) {
 131       {
 132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 133       };
 134     } catch (std::exception& e) {
 135       {
 136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 137       };
 138     } catch (...) {
 139       {
 140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 141       };
 142     }
 143   }
 144   jresult = new Dali::Application((const Dali::Application &)result);
 145   return jresult;
 146 }
 147
 148
 149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
 150   void * jresult ;
 151   int *arg1 = (int *) 0 ;
 152   char ***arg2 ;
 153   std::string *arg3 = 0 ;
 154   Dali::Application result;
 155
 156   {
 157     // Todo generate argv data from the C# args
 158     char **array;         // two dimensional array
 159     int numStrings = 1;     // number of strings
 160     int stringLength = 30;      // max string length.
 161     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
 162     argV = array;
 163
 164     // allocate the string data
 165     for( int i=0; i < numStrings; i++)
 166     {
 167       array[i]=(char *)malloc( stringLength * sizeof(char *) );
 168     }
 169     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
 170
 171     strcpy( array[0], "dali-csharp-app");
 172
 173     arg1 = &argC;
 174     arg2 = &argV;
 175   }
 176   if (!jarg3) {
 177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 178     return 0;
 179   }
 180   std::string arg3_str(jarg3);
 181   arg3 = &arg3_str;
 182   {
 183     try {
 184       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
 185     } catch (std::out_of_range& e) {
 186       {
 187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 188       };
 189     } catch (std::exception& e) {
 190       {
 191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 192       };
 193     } catch (...) {
 194       {
 195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 196       };
 197     }
 198   }
 199   jresult = new Dali::Application((const Dali::Application &)result);
 200
 201   //argout typemap for const std::string&
 202
 203   return jresult;
 204 }
 205
 206
 207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
 208   void * jresult ;
 209   int *arg1 = (int *) 0 ;
 210   char ***arg2 ;
 211   std::string *arg3 = 0 ;
 212   Dali::Application::WINDOW_MODE arg4 ;
 213   Dali::Application result;
 214
 215   {
 216     // Todo generate argv data from the C# args
 217     char **array;         // two dimensional array
 218     int numStrings = 1;     // number of strings
 219     int stringLength = 30;      // max string length.
 220     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
 221     argV = array;
 222
 223     // allocate the string data
 224     for( int i=0; i < numStrings; i++)
 225     {
 226       array[i]=(char *)malloc( stringLength * sizeof(char *) );
 227     }
 228     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
 229
 230     strcpy( array[0], "dali-csharp-app");
 231
 232     arg1 = &argC;
 233     arg2 = &argV;
 234   }
 235   if (!jarg3) {
 236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 237     return 0;
 238   }
 239   std::string arg3_str(jarg3);
 240   arg3 = &arg3_str;
 241   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
 242   {
 243     try {
 244       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
 245     } catch (std::out_of_range& e) {
 246       {
 247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 248       };
 249     } catch (std::exception& e) {
 250       {
 251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 252       };
 253     } catch (...) {
 254       {
 255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 256       };
 257     }
 258   }
 259   jresult = new Dali::Application((const Dali::Application &)result);
 260
 261   //argout typemap for const std::string&
 262
 263   return jresult;
 264 }
 265
 266
 267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
 268   void * jresult ;
 269   Dali::Application *result = 0 ;
 270
 271   {
 272     try {
 273       result = (Dali::Application *)new Dali::Application();
 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 (...) {
 283       {
 284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 285       };
 286     }
 287   }
 288   jresult = (void *)result;
 289   return jresult;
 290 }
 291
 292
 293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
 294   void * jresult ;
 295   Dali::Application *arg1 = 0 ;
 296   Dali::Application *result = 0 ;
 297
 298   arg1 = (Dali::Application *)jarg1;
 299   if (!arg1) {
 300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
 301     return 0;
 302   }
 303   {
 304     try {
 305       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
 306     } catch (std::out_of_range& e) {
 307       {
 308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 309       };
 310     } catch (std::exception& e) {
 311       {
 312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 313       };
 314     } catch (...) {
 315       {
 316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 317       };
 318     }
 319   }
 320   jresult = (void *)result;
 321   return jresult;
 322 }
 323
 324
 325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
 326   void * jresult ;
 327   Dali::Application *arg1 = (Dali::Application *) 0 ;
 328   Dali::Application *arg2 = 0 ;
 329   Dali::Application *result = 0 ;
 330
 331   arg1 = (Dali::Application *)jarg1;
 332   arg2 = (Dali::Application *)jarg2;
 333   if (!arg2) {
 334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
 335     return 0;
 336   }
 337   {
 338     try {
 339       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
 340     } catch (std::out_of_range& e) {
 341       {
 342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 343       };
 344     } catch (std::exception& e) {
 345       {
 346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 347       };
 348     } catch (...) {
 349       {
 350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 351       };
 352     }
 353   }
 354   jresult = (void *)result;
 355   return jresult;
 356 }
 357
 358
 359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
 360   Dali::Application *arg1 = (Dali::Application *) 0 ;
 361
 362   arg1 = (Dali::Application *)jarg1;
 363   {
 364     try {
 365       delete arg1;
 366     } catch (std::out_of_range& e) {
 367       {
 368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 369       };
 370     } catch (std::exception& e) {
 371       {
 372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 373       };
 374     } catch (...) {
 375       {
 376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 377       };
 378     }
 379   }
 380 }
 381
 382
 383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
 384   Dali::Application *arg1 = (Dali::Application *) 0 ;
 385
 386   arg1 = (Dali::Application *)jarg1;
 387   {
 388     try {
 389       (arg1)->MainLoop();
 390     } catch (std::out_of_range& e) {
 391       {
 392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 393       };
 394     } catch (std::exception& e) {
 395       {
 396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 397       };
 398     } catch (...) {
 399       {
 400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 401       };
 402     }
 403   }
 404 }
 405
 406
 407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
 408   Dali::Application *arg1 = (Dali::Application *) 0 ;
 409   Dali::Configuration::ContextLoss arg2 ;
 410   Dali::Configuration::ContextLoss *argp2 ;
 411
 412   arg1 = (Dali::Application *)jarg1;
 413   argp2 = (Dali::Configuration::ContextLoss *)jarg2;
 414   if (!argp2) {
 415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
 416     return ;
 417   }
 418   arg2 = *argp2;
 419   {
 420     try {
 421       (arg1)->MainLoop(arg2);
 422     } catch (std::out_of_range& e) {
 423       {
 424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 425       };
 426     } catch (std::exception& e) {
 427       {
 428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 429       };
 430     } catch (...) {
 431       {
 432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 433       };
 434     }
 435   }
 436 }
 437
 438
 439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
 440   Dali::Application *arg1 = (Dali::Application *) 0 ;
 441
 442   arg1 = (Dali::Application *)jarg1;
 443   {
 444     try {
 445       (arg1)->Lower();
 446     } catch (std::out_of_range& e) {
 447       {
 448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 449       };
 450     } catch (std::exception& e) {
 451       {
 452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 453       };
 454     } catch (...) {
 455       {
 456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 457       };
 458     }
 459   }
 460 }
 461
 462
 463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
 464   Dali::Application *arg1 = (Dali::Application *) 0 ;
 465
 466   arg1 = (Dali::Application *)jarg1;
 467   {
 468     try {
 469       (arg1)->Quit();
 470     } catch (std::out_of_range& e) {
 471       {
 472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 473       };
 474     } catch (std::exception& e) {
 475       {
 476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 477       };
 478     } catch (...) {
 479       {
 480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 481       };
 482     }
 483   }
 484 }
 485
 486
 487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
 488   unsigned int jresult ;
 489   Dali::Application *arg1 = (Dali::Application *) 0 ;
 490   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
 491   bool result;
 492
 493   arg1 = (Dali::Application *)jarg1;
 494   arg2 = (Dali::CallbackBase *)jarg2;
 495   {
 496     try {
 497       result = (bool)(arg1)->AddIdle(arg2);
 498     } catch (std::out_of_range& e) {
 499       {
 500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 501       };
 502     } catch (std::exception& e) {
 503       {
 504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 505       };
 506     } catch (...) {
 507       {
 508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 509       };
 510     }
 511   }
 512   jresult = result;
 513   return jresult;
 514 }
 515
 516
 517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
 518   void * jresult ;
 519   Dali::Application *arg1 = (Dali::Application *) 0 ;
 520   Dali::Window result;
 521
 522   arg1 = (Dali::Application *)jarg1;
 523   {
 524     try {
 525       result = (arg1)->GetWindow();
 526     } catch (std::out_of_range& e) {
 527       {
 528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 529       };
 530     } catch (std::exception& e) {
 531       {
 532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 533       };
 534     } catch (...) {
 535       {
 536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 537       };
 538     }
 539   }
 540   jresult = new Dali::Window((const Dali::Window &)result);
 541   return jresult;
 542 }
 543
 544
 545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
 546   Dali::Application *arg1 = (Dali::Application *) 0 ;
 547   Dali::PositionSize arg2 ;
 548   std::string *arg3 = 0 ;
 549   Dali::PositionSize *argp2 ;
 550
 551   arg1 = (Dali::Application *)jarg1;
 552   argp2 = (Dali::PositionSize *)jarg2;
 553   if (!argp2) {
 554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
 555     return ;
 556   }
 557   arg2 = *argp2;
 558   if (!jarg3) {
 559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 560     return ;
 561   }
 562   std::string arg3_str(jarg3);
 563   arg3 = &arg3_str;
 564   {
 565     try {
 566       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
 567     } catch (std::out_of_range& e) {
 568       {
 569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 570       };
 571     } catch (std::exception& e) {
 572       {
 573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 574       };
 575     } catch (...) {
 576       {
 577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 578       };
 579     }
 580   }
 581
 582   //argout typemap for const std::string&
 583
 584 }
 585
 586
 587 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
 588   char * jresult ;
 589   std::string result;
 590
 591   {
 592     try {
 593       result = Dali::Application::GetResourcePath();
 594     } catch (std::out_of_range& e) {
 595       {
 596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 597       };
 598     } catch (std::exception& e) {
 599       {
 600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 601       };
 602     } catch (...) {
 603       {
 604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 605       };
 606     }
 607   }
 608   jresult = SWIG_csharp_string_callback((&result)->c_str());
 609   return jresult;
 610 }
 611
 612
 613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
 614   Dali::Application *arg1 = (Dali::Application *) 0 ;
 615   Dali::ViewMode arg2 ;
 616
 617   arg1 = (Dali::Application *)jarg1;
 618   arg2 = (Dali::ViewMode)jarg2;
 619   {
 620     try {
 621       (arg1)->SetViewMode(arg2);
 622     } catch (std::out_of_range& e) {
 623       {
 624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 625       };
 626     } catch (std::exception& e) {
 627       {
 628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 629       };
 630     } catch (...) {
 631       {
 632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 633       };
 634     }
 635   }
 636 }
 637
 638
 639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
 640   int jresult ;
 641   Dali::Application *arg1 = (Dali::Application *) 0 ;
 642   Dali::ViewMode result;
 643
 644   arg1 = (Dali::Application *)jarg1;
 645   {
 646     try {
 647       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
 648     } catch (std::out_of_range& e) {
 649       {
 650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 651       };
 652     } catch (std::exception& e) {
 653       {
 654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 655       };
 656     } catch (...) {
 657       {
 658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 659       };
 660     }
 661   }
 662   jresult = (int)result;
 663   return jresult;
 664 }
 665
 666
 667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
 668   Dali::Application *arg1 = (Dali::Application *) 0 ;
 669   float arg2 ;
 670
 671   arg1 = (Dali::Application *)jarg1;
 672   arg2 = (float)jarg2;
 673   {
 674     try {
 675       (arg1)->SetStereoBase(arg2);
 676     } catch (std::out_of_range& e) {
 677       {
 678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 679       };
 680     } catch (std::exception& e) {
 681       {
 682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 683       };
 684     } catch (...) {
 685       {
 686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 687       };
 688     }
 689   }
 690 }
 691
 692
 693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
 694   float jresult ;
 695   Dali::Application *arg1 = (Dali::Application *) 0 ;
 696   float result;
 697
 698   arg1 = (Dali::Application *)jarg1;
 699   {
 700     try {
 701       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
 702     } catch (std::out_of_range& e) {
 703       {
 704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 705       };
 706     } catch (std::exception& e) {
 707       {
 708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 709       };
 710     } catch (...) {
 711       {
 712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 713       };
 714     }
 715   }
 716   jresult = result;
 717   return jresult;
 718 }
 719
 720
 721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
 722   void * jresult ;
 723   Dali::Application *arg1 = (Dali::Application *) 0 ;
 724   Dali::Application::AppSignalType *result = 0 ;
 725
 726   arg1 = (Dali::Application *)jarg1;
 727   {
 728     try {
 729       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
 730     } catch (std::out_of_range& e) {
 731       {
 732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 733       };
 734     } catch (std::exception& e) {
 735       {
 736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 737       };
 738     } catch (...) {
 739       {
 740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 741       };
 742     }
 743   }
 744   jresult = (void *)result;
 745   return jresult;
 746 }
 747
 748
 749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
 750   void * jresult ;
 751   Dali::Application *arg1 = (Dali::Application *) 0 ;
 752   Dali::Application::AppSignalType *result = 0 ;
 753
 754   arg1 = (Dali::Application *)jarg1;
 755   {
 756     try {
 757       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
 758     } catch (std::out_of_range& e) {
 759       {
 760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 761       };
 762     } catch (std::exception& e) {
 763       {
 764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 765       };
 766     } catch (...) {
 767       {
 768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 769       };
 770     }
 771   }
 772   jresult = (void *)result;
 773   return jresult;
 774 }
 775
 776
 777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
 778   void * jresult ;
 779   Dali::Application *arg1 = (Dali::Application *) 0 ;
 780   Dali::Application::AppSignalType *result = 0 ;
 781
 782   arg1 = (Dali::Application *)jarg1;
 783   {
 784     try {
 785       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
 786     } catch (std::out_of_range& e) {
 787       {
 788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 789       };
 790     } catch (std::exception& e) {
 791       {
 792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 793       };
 794     } catch (...) {
 795       {
 796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 797       };
 798     }
 799   }
 800   jresult = (void *)result;
 801   return jresult;
 802 }
 803
 804
 805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
 806   void * jresult ;
 807   Dali::Application *arg1 = (Dali::Application *) 0 ;
 808   Dali::Application::AppSignalType *result = 0 ;
 809
 810   arg1 = (Dali::Application *)jarg1;
 811   {
 812     try {
 813       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
 814     } catch (std::out_of_range& e) {
 815       {
 816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 817       };
 818     } catch (std::exception& e) {
 819       {
 820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 821       };
 822     } catch (...) {
 823       {
 824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 825       };
 826     }
 827   }
 828   jresult = (void *)result;
 829   return jresult;
 830 }
 831
 832
 833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
 834   void * jresult ;
 835   Dali::Application *arg1 = (Dali::Application *) 0 ;
 836   Dali::Application::AppSignalType *result = 0 ;
 837
 838   arg1 = (Dali::Application *)jarg1;
 839   {
 840     try {
 841       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
 842     } catch (std::out_of_range& e) {
 843       {
 844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 845       };
 846     } catch (std::exception& e) {
 847       {
 848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 849       };
 850     } catch (...) {
 851       {
 852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 853       };
 854     }
 855   }
 856   jresult = (void *)result;
 857   return jresult;
 858 }
 859
 860
 861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
 862   void * jresult ;
 863   Dali::Application *arg1 = (Dali::Application *) 0 ;
 864   Dali::Application::AppSignalType *result = 0 ;
 865
 866   arg1 = (Dali::Application *)jarg1;
 867   {
 868     try {
 869       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
 870     } catch (std::out_of_range& e) {
 871       {
 872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 873       };
 874     } catch (std::exception& e) {
 875       {
 876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 877       };
 878     } catch (...) {
 879       {
 880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 881       };
 882     }
 883   }
 884   jresult = (void *)result;
 885   return jresult;
 886 }
 887
 888
 889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
 890   void * jresult ;
 891   Dali::Application *arg1 = (Dali::Application *) 0 ;
 892   Dali::Application::AppControlSignalType *result = 0 ;
 893
 894   arg1 = (Dali::Application *)jarg1;
 895   {
 896     try {
 897       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
 898     } catch (std::out_of_range& e) {
 899       {
 900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 901       };
 902     } catch (std::exception& e) {
 903       {
 904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 905       };
 906     } catch (...) {
 907       {
 908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 909       };
 910     }
 911   }
 912   jresult = (void *)result;
 913   return jresult;
 914 }
 915
 916
 917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
 918   void * jresult ;
 919   Dali::Application *arg1 = (Dali::Application *) 0 ;
 920   Dali::Application::AppSignalType *result = 0 ;
 921
 922   arg1 = (Dali::Application *)jarg1;
 923   {
 924     try {
 925       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
 926     } catch (std::out_of_range& e) {
 927       {
 928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 929       };
 930     } catch (std::exception& e) {
 931       {
 932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 933       };
 934     } catch (...) {
 935       {
 936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 937       };
 938     }
 939   }
 940   jresult = (void *)result;
 941   return jresult;
 942 }
 943
 944
 945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
 946   void * jresult ;
 947   Dali::Application *arg1 = (Dali::Application *) 0 ;
 948   Dali::Application::AppSignalType *result = 0 ;
 949
 950   arg1 = (Dali::Application *)jarg1;
 951   {
 952     try {
 953       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
 954     } catch (std::out_of_range& e) {
 955       {
 956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 957       };
 958     } catch (std::exception& e) {
 959       {
 960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 961       };
 962     } catch (...) {
 963       {
 964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 965       };
 966     }
 967   }
 968   jresult = (void *)result;
 969   return jresult;
 970 }
 971
 972
 973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
 974   void * jresult ;
 975   Dali::Application *arg1 = (Dali::Application *) 0 ;
 976   Dali::Application::AppSignalType *result = 0 ;
 977
 978   arg1 = (Dali::Application *)jarg1;
 979   {
 980     try {
 981       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
 982     } catch (std::out_of_range& e) {
 983       {
 984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 985       };
 986     } catch (std::exception& e) {
 987       {
 988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 989       };
 990     } catch (...) {
 991       {
 992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 993       };
 994     }
 995   }
 996   jresult = (void *)result;
 997   return jresult;
 998 }
 999
1000
1001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
1002   void * jresult ;
1003   Dali::Application *arg1 = (Dali::Application *) 0 ;
1004   Dali::Application::AppSignalType *result = 0 ;
1005
1006   arg1 = (Dali::Application *)jarg1;
1007   {
1008     try {
1009       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
1010     } catch (std::out_of_range& e) {
1011       {
1012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1013       };
1014     } catch (std::exception& e) {
1015       {
1016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1017       };
1018     } catch (...) {
1019       {
1020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1021       };
1022     }
1023   }
1024   jresult = (void *)result;
1025   return jresult;
1026 }
1027
1028
1029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
1030   unsigned int jresult ;
1031   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1032   bool result;
1033
1034   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1035   {
1036     try {
1037       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
1038     } catch (std::out_of_range& e) {
1039       {
1040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1041       };
1042     } catch (std::exception& e) {
1043       {
1044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1045       };
1046     } catch (...) {
1047       {
1048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1049       };
1050     }
1051   }
1052   jresult = result;
1053   return jresult;
1054 }
1055
1056
1057 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
1058   unsigned long jresult ;
1059   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1060   std::size_t result;
1061
1062   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1063   {
1064     try {
1065       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
1066     } catch (std::out_of_range& e) {
1067       {
1068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1069       };
1070     } catch (std::exception& e) {
1071       {
1072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1073       };
1074     } catch (...) {
1075       {
1076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1077       };
1078     }
1079   }
1080   jresult = (unsigned long)result;
1081   return jresult;
1082 }
1083
1084
1085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
1086   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1087   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
1088
1089   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1090   arg2 = (void (*)(Dali::Application &))jarg2;
1091   {
1092     try {
1093       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
1094     } catch (std::out_of_range& e) {
1095       {
1096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1097       };
1098     } catch (std::exception& e) {
1099       {
1100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1101       };
1102     } catch (...) {
1103       {
1104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1105       };
1106     }
1107   }
1108 }
1109
1110
1111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
1112   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1113   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
1114
1115   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1116   arg2 = (void (*)(Dali::Application &))jarg2;
1117   {
1118     try {
1119       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
1120     } catch (std::out_of_range& e) {
1121       {
1122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1123       };
1124     } catch (std::exception& e) {
1125       {
1126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1127       };
1128     } catch (...) {
1129       {
1130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1131       };
1132     }
1133   }
1134 }
1135
1136
1137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
1138   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1139   Dali::Application *arg2 = 0 ;
1140
1141   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1142   arg2 = (Dali::Application *)jarg2;
1143   if (!arg2) {
1144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
1145     return ;
1146   }
1147   {
1148     try {
1149       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
1150     } catch (std::out_of_range& e) {
1151       {
1152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1153       };
1154     } catch (std::exception& e) {
1155       {
1156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1157       };
1158     } catch (...) {
1159       {
1160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1161       };
1162     }
1163   }
1164 }
1165
1166
1167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
1168   void * jresult ;
1169   Dali::Signal< void (Dali::Application &) > *result = 0 ;
1170
1171   {
1172     try {
1173       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
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 (...) {
1183       {
1184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1185       };
1186     }
1187   }
1188   jresult = (void *)result;
1189   return jresult;
1190 }
1191
1192
1193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
1194   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
1195
1196   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
1197   {
1198     try {
1199       delete arg1;
1200     } catch (std::out_of_range& e) {
1201       {
1202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1203       };
1204     } catch (std::exception& e) {
1205       {
1206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1207       };
1208     } catch (...) {
1209       {
1210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1211       };
1212     }
1213   }
1214 }
1215
1216
1217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
1218   unsigned int jresult ;
1219   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
1220   bool result;
1221
1222   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
1223   {
1224     try {
1225       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
1226     } catch (std::out_of_range& e) {
1227       {
1228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1229       };
1230     } catch (std::exception& e) {
1231       {
1232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1233       };
1234     } catch (...) {
1235       {
1236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1237       };
1238     }
1239   }
1240   jresult = result;
1241   return jresult;
1242 }
1243
1244
1245 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
1246   unsigned long jresult ;
1247   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
1248   std::size_t result;
1249
1250   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
1251   {
1252     try {
1253       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
1254     } catch (std::out_of_range& e) {
1255       {
1256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1257       };
1258     } catch (std::exception& e) {
1259       {
1260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1261       };
1262     } catch (...) {
1263       {
1264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1265       };
1266     }
1267   }
1268   jresult = (unsigned long)result;
1269   return jresult;
1270 }
1271
1272
1273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
1274   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
1275   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
1276
1277   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
1278   arg2 = (void (*)(Dali::Application &,void *))jarg2;
1279   {
1280     try {
1281       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
1282     } catch (std::out_of_range& e) {
1283       {
1284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1285       };
1286     } catch (std::exception& e) {
1287       {
1288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1289       };
1290     } catch (...) {
1291       {
1292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1293       };
1294     }
1295   }
1296 }
1297
1298
1299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
1300   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
1301   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
1302
1303   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
1304   arg2 = (void (*)(Dali::Application &,void *))jarg2;
1305   {
1306     try {
1307       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
1308     } catch (std::out_of_range& e) {
1309       {
1310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1311       };
1312     } catch (std::exception& e) {
1313       {
1314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1315       };
1316     } catch (...) {
1317       {
1318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1319       };
1320     }
1321   }
1322 }
1323
1324
1325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
1326   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
1327   Dali::Application *arg2 = 0 ;
1328   void *arg3 = (void *) 0 ;
1329
1330   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
1331   arg2 = (Dali::Application *)jarg2;
1332   if (!arg2) {
1333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
1334     return ;
1335   }
1336   arg3 = jarg3;
1337   {
1338     try {
1339       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
1340     } catch (std::out_of_range& e) {
1341       {
1342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1343       };
1344     } catch (std::exception& e) {
1345       {
1346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1347       };
1348     } catch (...) {
1349       {
1350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1351       };
1352     }
1353   }
1354 }
1355
1356
1357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
1358   void * jresult ;
1359   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
1360
1361   {
1362     try {
1363       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
1364     } catch (std::out_of_range& e) {
1365       {
1366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1367       };
1368     } catch (std::exception& e) {
1369       {
1370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1371       };
1372     } catch (...) {
1373       {
1374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1375       };
1376     }
1377   }
1378   jresult = (void *)result;
1379   return jresult;
1380 }
1381
1382
1383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
1384   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
1385
1386   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
1387   {
1388     try {
1389       delete arg1;
1390     } catch (std::out_of_range& e) {
1391       {
1392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1393       };
1394     } catch (std::exception& e) {
1395       {
1396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1397       };
1398     } catch (...) {
1399       {
1400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1401       };
1402     }
1403   }
1404 }
1405
1406
1407 /*application-devel binding*/
1408
1409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_4(int jarg1, char * jarg3, int jarg4, void * jarg5) {
1410   void * jresult ;
1411   int *arg1 = (int *) 0 ;
1412   char ***arg2 ;
1413   std::string *arg3 = 0 ;
1414   Dali::Application::WINDOW_MODE arg4 ;
1415   Dali::PositionSize arg5 ;
1416   Dali::PositionSize *argp5 ;
1417   Dali::Application result;
1418
1419   {
1420     // Todo generate argv data from the C# args
1421     char **array;         // two dimensional array
1422     int numStrings = 1;     // number of strings
1423     int stringLength = 30;      // max string length.
1424     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
1425     argV = array;
1426
1427     // allocate the string data
1428     for( int i=0; i < numStrings; i++)
1429     {
1430       array[i]=(char *)malloc( stringLength * sizeof(char *) );
1431     }
1432     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
1433
1434     strcpy( array[0], "dali-csharp-app");
1435
1436     arg1 = &argC;
1437     arg2 = &argV;
1438   }
1439   if (!jarg3) {
1440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1441     return 0;
1442   }
1443   std::string arg3_str(jarg3);
1444   arg3 = &arg3_str;
1445   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
1446   argp5 = (Dali::PositionSize *)jarg5;
1447   if (!argp5) {
1448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
1449     return 0;
1450   }
1451   arg5 = *argp5;
1452   {
1453     try {
1454       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4,arg5);
1455     } catch (std::out_of_range& e) {
1456       {
1457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1458       };
1459     } catch (std::exception& e) {
1460       {
1461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1462       };
1463     } catch (...) {
1464       {
1465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1466       };
1467     }
1468   }
1469   jresult = new Dali::Application((const Dali::Application &)result);
1470
1471   return jresult;
1472 }
1473
1474
1475
1476 #ifdef __cplusplus
1477 }
1478 #endif
1479