dali-csharp-binder/src/application.cpp

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