dali-csharp-binder/src/watch.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_WATCH
  18 #define CSHARP_WATCH
  19 #endif
  20
  21 #include "common.h"
  22 #include <dali/public-api/watch/watch-time.h>
  23 #include <dali/public-api/watch/watch-application.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 argWatchC = 1;
  32 char **argWatchV = NULL;
  33
  34 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > const *self){
  35   return self->Empty();
  36 }
  37 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > const *self){
  38   return self->GetConnectionCount();
  39 }
  40 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *self,void (*func)(Dali::Application &,Dali::WatchTime const &)){
  41   self->Connect( func );
  42 }
  43 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *self,void (*func)(Dali::Application &,Dali::WatchTime const &)){
  44   self->Disconnect( func );
  45 }
  46 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *self,Dali::Application &arg1,Dali::WatchTime const &arg2){
  47   self->Emit( arg1, arg2 );
  48 }
  49
  50 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Application &,bool) > const *self){
  51   return self->Empty();
  52 }
  53 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,bool) > const *self){
  54   return self->GetConnectionCount();
  55 }
  56 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Application &,bool) > *self,void (*func)(Dali::Application &,bool)){
  57   self->Connect( func );
  58 }
  59 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,bool) > *self,void (*func)(Dali::Application &,bool)){
  60   self->Disconnect( func );
  61 }
  62 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Application &,bool) > *self,Dali::Application &arg1,bool arg2){
  63   self->Emit( arg1, arg2 );
  64 }
  65
  66 #ifdef __cplusplus
  67 extern "C" {
  68 #endif
  69
  70 /*watch binding*/
  71
  72 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchTime() {
  73   void * jresult ;
  74   Dali::WatchTime *result = 0 ;
  75
  76   {
  77     try {
  78       result = (Dali::WatchTime *)new Dali::WatchTime();
  79     } catch (std::out_of_range& e) {
  80       {
  81         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
  82       };
  83     } catch (std::exception& e) {
  84       {
  85         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
  86       };
  87     } catch (...) {
  88       {
  89         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
  90       };
  91     }
  92   }
  93   jresult = (void *)result;
  94   return jresult;
  95 }
  96
  97
  98 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchTime(void * jarg1) {
  99   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 100
 101   arg1 = (Dali::WatchTime *)jarg1;
 102   {
 103     try {
 104       delete arg1;
 105     } catch (std::out_of_range& e) {
 106       {
 107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 108       };
 109     } catch (std::exception& e) {
 110       {
 111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 112       };
 113     } catch (...) {
 114       {
 115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 116       };
 117     }
 118   }
 119 }
 120
 121
 122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetHour(void * jarg1) {
 123   int jresult ;
 124   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 125   int result;
 126
 127   arg1 = (Dali::WatchTime *)jarg1;
 128   {
 129     try {
 130       result = (int)((Dali::WatchTime const *)arg1)->GetHour();
 131     } catch (std::out_of_range& e) {
 132       {
 133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 134       };
 135     } catch (std::exception& e) {
 136       {
 137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 138       };
 139     } catch (...) {
 140       {
 141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 142       };
 143     }
 144   }
 145   jresult = result;
 146   return jresult;
 147 }
 148
 149
 150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetHour24(void * jarg1) {
 151   int jresult ;
 152   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 153   int result;
 154
 155   arg1 = (Dali::WatchTime *)jarg1;
 156   {
 157     try {
 158       result = (int)((Dali::WatchTime const *)arg1)->GetHour24();
 159     } catch (std::out_of_range& e) {
 160       {
 161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 162       };
 163     } catch (std::exception& e) {
 164       {
 165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 166       };
 167     } catch (...) {
 168       {
 169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 170       };
 171     }
 172   }
 173   jresult = result;
 174   return jresult;
 175 }
 176
 177
 178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetMinute(void * jarg1) {
 179   int jresult ;
 180   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 181   int result;
 182
 183   arg1 = (Dali::WatchTime *)jarg1;
 184   {
 185     try {
 186       result = (int)((Dali::WatchTime const *)arg1)->GetMinute();
 187     } catch (std::out_of_range& e) {
 188       {
 189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 190       };
 191     } catch (std::exception& e) {
 192       {
 193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 194       };
 195     } catch (...) {
 196       {
 197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 198       };
 199     }
 200   }
 201   jresult = result;
 202   return jresult;
 203 }
 204
 205
 206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetSecond(void * jarg1) {
 207   int jresult ;
 208   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 209   int result;
 210
 211   arg1 = (Dali::WatchTime *)jarg1;
 212   {
 213     try {
 214       result = (int)((Dali::WatchTime const *)arg1)->GetSecond();
 215     } catch (std::out_of_range& e) {
 216       {
 217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 218       };
 219     } catch (std::exception& e) {
 220       {
 221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 222       };
 223     } catch (...) {
 224       {
 225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 226       };
 227     }
 228   }
 229   jresult = result;
 230   return jresult;
 231 }
 232
 233
 234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetMillisecond(void * jarg1) {
 235   int jresult ;
 236   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 237   int result;
 238
 239   arg1 = (Dali::WatchTime *)jarg1;
 240   {
 241     try {
 242       result = (int)((Dali::WatchTime const *)arg1)->GetMillisecond();
 243     } catch (std::out_of_range& e) {
 244       {
 245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 246       };
 247     } catch (std::exception& e) {
 248       {
 249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 250       };
 251     } catch (...) {
 252       {
 253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 254       };
 255     }
 256   }
 257   jresult = result;
 258   return jresult;
 259 }
 260
 261
 262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetYear(void * jarg1) {
 263   int jresult ;
 264   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 265   int result;
 266
 267   arg1 = (Dali::WatchTime *)jarg1;
 268   {
 269     try {
 270       result = (int)((Dali::WatchTime const *)arg1)->GetYear();
 271     } catch (std::out_of_range& e) {
 272       {
 273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 274       };
 275     } catch (std::exception& e) {
 276       {
 277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 278       };
 279     } catch (...) {
 280       {
 281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 282       };
 283     }
 284   }
 285   jresult = result;
 286   return jresult;
 287 }
 288
 289
 290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetMonth(void * jarg1) {
 291   int jresult ;
 292   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 293   int result;
 294
 295   arg1 = (Dali::WatchTime *)jarg1;
 296   {
 297     try {
 298       result = (int)((Dali::WatchTime const *)arg1)->GetMonth();
 299     } catch (std::out_of_range& e) {
 300       {
 301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 302       };
 303     } catch (std::exception& e) {
 304       {
 305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 306       };
 307     } catch (...) {
 308       {
 309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 310       };
 311     }
 312   }
 313   jresult = result;
 314   return jresult;
 315 }
 316
 317
 318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetDay(void * jarg1) {
 319   int jresult ;
 320   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 321   int result;
 322
 323   arg1 = (Dali::WatchTime *)jarg1;
 324   {
 325     try {
 326       result = (int)((Dali::WatchTime const *)arg1)->GetDay();
 327     } catch (std::out_of_range& e) {
 328       {
 329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 330       };
 331     } catch (std::exception& e) {
 332       {
 333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 334       };
 335     } catch (...) {
 336       {
 337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 338       };
 339     }
 340   }
 341   jresult = result;
 342   return jresult;
 343 }
 344
 345
 346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetDayOfWeek(void * jarg1) {
 347   int jresult ;
 348   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 349   int result;
 350
 351   arg1 = (Dali::WatchTime *)jarg1;
 352   {
 353     try {
 354       result = (int)((Dali::WatchTime const *)arg1)->GetDayOfWeek();
 355     } catch (std::out_of_range& e) {
 356       {
 357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 358       };
 359     } catch (std::exception& e) {
 360       {
 361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 362       };
 363     } catch (...) {
 364       {
 365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 366       };
 367     }
 368   }
 369   jresult = result;
 370   return jresult;
 371 }
 372
 373
 374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchTime_GetUtcTime(void * jarg1) {
 375   void * jresult ;
 376   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 377   tm result;
 378
 379   arg1 = (Dali::WatchTime *)jarg1;
 380   {
 381     try {
 382       result = ((Dali::WatchTime const *)arg1)->GetUtcTime();
 383     } catch (std::out_of_range& e) {
 384       {
 385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 386       };
 387     } catch (std::exception& e) {
 388       {
 389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 390       };
 391     } catch (...) {
 392       {
 393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 394       };
 395     }
 396   }
 397   jresult = new tm((const tm &)result);
 398   return jresult;
 399 }
 400
 401
 402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchTime_GetUtcTimeStamp(void * jarg1) {
 403   void * jresult ;
 404   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 405   time_t result;
 406
 407   arg1 = (Dali::WatchTime *)jarg1;
 408   {
 409     try {
 410       result = ((Dali::WatchTime const *)arg1)->GetUtcTimeStamp();
 411     } catch (std::out_of_range& e) {
 412       {
 413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 414       };
 415     } catch (std::exception& e) {
 416       {
 417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 418       };
 419     } catch (...) {
 420       {
 421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 422       };
 423     }
 424   }
 425   jresult = new time_t((const time_t &)result);
 426   return jresult;
 427 }
 428
 429
 430 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_WatchTime_GetTimeZone(void * jarg1) {
 431   char * jresult ;
 432   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 433   char *result = 0 ;
 434
 435   arg1 = (Dali::WatchTime *)jarg1;
 436   {
 437     try {
 438       result = (char *)((Dali::WatchTime const *)arg1)->GetTimeZone();
 439     } catch (std::out_of_range& e) {
 440       {
 441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 442       };
 443     } catch (std::exception& e) {
 444       {
 445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 446       };
 447     } catch (...) {
 448       {
 449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 450       };
 451     }
 452   }
 453   jresult = SWIG_csharp_string_callback((const char *)result);
 454   return jresult;
 455 }
 456
 457
 458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WatchTime_GetDaylightSavingTimeStatus(void * jarg1) {
 459   unsigned int jresult ;
 460   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 461   bool result;
 462
 463   arg1 = (Dali::WatchTime *)jarg1;
 464   {
 465     try {
 466       result = (bool)((Dali::WatchTime const *)arg1)->GetDaylightSavingTimeStatus();
 467     } catch (std::out_of_range& e) {
 468       {
 469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 470       };
 471     } catch (std::exception& e) {
 472       {
 473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 474       };
 475     } catch (...) {
 476       {
 477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 478       };
 479     }
 480   }
 481   jresult = result;
 482   return jresult;
 483 }
 484
 485
 486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_New__SWIG_0() {
 487   void * jresult ;
 488   Dali::WatchApplication result;
 489
 490   {
 491     try {
 492       result = Dali::WatchApplication::New();
 493     } catch (std::out_of_range& e) {
 494       {
 495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 496       };
 497     } catch (std::exception& e) {
 498       {
 499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 500       };
 501     } catch (...) {
 502       {
 503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 504       };
 505     }
 506   }
 507   jresult = new Dali::WatchApplication((const Dali::WatchApplication &)result);
 508   return jresult;
 509 }
 510
 511
 512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_New__SWIG_1(int jarg1, char * jarg2) {
 513   void * jresult ;
 514   int *arg1 = (int *) 0 ;
 515   char ***arg2 ;
 516   Dali::WatchApplication result;
 517   {
 518     int index=0;
 519     char *retPtr;
 520     char *nextPtr;
 521     argWatchC = jarg1;
 522     argWatchV = new char*[jarg1 + 1];
 523
 524     retPtr = strtok_r(jarg2, " ", &nextPtr);
 525     argWatchV[index] = new char[strlen(retPtr) + 1];
 526     strncpy(argWatchV[index], retPtr, strlen(retPtr));
 527     argWatchV[index][strlen(retPtr)] = '\0';
 528     index++;
 529
 530     while( index < jarg1 )
 531     {
 532       retPtr = strtok_r(NULL, " ", &nextPtr);
 533       argWatchV[index] = new char[strlen(retPtr)+1];
 534       strncpy(argWatchV[index], retPtr, strlen(retPtr));
 535       argWatchV[index][strlen(retPtr)] = '\0';
 536       index++;
 537     }
 538   }
 539
 540   argWatchV[jarg1] = NULL;
 541
 542   arg1 = &argWatchC;
 543   arg2 = &argWatchV;
 544   {
 545     try {
 546       result = Dali::WatchApplication::New(arg1,arg2);
 547     } catch (std::out_of_range& e) {
 548       {
 549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 550       };
 551     } catch (std::exception& e) {
 552       {
 553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 554       };
 555     } catch (...) {
 556       {
 557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 558       };
 559     }
 560   }
 561   jresult = new Dali::WatchApplication((const Dali::WatchApplication &)result);
 562   return jresult;
 563 }
 564
 565
 566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_New__SWIG_2(int jarg1, char * jarg2, char * jarg3) {
 567   void * jresult ;
 568   int *arg1 = (int *) 0 ;
 569   char ***arg2 ;
 570   std::string *arg3 = 0 ;
 571   Dali::WatchApplication result;
 572   {
 573     int index=0;
 574     char *retPtr;
 575     char *nextPtr;
 576     argWatchC = jarg1;
 577     argWatchV = new char*[jarg1 + 1];
 578
 579     retPtr = strtok_r(jarg2, " ", &nextPtr);
 580     argWatchV[index] = new char[strlen(retPtr) + 1];
 581     strncpy(argWatchV[index], retPtr, strlen(retPtr));
 582     argWatchV[index][strlen(retPtr)] = '\0';
 583     index++;
 584
 585     while( index < jarg1 )
 586     {
 587       retPtr = strtok_r(NULL, " ", &nextPtr);
 588       argWatchV[index] = new char[strlen(retPtr)+1];
 589       strncpy(argWatchV[index], retPtr, strlen(retPtr));
 590       argWatchV[index][strlen(retPtr)] = '\0';
 591       index++;
 592     }
 593   }
 594
 595   argWatchV[jarg1] = NULL;
 596
 597   arg1 = &argWatchC;
 598   arg2 = &argWatchV;
 599   if (!jarg3) {
 600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 601     return 0;
 602   }
 603   std::string arg3_str(jarg3);
 604   arg3 = &arg3_str;
 605   {
 606     try {
 607       result = Dali::WatchApplication::New(arg1,arg2,(std::string const &)*arg3);
 608     } catch (std::out_of_range& e) {
 609       {
 610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 611       };
 612     } catch (std::exception& e) {
 613       {
 614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 615       };
 616     } catch (...) {
 617       {
 618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 619       };
 620     }
 621   }
 622   jresult = new Dali::WatchApplication((const Dali::WatchApplication &)result);
 623
 624   //argout typemap for const std::string&
 625
 626   return jresult;
 627 }
 628
 629
 630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchApplication__SWIG_0() {
 631   void * jresult ;
 632   Dali::WatchApplication *result = 0 ;
 633
 634   {
 635     try {
 636       result = (Dali::WatchApplication *)new Dali::WatchApplication();
 637     } catch (std::out_of_range& e) {
 638       {
 639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 640       };
 641     } catch (std::exception& e) {
 642       {
 643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 644       };
 645     } catch (...) {
 646       {
 647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 648       };
 649     }
 650   }
 651   jresult = (void *)result;
 652   return jresult;
 653 }
 654
 655
 656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchApplication__SWIG_1(void * jarg1) {
 657   void * jresult ;
 658   Dali::WatchApplication *arg1 = 0 ;
 659   Dali::WatchApplication *result = 0 ;
 660
 661   arg1 = (Dali::WatchApplication *)jarg1;
 662   if (!arg1) {
 663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WatchApplication const & type is null", 0);
 664     return 0;
 665   }
 666   {
 667     try {
 668       result = (Dali::WatchApplication *)new Dali::WatchApplication((Dali::WatchApplication const &)*arg1);
 669     } catch (std::out_of_range& e) {
 670       {
 671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 672       };
 673     } catch (std::exception& e) {
 674       {
 675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 676       };
 677     } catch (...) {
 678       {
 679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 680       };
 681     }
 682   }
 683   jresult = (void *)result;
 684   return jresult;
 685 }
 686
 687
 688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_Assign(void * jarg1, void * jarg2) {
 689   void * jresult ;
 690   Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ;
 691   Dali::WatchApplication *arg2 = 0 ;
 692   Dali::WatchApplication *result = 0 ;
 693
 694   arg1 = (Dali::WatchApplication *)jarg1;
 695   arg2 = (Dali::WatchApplication *)jarg2;
 696   if (!arg2) {
 697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WatchApplication const & type is null", 0);
 698     return 0;
 699   }
 700   {
 701     try {
 702       result = (Dali::WatchApplication *) &(arg1)->operator =((Dali::WatchApplication const &)*arg2);
 703     } catch (std::out_of_range& e) {
 704       {
 705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 706       };
 707     } catch (std::exception& e) {
 708       {
 709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 710       };
 711     } catch (...) {
 712       {
 713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 714       };
 715     }
 716   }
 717   jresult = (void *)result;
 718   return jresult;
 719 }
 720
 721
 722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchApplication(void * jarg1) {
 723   Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ;
 724
 725   arg1 = (Dali::WatchApplication *)jarg1;
 726   {
 727     try {
 728       delete arg1;
 729       if( argWatchV )
 730       {
 731         //free string data
 732         for (int i=0; i<argWatchC+1; i++)
 733         {
 734           delete [] argWatchV[i];
 735         }
 736         delete [] argWatchV;
 737       }
 738     } catch (std::out_of_range& e) {
 739       {
 740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 741       };
 742     } catch (std::exception& e) {
 743       {
 744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 745       };
 746     } catch (...) {
 747       {
 748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 749       };
 750     }
 751   }
 752 }
 753
 754
 755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_TimeTickSignal(void * jarg1) {
 756   void * jresult ;
 757   Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ;
 758   Dali::WatchApplication::WatchTimeSignal *result = 0 ;
 759
 760   arg1 = (Dali::WatchApplication *)jarg1;
 761   {
 762     try {
 763       result = (Dali::WatchApplication::WatchTimeSignal *) &(arg1)->TimeTickSignal();
 764     } catch (std::out_of_range& e) {
 765       {
 766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 767       };
 768     } catch (std::exception& e) {
 769       {
 770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 771       };
 772     } catch (...) {
 773       {
 774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 775       };
 776     }
 777   }
 778   jresult = (void *)result;
 779   return jresult;
 780 }
 781
 782
 783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_AmbientTickSignal(void * jarg1) {
 784   void * jresult ;
 785   Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ;
 786   Dali::WatchApplication::WatchTimeSignal *result = 0 ;
 787
 788   arg1 = (Dali::WatchApplication *)jarg1;
 789   {
 790     try {
 791       result = (Dali::WatchApplication::WatchTimeSignal *) &(arg1)->AmbientTickSignal();
 792     } catch (std::out_of_range& e) {
 793       {
 794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 795       };
 796     } catch (std::exception& e) {
 797       {
 798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 799       };
 800     } catch (...) {
 801       {
 802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 803       };
 804     }
 805   }
 806   jresult = (void *)result;
 807   return jresult;
 808 }
 809
 810
 811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_AmbientChangedSignal(void * jarg1) {
 812   void * jresult ;
 813   Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ;
 814   Dali::WatchApplication::WatchBoolSignal *result = 0 ;
 815
 816   arg1 = (Dali::WatchApplication *)jarg1;
 817   {
 818     try {
 819       result = (Dali::WatchApplication::WatchBoolSignal *) &(arg1)->AmbientChangedSignal();
 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 (...) {
 829       {
 830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 831       };
 832     }
 833   }
 834   jresult = (void *)result;
 835   return jresult;
 836 }
 837
 838
 839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WatchTimeSignal_Empty(void * jarg1) {
 840   unsigned int jresult ;
 841   Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ;
 842   bool result;
 843
 844   arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1;
 845   {
 846     try {
 847       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > const *)arg1);
 848     } catch (std::out_of_range& e) {
 849       {
 850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 851       };
 852     } catch (std::exception& e) {
 853       {
 854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 855       };
 856     } catch (...) {
 857       {
 858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 859       };
 860     }
 861   }
 862   jresult = result;
 863   return jresult;
 864 }
 865
 866
 867 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WatchTimeSignal_GetConnectionCount(void * jarg1) {
 868   unsigned long jresult ;
 869   Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ;
 870   std::size_t result;
 871
 872   arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1;
 873   {
 874     try {
 875       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > const *)arg1);
 876     } catch (std::out_of_range& e) {
 877       {
 878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 879       };
 880     } catch (std::exception& e) {
 881       {
 882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 883       };
 884     } catch (...) {
 885       {
 886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 887       };
 888     }
 889   }
 890   jresult = (unsigned long)result;
 891   return jresult;
 892 }
 893
 894
 895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchTimeSignal_Connect(void * jarg1, void * jarg2) {
 896   Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ;
 897   void (*arg2)(Dali::Application &,Dali::WatchTime const &) = (void (*)(Dali::Application &,Dali::WatchTime const &)) 0 ;
 898
 899   arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1;
 900   arg2 = (void (*)(Dali::Application &,Dali::WatchTime const &))jarg2;
 901   {
 902     try {
 903       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Connect(arg1,arg2);
 904     } catch (std::out_of_range& e) {
 905       {
 906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 907       };
 908     } catch (std::exception& e) {
 909       {
 910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 911       };
 912     } catch (...) {
 913       {
 914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 915       };
 916     }
 917   }
 918 }
 919
 920
 921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchTimeSignal_Disconnect(void * jarg1, void * jarg2) {
 922   Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ;
 923   void (*arg2)(Dali::Application &,Dali::WatchTime const &) = (void (*)(Dali::Application &,Dali::WatchTime const &)) 0 ;
 924
 925   arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1;
 926   arg2 = (void (*)(Dali::Application &,Dali::WatchTime const &))jarg2;
 927   {
 928     try {
 929       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
 930     } catch (std::out_of_range& e) {
 931       {
 932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 933       };
 934     } catch (std::exception& e) {
 935       {
 936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 937       };
 938     } catch (...) {
 939       {
 940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 941       };
 942     }
 943   }
 944 }
 945
 946
 947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchTimeSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
 948   Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ;
 949   Dali::Application *arg2 = 0 ;
 950   Dali::WatchTime *arg3 = 0 ;
 951
 952   arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1;
 953   arg2 = (Dali::Application *)jarg2;
 954   if (!arg2) {
 955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
 956     return ;
 957   }
 958   arg3 = (Dali::WatchTime *)jarg3;
 959   if (!arg3) {
 960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WatchTime const & type is null", 0);
 961     return ;
 962   }
 963   {
 964     try {
 965       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Emit(arg1,*arg2,(Dali::WatchTime const &)*arg3);
 966     } catch (std::out_of_range& e) {
 967       {
 968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 969       };
 970     } catch (std::exception& e) {
 971       {
 972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 973       };
 974     } catch (...) {
 975       {
 976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 977       };
 978     }
 979   }
 980 }
 981
 982
 983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchTimeSignal() {
 984   void * jresult ;
 985   Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *result = 0 ;
 986
 987   {
 988     try {
 989       result = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)new Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) >();
 990     } catch (std::out_of_range& e) {
 991       {
 992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 993       };
 994     } catch (std::exception& e) {
 995       {
 996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 997       };
 998     } catch (...) {
 999       {
1000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1001       };
1002     }
1003   }
1004   jresult = (void *)result;
1005   return jresult;
1006 }
1007
1008
1009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchTimeSignal(void * jarg1) {
1010   Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ;
1011
1012   arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1;
1013   {
1014     try {
1015       delete arg1;
1016     } catch (std::out_of_range& e) {
1017       {
1018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1019       };
1020     } catch (std::exception& e) {
1021       {
1022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1023       };
1024     } catch (...) {
1025       {
1026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1027       };
1028     }
1029   }
1030 }
1031
1032
1033 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WatchBoolSignal_Empty(void * jarg1) {
1034   unsigned int jresult ;
1035   Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ;
1036   bool result;
1037
1038   arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1;
1039   {
1040     try {
1041       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Application &,bool) > const *)arg1);
1042     } catch (std::out_of_range& e) {
1043       {
1044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1045       };
1046     } catch (std::exception& e) {
1047       {
1048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1049       };
1050     } catch (...) {
1051       {
1052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1053       };
1054     }
1055   }
1056   jresult = result;
1057   return jresult;
1058 }
1059
1060
1061 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WatchBoolSignal_GetConnectionCount(void * jarg1) {
1062   unsigned long jresult ;
1063   Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ;
1064   std::size_t result;
1065
1066   arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1;
1067   {
1068     try {
1069       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,bool) > const *)arg1);
1070     } catch (std::out_of_range& e) {
1071       {
1072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1073       };
1074     } catch (std::exception& e) {
1075       {
1076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1077       };
1078     } catch (...) {
1079       {
1080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1081       };
1082     }
1083   }
1084   jresult = (unsigned long)result;
1085   return jresult;
1086 }
1087
1088
1089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchBoolSignal_Connect(void * jarg1, void * jarg2) {
1090   Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ;
1091   void (*arg2)(Dali::Application &,bool) = (void (*)(Dali::Application &,bool)) 0 ;
1092
1093   arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1;
1094   arg2 = (void (*)(Dali::Application &,bool))jarg2;
1095   {
1096     try {
1097       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Connect(arg1,arg2);
1098     } catch (std::out_of_range& e) {
1099       {
1100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1101       };
1102     } catch (std::exception& e) {
1103       {
1104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1105       };
1106     } catch (...) {
1107       {
1108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1109       };
1110     }
1111   }
1112 }
1113
1114
1115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchBoolSignal_Disconnect(void * jarg1, void * jarg2) {
1116   Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ;
1117   void (*arg2)(Dali::Application &,bool) = (void (*)(Dali::Application &,bool)) 0 ;
1118
1119   arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1;
1120   arg2 = (void (*)(Dali::Application &,bool))jarg2;
1121   {
1122     try {
1123       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Disconnect(arg1,arg2);
1124     } catch (std::out_of_range& e) {
1125       {
1126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1127       };
1128     } catch (std::exception& e) {
1129       {
1130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1131       };
1132     } catch (...) {
1133       {
1134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1135       };
1136     }
1137   }
1138 }
1139
1140
1141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchBoolSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
1142   Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ;
1143   Dali::Application *arg2 = 0 ;
1144   bool arg3 ;
1145
1146   arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1;
1147   arg2 = (Dali::Application *)jarg2;
1148   if (!arg2) {
1149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
1150     return ;
1151   }
1152   arg3 = jarg3 ? true : false;
1153   {
1154     try {
1155       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Emit(arg1,*arg2,arg3);
1156     } catch (std::out_of_range& e) {
1157       {
1158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1159       };
1160     } catch (std::exception& e) {
1161       {
1162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1163       };
1164     } catch (...) {
1165       {
1166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1167       };
1168     }
1169   }
1170 }
1171
1172
1173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchBoolSignal() {
1174   void * jresult ;
1175   Dali::Signal< void (Dali::Application &,bool) > *result = 0 ;
1176
1177   {
1178     try {
1179       result = (Dali::Signal< void (Dali::Application &,bool) > *)new Dali::Signal< void (Dali::Application &,bool) >();
1180     } catch (std::out_of_range& e) {
1181       {
1182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1183       };
1184     } catch (std::exception& e) {
1185       {
1186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1187       };
1188     } catch (...) {
1189       {
1190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1191       };
1192     }
1193   }
1194   jresult = (void *)result;
1195   return jresult;
1196 }
1197
1198
1199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchBoolSignal(void * jarg1) {
1200   Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ;
1201
1202   arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1;
1203   {
1204     try {
1205       delete arg1;
1206     } catch (std::out_of_range& e) {
1207       {
1208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1209       };
1210     } catch (std::exception& e) {
1211       {
1212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1213       };
1214     } catch (...) {
1215       {
1216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1217       };
1218     }
1219   }
1220 }
1221
1222
1223 #ifdef __cplusplus
1224 }
1225 #endif
1226