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 (Dali::DaliException e) {
  88       {
  89         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
  90       };
  91     } catch (...) {
  92       {
  93         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
  94       };
  95     }
  96   }
  97   jresult = (void *)result;
  98   return jresult;
  99 }
 100
 101
 102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchTime(void * jarg1) {
 103   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 104
 105   arg1 = (Dali::WatchTime *)jarg1;
 106   {
 107     try {
 108       delete arg1;
 109     } catch (std::out_of_range& e) {
 110       {
 111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 112       };
 113     } catch (std::exception& e) {
 114       {
 115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 116       };
 117     } catch (Dali::DaliException e) {
 118       {
 119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 120       };
 121     } catch (...) {
 122       {
 123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 124       };
 125     }
 126   }
 127 }
 128
 129
 130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetHour(void * jarg1) {
 131   int jresult ;
 132   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 133   int result;
 134
 135   arg1 = (Dali::WatchTime *)jarg1;
 136   {
 137     try {
 138       result = (int)((Dali::WatchTime const *)arg1)->GetHour();
 139     } catch (std::out_of_range& e) {
 140       {
 141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 142       };
 143     } catch (std::exception& e) {
 144       {
 145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 146       };
 147     } catch (Dali::DaliException e) {
 148       {
 149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 150       };
 151     } catch (...) {
 152       {
 153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 154       };
 155     }
 156   }
 157   jresult = result;
 158   return jresult;
 159 }
 160
 161
 162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetHour24(void * jarg1) {
 163   int jresult ;
 164   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 165   int result;
 166
 167   arg1 = (Dali::WatchTime *)jarg1;
 168   {
 169     try {
 170       result = (int)((Dali::WatchTime const *)arg1)->GetHour24();
 171     } catch (std::out_of_range& e) {
 172       {
 173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 174       };
 175     } catch (std::exception& e) {
 176       {
 177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 178       };
 179     } catch (Dali::DaliException e) {
 180       {
 181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 182       };
 183     } catch (...) {
 184       {
 185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 186       };
 187     }
 188   }
 189   jresult = result;
 190   return jresult;
 191 }
 192
 193
 194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetMinute(void * jarg1) {
 195   int jresult ;
 196   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 197   int result;
 198
 199   arg1 = (Dali::WatchTime *)jarg1;
 200   {
 201     try {
 202       result = (int)((Dali::WatchTime const *)arg1)->GetMinute();
 203     } catch (std::out_of_range& e) {
 204       {
 205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 206       };
 207     } catch (std::exception& e) {
 208       {
 209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 210       };
 211     } catch (Dali::DaliException e) {
 212       {
 213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 214       };
 215     } catch (...) {
 216       {
 217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 218       };
 219     }
 220   }
 221   jresult = result;
 222   return jresult;
 223 }
 224
 225
 226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetSecond(void * jarg1) {
 227   int jresult ;
 228   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 229   int result;
 230
 231   arg1 = (Dali::WatchTime *)jarg1;
 232   {
 233     try {
 234       result = (int)((Dali::WatchTime const *)arg1)->GetSecond();
 235     } catch (std::out_of_range& e) {
 236       {
 237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 238       };
 239     } catch (std::exception& e) {
 240       {
 241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 242       };
 243     } catch (Dali::DaliException e) {
 244       {
 245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 246       };
 247     } catch (...) {
 248       {
 249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 250       };
 251     }
 252   }
 253   jresult = result;
 254   return jresult;
 255 }
 256
 257
 258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetMillisecond(void * jarg1) {
 259   int jresult ;
 260   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 261   int result;
 262
 263   arg1 = (Dali::WatchTime *)jarg1;
 264   {
 265     try {
 266       result = (int)((Dali::WatchTime const *)arg1)->GetMillisecond();
 267     } catch (std::out_of_range& e) {
 268       {
 269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 270       };
 271     } catch (std::exception& e) {
 272       {
 273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 274       };
 275     } catch (Dali::DaliException e) {
 276       {
 277         SWIG_CSharpException(SWIG_UnknownError, e.condition); 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_GetYear(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)->GetYear();
 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 (Dali::DaliException e) {
 308       {
 309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 310       };
 311     } catch (...) {
 312       {
 313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 314       };
 315     }
 316   }
 317   jresult = result;
 318   return jresult;
 319 }
 320
 321
 322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetMonth(void * jarg1) {
 323   int jresult ;
 324   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 325   int result;
 326
 327   arg1 = (Dali::WatchTime *)jarg1;
 328   {
 329     try {
 330       result = (int)((Dali::WatchTime const *)arg1)->GetMonth();
 331     } catch (std::out_of_range& e) {
 332       {
 333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 334       };
 335     } catch (std::exception& e) {
 336       {
 337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 338       };
 339     } catch (Dali::DaliException e) {
 340       {
 341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 342       };
 343     } catch (...) {
 344       {
 345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 346       };
 347     }
 348   }
 349   jresult = result;
 350   return jresult;
 351 }
 352
 353
 354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetDay(void * jarg1) {
 355   int jresult ;
 356   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 357   int result;
 358
 359   arg1 = (Dali::WatchTime *)jarg1;
 360   {
 361     try {
 362       result = (int)((Dali::WatchTime const *)arg1)->GetDay();
 363     } catch (std::out_of_range& e) {
 364       {
 365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 366       };
 367     } catch (std::exception& e) {
 368       {
 369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 370       };
 371     } catch (Dali::DaliException e) {
 372       {
 373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 374       };
 375     } catch (...) {
 376       {
 377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 378       };
 379     }
 380   }
 381   jresult = result;
 382   return jresult;
 383 }
 384
 385
 386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetDayOfWeek(void * jarg1) {
 387   int jresult ;
 388   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 389   int result;
 390
 391   arg1 = (Dali::WatchTime *)jarg1;
 392   {
 393     try {
 394       result = (int)((Dali::WatchTime const *)arg1)->GetDayOfWeek();
 395     } catch (std::out_of_range& e) {
 396       {
 397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 398       };
 399     } catch (std::exception& e) {
 400       {
 401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 402       };
 403     } catch (Dali::DaliException e) {
 404       {
 405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 406       };
 407     } catch (...) {
 408       {
 409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 410       };
 411     }
 412   }
 413   jresult = result;
 414   return jresult;
 415 }
 416
 417
 418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchTime_GetUtcTime(void * jarg1) {
 419   void * jresult ;
 420   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 421   tm result;
 422
 423   arg1 = (Dali::WatchTime *)jarg1;
 424   {
 425     try {
 426       result = ((Dali::WatchTime const *)arg1)->GetUtcTime();
 427     } catch (std::out_of_range& e) {
 428       {
 429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 430       };
 431     } catch (std::exception& e) {
 432       {
 433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 434       };
 435     } catch (Dali::DaliException e) {
 436       {
 437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 438       };
 439     } catch (...) {
 440       {
 441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 442       };
 443     }
 444   }
 445   jresult = new tm((const tm &)result);
 446   return jresult;
 447 }
 448
 449
 450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchTime_GetUtcTimeStamp(void * jarg1) {
 451   void * jresult ;
 452   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 453   time_t result;
 454
 455   arg1 = (Dali::WatchTime *)jarg1;
 456   {
 457     try {
 458       result = ((Dali::WatchTime const *)arg1)->GetUtcTimeStamp();
 459     } catch (std::out_of_range& e) {
 460       {
 461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 462       };
 463     } catch (std::exception& e) {
 464       {
 465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 466       };
 467     } catch (Dali::DaliException e) {
 468       {
 469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 470       };
 471     } catch (...) {
 472       {
 473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 474       };
 475     }
 476   }
 477   jresult = new time_t((const time_t &)result);
 478   return jresult;
 479 }
 480
 481
 482 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_WatchTime_GetTimeZone(void * jarg1) {
 483   char * jresult ;
 484   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 485   char *result = 0 ;
 486
 487   arg1 = (Dali::WatchTime *)jarg1;
 488   {
 489     try {
 490       result = (char *)((Dali::WatchTime const *)arg1)->GetTimeZone();
 491     } catch (std::out_of_range& e) {
 492       {
 493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 494       };
 495     } catch (std::exception& e) {
 496       {
 497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 498       };
 499     } catch (Dali::DaliException e) {
 500       {
 501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 502       };
 503     } catch (...) {
 504       {
 505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 506       };
 507     }
 508   }
 509   jresult = SWIG_csharp_string_callback((const char *)result);
 510   return jresult;
 511 }
 512
 513
 514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WatchTime_GetDaylightSavingTimeStatus(void * jarg1) {
 515   unsigned int jresult ;
 516   Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ;
 517   bool result;
 518
 519   arg1 = (Dali::WatchTime *)jarg1;
 520   {
 521     try {
 522       result = (bool)((Dali::WatchTime const *)arg1)->GetDaylightSavingTimeStatus();
 523     } catch (std::out_of_range& e) {
 524       {
 525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 526       };
 527     } catch (std::exception& e) {
 528       {
 529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 530       };
 531     } catch (Dali::DaliException e) {
 532       {
 533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 534       };
 535     } catch (...) {
 536       {
 537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 538       };
 539     }
 540   }
 541   jresult = result;
 542   return jresult;
 543 }
 544
 545
 546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_New__SWIG_0() {
 547   void * jresult ;
 548   Dali::WatchApplication result;
 549
 550   {
 551     try {
 552       result = Dali::WatchApplication::New();
 553     } catch (std::out_of_range& e) {
 554       {
 555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 556       };
 557     } catch (std::exception& e) {
 558       {
 559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 560       };
 561     } catch (Dali::DaliException e) {
 562       {
 563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 564       };
 565     } catch (...) {
 566       {
 567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 568       };
 569     }
 570   }
 571   jresult = new Dali::WatchApplication((const Dali::WatchApplication &)result);
 572   return jresult;
 573 }
 574
 575
 576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_New__SWIG_1(int jarg1, char * jarg2) {
 577   void * jresult ;
 578   int *arg1 = (int *) 0 ;
 579   char ***arg2 ;
 580   Dali::WatchApplication result;
 581   {
 582     int index = 0;
 583     int length = 0;
 584     char *retPtr;
 585     char *nextPtr;
 586     argWatchC = jarg1;
 587     argWatchV = new char*[jarg1 + 1];
 588
 589     retPtr = strtok_r(jarg2, " ", &nextPtr);
 590     if( retPtr )
 591     {
 592       length = strlen(retPtr);
 593     }
 594     argWatchV[index] = new char[length + 1];
 595     if( retPtr )
 596     {
 597       strncpy(argWatchV[index], retPtr, length);
 598     }
 599     argWatchV[index][length] = '\0';
 600     index++;
 601
 602     while( index < jarg1 )
 603     {
 604       length = 0;
 605       retPtr = strtok_r(NULL, " ", &nextPtr);
 606       if( retPtr )
 607       {
 608         length = strlen(retPtr);
 609       }
 610       argWatchV[index] = new char[length + 1];
 611       if( retPtr )
 612       {
 613         strncpy(argWatchV[index], retPtr, length);
 614       }
 615       argWatchV[index][length] = '\0';
 616       index++;
 617     }
 618   }
 619
 620   argWatchV[jarg1] = NULL;
 621
 622   arg1 = &argWatchC;
 623   arg2 = &argWatchV;
 624   {
 625     try {
 626       result = Dali::WatchApplication::New(arg1,arg2);
 627     } catch (std::out_of_range& e) {
 628       {
 629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 630       };
 631     } catch (std::exception& e) {
 632       {
 633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 634       };
 635     } catch (Dali::DaliException e) {
 636       {
 637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 638       };
 639     } catch (...) {
 640       {
 641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 642       };
 643     }
 644   }
 645   jresult = new Dali::WatchApplication((const Dali::WatchApplication &)result);
 646   return jresult;
 647 }
 648
 649
 650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_New__SWIG_2(int jarg1, char * jarg2, char * jarg3) {
 651   void * jresult ;
 652   int *arg1 = (int *) 0 ;
 653   char ***arg2 ;
 654   std::string *arg3 = 0 ;
 655   Dali::WatchApplication result;
 656   {
 657     int index = 0;
 658     int length = 0;
 659     char *retPtr;
 660     char *nextPtr;
 661     argWatchC = jarg1;
 662     argWatchV = new char*[jarg1 + 1];
 663
 664     retPtr = strtok_r(jarg2, " ", &nextPtr);
 665     if( retPtr )
 666     {
 667       length = strlen(retPtr);
 668     }
 669     argWatchV[index] = new char[length + 1];
 670     if( retPtr )
 671     {
 672       strncpy(argWatchV[index], retPtr, length);
 673     }
 674     argWatchV[index][length] = '\0';
 675     index++;
 676
 677     while( index < jarg1 )
 678     {
 679       length = 0;
 680       retPtr = strtok_r(NULL, " ", &nextPtr);
 681       if( retPtr )
 682       {
 683         length = strlen(retPtr);
 684       }
 685       argWatchV[index] = new char[length + 1];
 686       if( retPtr )
 687       {
 688         strncpy(argWatchV[index], retPtr, length);
 689       }
 690       argWatchV[index][length] = '\0';
 691       index++;
 692     }
 693   }
 694
 695   argWatchV[jarg1] = NULL;
 696
 697   arg1 = &argWatchC;
 698   arg2 = &argWatchV;
 699   if (!jarg3) {
 700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 701     return 0;
 702   }
 703   std::string arg3_str(jarg3);
 704   arg3 = &arg3_str;
 705   {
 706     try {
 707       result = Dali::WatchApplication::New(arg1,arg2,(std::string const &)*arg3);
 708     } catch (std::out_of_range& e) {
 709       {
 710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 711       };
 712     } catch (std::exception& e) {
 713       {
 714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 715       };
 716     } catch (Dali::DaliException e) {
 717       {
 718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 719       };
 720     } catch (...) {
 721       {
 722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 723       };
 724     }
 725   }
 726   jresult = new Dali::WatchApplication((const Dali::WatchApplication &)result);
 727
 728   //argout typemap for const std::string&
 729
 730   return jresult;
 731 }
 732
 733
 734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchApplication__SWIG_0() {
 735   void * jresult ;
 736   Dali::WatchApplication *result = 0 ;
 737
 738   {
 739     try {
 740       result = (Dali::WatchApplication *)new Dali::WatchApplication();
 741     } catch (std::out_of_range& e) {
 742       {
 743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 744       };
 745     } catch (std::exception& e) {
 746       {
 747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 748       };
 749     } catch (Dali::DaliException e) {
 750       {
 751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 752       };
 753     } catch (...) {
 754       {
 755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 756       };
 757     }
 758   }
 759   jresult = (void *)result;
 760   return jresult;
 761 }
 762
 763
 764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchApplication__SWIG_1(void * jarg1) {
 765   void * jresult ;
 766   Dali::WatchApplication *arg1 = 0 ;
 767   Dali::WatchApplication *result = 0 ;
 768
 769   arg1 = (Dali::WatchApplication *)jarg1;
 770   if (!arg1) {
 771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WatchApplication const & type is null", 0);
 772     return 0;
 773   }
 774   {
 775     try {
 776       result = (Dali::WatchApplication *)new Dali::WatchApplication((Dali::WatchApplication const &)*arg1);
 777     } catch (std::out_of_range& e) {
 778       {
 779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 780       };
 781     } catch (std::exception& e) {
 782       {
 783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 784       };
 785     } catch (Dali::DaliException e) {
 786       {
 787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 788       };
 789     } catch (...) {
 790       {
 791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 792       };
 793     }
 794   }
 795   jresult = (void *)result;
 796   return jresult;
 797 }
 798
 799
 800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_Assign(void * jarg1, void * jarg2) {
 801   void * jresult ;
 802   Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ;
 803   Dali::WatchApplication *arg2 = 0 ;
 804   Dali::WatchApplication *result = 0 ;
 805
 806   arg1 = (Dali::WatchApplication *)jarg1;
 807   arg2 = (Dali::WatchApplication *)jarg2;
 808   if (!arg2) {
 809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WatchApplication const & type is null", 0);
 810     return 0;
 811   }
 812   {
 813     try {
 814       result = (Dali::WatchApplication *) &(arg1)->operator =((Dali::WatchApplication const &)*arg2);
 815     } catch (std::out_of_range& e) {
 816       {
 817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 818       };
 819     } catch (std::exception& e) {
 820       {
 821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 822       };
 823     } catch (Dali::DaliException e) {
 824       {
 825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 826       };
 827     } catch (...) {
 828       {
 829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 830       };
 831     }
 832   }
 833   jresult = (void *)result;
 834   return jresult;
 835 }
 836
 837
 838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchApplication(void * jarg1) {
 839   Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ;
 840
 841   arg1 = (Dali::WatchApplication *)jarg1;
 842   {
 843     try {
 844       delete arg1;
 845       if( argWatchV )
 846       {
 847         //free string data
 848         for (int i=0; i<argWatchC+1; i++)
 849         {
 850           delete [] argWatchV[i];
 851         }
 852         delete [] argWatchV;
 853       }
 854     } catch (std::out_of_range& e) {
 855       {
 856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 857       };
 858     } catch (std::exception& e) {
 859       {
 860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 861       };
 862     } catch (Dali::DaliException e) {
 863       {
 864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 865       };
 866     } catch (...) {
 867       {
 868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 869       };
 870     }
 871   }
 872 }
 873
 874
 875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_TimeTickSignal(void * jarg1) {
 876   void * jresult ;
 877   Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ;
 878   Dali::WatchApplication::WatchTimeSignal *result = 0 ;
 879
 880   arg1 = (Dali::WatchApplication *)jarg1;
 881   {
 882     try {
 883       result = (Dali::WatchApplication::WatchTimeSignal *) &(arg1)->TimeTickSignal();
 884     } catch (std::out_of_range& e) {
 885       {
 886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 887       };
 888     } catch (std::exception& e) {
 889       {
 890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 891       };
 892     } catch (Dali::DaliException e) {
 893       {
 894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 895       };
 896     } catch (...) {
 897       {
 898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 899       };
 900     }
 901   }
 902   jresult = (void *)result;
 903   return jresult;
 904 }
 905
 906
 907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_AmbientTickSignal(void * jarg1) {
 908   void * jresult ;
 909   Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ;
 910   Dali::WatchApplication::WatchTimeSignal *result = 0 ;
 911
 912   arg1 = (Dali::WatchApplication *)jarg1;
 913   {
 914     try {
 915       result = (Dali::WatchApplication::WatchTimeSignal *) &(arg1)->AmbientTickSignal();
 916     } catch (std::out_of_range& e) {
 917       {
 918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 919       };
 920     } catch (std::exception& e) {
 921       {
 922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 923       };
 924     } catch (Dali::DaliException e) {
 925       {
 926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 927       };
 928     } catch (...) {
 929       {
 930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 931       };
 932     }
 933   }
 934   jresult = (void *)result;
 935   return jresult;
 936 }
 937
 938
 939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_AmbientChangedSignal(void * jarg1) {
 940   void * jresult ;
 941   Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ;
 942   Dali::WatchApplication::WatchBoolSignal *result = 0 ;
 943
 944   arg1 = (Dali::WatchApplication *)jarg1;
 945   {
 946     try {
 947       result = (Dali::WatchApplication::WatchBoolSignal *) &(arg1)->AmbientChangedSignal();
 948     } catch (std::out_of_range& e) {
 949       {
 950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 951       };
 952     } catch (std::exception& e) {
 953       {
 954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 955       };
 956     } catch (Dali::DaliException e) {
 957       {
 958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 959       };
 960     } catch (...) {
 961       {
 962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 963       };
 964     }
 965   }
 966   jresult = (void *)result;
 967   return jresult;
 968 }
 969
 970
 971 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WatchTimeSignal_Empty(void * jarg1) {
 972   unsigned int jresult ;
 973   Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ;
 974   bool result;
 975
 976   arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1;
 977   {
 978     try {
 979       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);
 980     } catch (std::out_of_range& e) {
 981       {
 982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 983       };
 984     } catch (std::exception& e) {
 985       {
 986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 987       };
 988     } catch (Dali::DaliException e) {
 989       {
 990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 991       };
 992     } catch (...) {
 993       {
 994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 995       };
 996     }
 997   }
 998   jresult = result;
 999   return jresult;
1000 }
1001
1002
1003 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WatchTimeSignal_GetConnectionCount(void * jarg1) {
1004   unsigned long jresult ;
1005   Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ;
1006   std::size_t result;
1007
1008   arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1;
1009   {
1010     try {
1011       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);
1012     } catch (std::out_of_range& e) {
1013       {
1014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1015       };
1016     } catch (std::exception& e) {
1017       {
1018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1019       };
1020     } catch (Dali::DaliException e) {
1021       {
1022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1023       };
1024     } catch (...) {
1025       {
1026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1027       };
1028     }
1029   }
1030   jresult = (unsigned long)result;
1031   return jresult;
1032 }
1033
1034
1035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchTimeSignal_Connect(void * jarg1, void * jarg2) {
1036   Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ;
1037   void (*arg2)(Dali::Application &,Dali::WatchTime const &) = (void (*)(Dali::Application &,Dali::WatchTime const &)) 0 ;
1038
1039   arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1;
1040   arg2 = (void (*)(Dali::Application &,Dali::WatchTime const &))jarg2;
1041   {
1042     try {
1043       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Connect(arg1,arg2);
1044     } catch (std::out_of_range& e) {
1045       {
1046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1047       };
1048     } catch (std::exception& e) {
1049       {
1050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1051       };
1052     } catch (Dali::DaliException e) {
1053       {
1054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1055       };
1056     } catch (...) {
1057       {
1058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1059       };
1060     }
1061   }
1062 }
1063
1064
1065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchTimeSignal_Disconnect(void * jarg1, void * jarg2) {
1066   Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ;
1067   void (*arg2)(Dali::Application &,Dali::WatchTime const &) = (void (*)(Dali::Application &,Dali::WatchTime const &)) 0 ;
1068
1069   arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1;
1070   arg2 = (void (*)(Dali::Application &,Dali::WatchTime const &))jarg2;
1071   {
1072     try {
1073       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
1074     } catch (std::out_of_range& e) {
1075       {
1076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1077       };
1078     } catch (std::exception& e) {
1079       {
1080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1081       };
1082     } catch (Dali::DaliException e) {
1083       {
1084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1085       };
1086     } catch (...) {
1087       {
1088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1089       };
1090     }
1091   }
1092 }
1093
1094
1095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchTimeSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
1096   Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ;
1097   Dali::Application *arg2 = 0 ;
1098   Dali::WatchTime *arg3 = 0 ;
1099
1100   arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1;
1101   arg2 = (Dali::Application *)jarg2;
1102   if (!arg2) {
1103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
1104     return ;
1105   }
1106   arg3 = (Dali::WatchTime *)jarg3;
1107   if (!arg3) {
1108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WatchTime const & type is null", 0);
1109     return ;
1110   }
1111   {
1112     try {
1113       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Emit(arg1,*arg2,(Dali::WatchTime const &)*arg3);
1114     } catch (std::out_of_range& e) {
1115       {
1116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1117       };
1118     } catch (std::exception& e) {
1119       {
1120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1121       };
1122     } catch (Dali::DaliException e) {
1123       {
1124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1125       };
1126     } catch (...) {
1127       {
1128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1129       };
1130     }
1131   }
1132 }
1133
1134
1135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchTimeSignal() {
1136   void * jresult ;
1137   Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *result = 0 ;
1138
1139   {
1140     try {
1141       result = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)new Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) >();
1142     } catch (std::out_of_range& e) {
1143       {
1144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1145       };
1146     } catch (std::exception& e) {
1147       {
1148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1149       };
1150     } catch (Dali::DaliException e) {
1151       {
1152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1153       };
1154     } catch (...) {
1155       {
1156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1157       };
1158     }
1159   }
1160   jresult = (void *)result;
1161   return jresult;
1162 }
1163
1164
1165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchTimeSignal(void * jarg1) {
1166   Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ;
1167
1168   arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1;
1169   {
1170     try {
1171       delete arg1;
1172     } catch (std::out_of_range& e) {
1173       {
1174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1175       };
1176     } catch (std::exception& e) {
1177       {
1178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1179       };
1180     } catch (Dali::DaliException e) {
1181       {
1182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1183       };
1184     } catch (...) {
1185       {
1186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1187       };
1188     }
1189   }
1190 }
1191
1192
1193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WatchBoolSignal_Empty(void * jarg1) {
1194   unsigned int jresult ;
1195   Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ;
1196   bool result;
1197
1198   arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1;
1199   {
1200     try {
1201       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Application &,bool) > const *)arg1);
1202     } catch (std::out_of_range& e) {
1203       {
1204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1205       };
1206     } catch (std::exception& e) {
1207       {
1208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1209       };
1210     } catch (Dali::DaliException e) {
1211       {
1212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1213       };
1214     } catch (...) {
1215       {
1216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1217       };
1218     }
1219   }
1220   jresult = result;
1221   return jresult;
1222 }
1223
1224
1225 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WatchBoolSignal_GetConnectionCount(void * jarg1) {
1226   unsigned long jresult ;
1227   Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ;
1228   std::size_t result;
1229
1230   arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1;
1231   {
1232     try {
1233       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,bool) > const *)arg1);
1234     } catch (std::out_of_range& e) {
1235       {
1236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1237       };
1238     } catch (std::exception& e) {
1239       {
1240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1241       };
1242     } catch (Dali::DaliException e) {
1243       {
1244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1245       };
1246     } catch (...) {
1247       {
1248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1249       };
1250     }
1251   }
1252   jresult = (unsigned long)result;
1253   return jresult;
1254 }
1255
1256
1257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchBoolSignal_Connect(void * jarg1, void * jarg2) {
1258   Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ;
1259   void (*arg2)(Dali::Application &,bool) = (void (*)(Dali::Application &,bool)) 0 ;
1260
1261   arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1;
1262   arg2 = (void (*)(Dali::Application &,bool))jarg2;
1263   {
1264     try {
1265       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Connect(arg1,arg2);
1266     } catch (std::out_of_range& e) {
1267       {
1268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1269       };
1270     } catch (std::exception& e) {
1271       {
1272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1273       };
1274     } catch (Dali::DaliException e) {
1275       {
1276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1277       };
1278     } catch (...) {
1279       {
1280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1281       };
1282     }
1283   }
1284 }
1285
1286
1287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchBoolSignal_Disconnect(void * jarg1, void * jarg2) {
1288   Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ;
1289   void (*arg2)(Dali::Application &,bool) = (void (*)(Dali::Application &,bool)) 0 ;
1290
1291   arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1;
1292   arg2 = (void (*)(Dali::Application &,bool))jarg2;
1293   {
1294     try {
1295       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Disconnect(arg1,arg2);
1296     } catch (std::out_of_range& e) {
1297       {
1298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1299       };
1300     } catch (std::exception& e) {
1301       {
1302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1303       };
1304     } catch (Dali::DaliException e) {
1305       {
1306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1307       };
1308     } catch (...) {
1309       {
1310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1311       };
1312     }
1313   }
1314 }
1315
1316
1317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchBoolSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
1318   Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ;
1319   Dali::Application *arg2 = 0 ;
1320   bool arg3 ;
1321
1322   arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1;
1323   arg2 = (Dali::Application *)jarg2;
1324   if (!arg2) {
1325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
1326     return ;
1327   }
1328   arg3 = jarg3 ? true : false;
1329   {
1330     try {
1331       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Emit(arg1,*arg2,arg3);
1332     } catch (std::out_of_range& e) {
1333       {
1334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1335       };
1336     } catch (std::exception& e) {
1337       {
1338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1339       };
1340     } catch (Dali::DaliException e) {
1341       {
1342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1343       };
1344     } catch (...) {
1345       {
1346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1347       };
1348     }
1349   }
1350 }
1351
1352
1353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchBoolSignal() {
1354   void * jresult ;
1355   Dali::Signal< void (Dali::Application &,bool) > *result = 0 ;
1356
1357   {
1358     try {
1359       result = (Dali::Signal< void (Dali::Application &,bool) > *)new Dali::Signal< void (Dali::Application &,bool) >();
1360     } catch (std::out_of_range& e) {
1361       {
1362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1363       };
1364     } catch (std::exception& e) {
1365       {
1366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1367       };
1368     } catch (Dali::DaliException e) {
1369       {
1370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1371       };
1372     } catch (...) {
1373       {
1374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1375       };
1376     }
1377   }
1378   jresult = (void *)result;
1379   return jresult;
1380 }
1381
1382
1383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchBoolSignal(void * jarg1) {
1384   Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ;
1385
1386   arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1;
1387   {
1388     try {
1389       delete arg1;
1390     } catch (std::out_of_range& e) {
1391       {
1392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1393       };
1394     } catch (std::exception& e) {
1395       {
1396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1397       };
1398     } catch (Dali::DaliException e) {
1399       {
1400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1401       };
1402     } catch (...) {
1403       {
1404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1405       };
1406     }
1407   }
1408 }
1409
1410
1411 #ifdef __cplusplus
1412 }
1413 #endif
1414