dali-csharp-binder/src/autofill-container-wrap.cpp

   1 /*
   2  * Copyright (c) 2019 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #ifndef CSHARP_AUTOFILL_CONTAINER
  19 #define CSHARP_AUTOFILL_CONTAINER
  20 #endif
  21
  22 #include "common.h"
  23 #include <dali-toolkit/devel-api/controls/text-controls/autofill-container.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 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_AutofillContainer_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > const *self){
  31   return self->Empty();
  32 }
  33 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_AutofillContainer_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > const *self){
  34   return self->GetConnectionCount();
  35 }
  36 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_AutofillContainer_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *self,void (*func)(Dali::Toolkit::AutofillContainer &)){
  37   self->Connect( func );
  38 }
  39 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_AutofillContainer_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *self,void (*func)(Dali::Toolkit::AutofillContainer &)){
  40   self->Disconnect( func );
  41 }
  42 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_AutofillContainer_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *self,Dali::Toolkit::AutofillContainer &arg){
  43   self->Emit( arg );
  44 }
  45
  46 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control &) > const *self){
  47   return self->Empty();
  48 }
  49 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SA__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control &) > const *self){
  50   return self->GetConnectionCount();
  51 }
  52 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SA__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control &) > *self,void (*func)(Dali::Toolkit::Control &)){
  53   self->Connect( func );
  54 }
  55 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SA__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control &) > *self,void (*func)(Dali::Toolkit::Control &)){
  56   self->Disconnect( func );
  57 }
  58 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SA__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control &) > *self,Dali::Toolkit::Control &arg){
  59   self->Emit( arg );
  60 }
  61
  62
  63 #ifdef __cplusplus
  64 extern "C" {
  65 #endif
  66
  67 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AutofillContainer_SWIGUpcast(Dali::Toolkit::AutofillContainer *jarg1) {
  68     return (Dali::BaseHandle *)jarg1;
  69 }
  70
  71 SWIGEXPORT void * SWIGSTDCALL CSharp_AutofillContainer_New(char * jarg1) {
  72   void * jresult;
  73   Dali::Toolkit::AutofillContainer result;
  74   std::string *arg1 = 0;
  75
  76   if(!jarg1){
  77       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
  78       return 0;
  79   }
  80
  81   std::string arg1_str(jarg1);
  82   arg1 = &arg1_str;
  83   {
  84     try {
  85       result = Dali::Toolkit::AutofillContainer::New((std::string const &)*arg1);
  86     } catch (std::out_of_range& e) {
  87       {
  88         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
  89       };
  90     } catch (std::exception& e) {
  91       {
  92         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
  93       };
  94     } catch (Dali::DaliException e) {
  95       {
  96         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
  97       };
  98     } catch (...) {
  99       {
 100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 101       };
 102     }
 103   }
 104
 105   jresult = new Dali::Toolkit::AutofillContainer((const Dali::Toolkit::AutofillContainer &)result);
 106   return jresult;
 107 }
 108
 109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AutofillContainer__SWIG_0() {
 110   void * jresult ;
 111   Dali::Toolkit::AutofillContainer *result = 0 ;
 112
 113   {
 114     try {
 115       result = (Dali::Toolkit::AutofillContainer *)new Dali::Toolkit::AutofillContainer();
 116     } catch (std::out_of_range& e) {
 117       {
 118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 119       };
 120     } catch (std::exception& e) {
 121       {
 122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 123       };
 124     } catch (Dali::DaliException e) {
 125       {
 126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 127       };
 128     } catch (...) {
 129       {
 130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 131       };
 132     }
 133   }
 134
 135   jresult = (void *)result;
 136   return jresult;
 137 }
 138
 139 // Copy constructor
 140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AutofillContainer__SWIG_1(void * jarg1) {
 141   void * jresult ;
 142   Dali::Toolkit::AutofillContainer *arg1 = 0 ;
 143   Dali::Toolkit::AutofillContainer *result = 0 ;
 144
 145   arg1 = (Dali::Toolkit::AutofillContainer *)jarg1;
 146   if (!arg1) {
 147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AutofillContainer const & type is null", 0);
 148     return 0;
 149   }
 150   {
 151     try {
 152       result = (Dali::Toolkit::AutofillContainer *)new Dali::Toolkit::AutofillContainer((Dali::Toolkit::AutofillContainer const &)*arg1);
 153     } catch (std::out_of_range& e) {
 154       {
 155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 156       };
 157     } catch (std::exception& e) {
 158       {
 159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 160       };
 161     } catch (Dali::DaliException e) {
 162       {
 163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 164       };
 165     } catch (...) {
 166       {
 167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 168       };
 169     }
 170   }
 171
 172   jresult = (void *)result;
 173   return jresult;
 174 }
 175
 176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AutofillContainer_Assign(void * jarg1, void * jarg2) {
 177   void * jresult ;
 178   Dali::Toolkit::AutofillContainer *arg1 = (Dali::Toolkit::AutofillContainer *) 0 ;
 179   Dali::Toolkit::AutofillContainer *arg2 = 0 ;
 180   Dali::Toolkit::AutofillContainer *result = 0 ;
 181
 182   arg1 = (Dali::Toolkit::AutofillContainer *)jarg1;
 183   arg2 = (Dali::Toolkit::AutofillContainer *)jarg2;
 184   if (!arg2) {
 185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AutofillContainer const & type is null", 0);
 186     return 0;
 187   }
 188   {
 189     try {
 190       result = (Dali::Toolkit::AutofillContainer *) &(arg1)->operator =((Dali::Toolkit::AutofillContainer const &)*arg2);
 191     } catch (std::out_of_range& e) {
 192       {
 193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 194       };
 195     } catch (std::exception& e) {
 196       {
 197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 198       };
 199     } catch (Dali::DaliException e) {
 200       {
 201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 202       };
 203     } catch (...) {
 204       {
 205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 206       };
 207     }
 208   }
 209
 210   jresult = (void *)result;
 211   return jresult;
 212 }
 213
 214
 215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AutofillContainer(void * jarg1) {
 216   Dali::Toolkit::AutofillContainer *arg1 = (Dali::Toolkit::AutofillContainer *) 0 ;
 217
 218   arg1 = (Dali::Toolkit::AutofillContainer *)jarg1;
 219   {
 220     try {
 221       delete arg1;
 222     } catch (std::out_of_range& e) {
 223       {
 224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 225       };
 226     } catch (std::exception& e) {
 227       {
 228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 229       };
 230     } catch (Dali::DaliException e) {
 231       {
 232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 233       };
 234     } catch (...) {
 235       {
 236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 237       };
 238     }
 239   }
 240
 241 }
 242
 243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AutofillContainer_DownCast(void * jarg1) {
 244   void * jresult ;
 245   Dali::BaseHandle arg1 ;
 246   Dali::BaseHandle *argp1 ;
 247   Dali::Toolkit::AutofillContainer result;
 248
 249   argp1 = (Dali::BaseHandle *)jarg1;
 250   if (!argp1) {
 251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
 252     return 0;
 253   }
 254   arg1 = *argp1;
 255   {
 256     try {
 257       result = Dali::Toolkit::AutofillContainer::DownCast(arg1);
 258     } catch (std::out_of_range& e) {
 259       {
 260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 261       };
 262     } catch (std::exception& e) {
 263       {
 264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 265       };
 266     } catch (Dali::DaliException e) {
 267       {
 268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 269       };
 270     } catch (...) {
 271       {
 272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 273       };
 274     }
 275   }
 276
 277   jresult = new Dali::Toolkit::AutofillContainer((const Dali::Toolkit::AutofillContainer &)result);
 278   return jresult;
 279 }
 280
 281 SWIGEXPORT void SWIGSTDCALL CSharp_AutofillContainer_AddAutofillItem(void * jarg1, void * jarg2, int jarg3, char * jarg4, char * jarg5, unsigned int jarg6, unsigned int jarg7) {
 282   Dali::Toolkit::AutofillContainer *arg1 = (Dali::Toolkit::AutofillContainer *) 0 ;
 283   Dali::Toolkit::Control arg2;
 284   Dali::Toolkit::Control *argp2 ;
 285   Dali::Property::Index arg3 = 0 ;
 286   std::string *arg4 = 0 ;
 287   std::string *arg5 = 0 ;
 288   Dali::AutofillItem::Hint arg6 ;
 289   bool arg7 ;
 290
 291   arg1 = (Dali::Toolkit::AutofillContainer *)jarg1;
 292   argp2 = (Dali::Toolkit::Control *)jarg2;
 293   if (!argp2) {
 294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
 295     return;
 296   }
 297   arg2 = *argp2;
 298   arg3 = (Dali::Property::Index)jarg3;
 299   std::string arg4_str(jarg4);
 300   arg4 = &arg4_str;
 301   std::string arg5_str(jarg5);
 302   arg5 = &arg5_str;
 303   arg6 = (Dali::AutofillItem::Hint)jarg6;
 304   arg7 = jarg7 ? true : false;
 305   {
 306     try {
 307       (arg1)->AddAutofillItem(arg2, arg3, (std::string const &)*arg4, (std::string const &)*arg5, (Dali::AutofillItem::Hint)arg6, arg7);
 308     } catch (std::out_of_range& e) {
 309       {
 310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
 311       };
 312     } catch (std::exception& e) {
 313       {
 314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
 315       };
 316     } catch (Dali::DaliException e) {
 317       {
 318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
 319       };
 320     } catch (...) {
 321       {
 322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
 323       };
 324     }
 325   }
 326
 327 }
 328
 329 SWIGEXPORT void SWIGSTDCALL CSharp_AutofillContainer_RemoveAutofillItem(void * jarg1, void * jarg2) {
 330   Dali::Toolkit::AutofillContainer *arg1 = (Dali::Toolkit::AutofillContainer *) 0 ;
 331   Dali::Toolkit::Control arg2;
 332   Dali::Toolkit::Control *argp2 ;
 333
 334   arg1 = (Dali::Toolkit::AutofillContainer *)jarg1;
 335   argp2 = (Dali::Toolkit::Control *)jarg2;
 336   if (!argp2) {
 337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
 338     return;
 339   }
 340   arg2 = *argp2;
 341   {
 342     try {
 343       (arg1)->RemoveAutofillItem(arg2);
 344     } catch (std::out_of_range& e) {
 345       {
 346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
 347       };
 348     } catch (std::exception& e) {
 349       {
 350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
 351       };
 352     } catch (Dali::DaliException e) {
 353       {
 354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
 355       };
 356     } catch (...) {
 357       {
 358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
 359       };
 360     }
 361   }
 362
 363 }
 364
 365 SWIGEXPORT void SWIGSTDCALL CSharp_AutofillContainer_SaveAutofillData(void * jarg1) {
 366   Dali::Toolkit::AutofillContainer *arg1 = (Dali::Toolkit::AutofillContainer *) 0 ;
 367
 368   arg1 = (Dali::Toolkit::AutofillContainer *)jarg1;
 369   {
 370     try {
 371       (arg1)->SaveAutofillData();
 372     } catch (std::out_of_range& e) {
 373       {
 374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
 375       };
 376     } catch (std::exception& e) {
 377       {
 378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
 379       };
 380     } catch (Dali::DaliException e) {
 381       {
 382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
 383       };
 384     } catch (...) {
 385       {
 386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
 387       };
 388     }
 389   }
 390 }
 391
 392 SWIGEXPORT void SWIGSTDCALL CSharp_AutofillContainer_RequestFillData(void * jarg1) {
 393   Dali::Toolkit::AutofillContainer *arg1 = (Dali::Toolkit::AutofillContainer *) 0 ;
 394
 395   arg1 = (Dali::Toolkit::AutofillContainer *)jarg1;
 396   {
 397     try {
 398       (arg1)->RequestFillData();
 399     } catch (std::out_of_range& e) {
 400       {
 401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
 402       };
 403     } catch (std::exception& e) {
 404       {
 405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
 406       };
 407     } catch (Dali::DaliException e) {
 408       {
 409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
 410       };
 411     } catch (...) {
 412       {
 413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
 414       };
 415     }
 416   }
 417 }
 418
 419
 420 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AutofillContainer_GetAutofillServiceName(void * jarg1) {
 421   char * jresult ;
 422   Dali::Toolkit::AutofillContainer *arg1 = (Dali::Toolkit::AutofillContainer *) 0 ;
 423   std::string *result = 0;
 424
 425   arg1 = (Dali::Toolkit::AutofillContainer *)jarg1;
 426   {
 427     try {
 428       result = (std::string *) &((Dali::Toolkit::AutofillContainer const *)arg1)->GetAutofillServiceName();
 429     } catch (std::out_of_range& e) {
 430       {
 431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 432       };
 433     } catch (std::exception& e) {
 434       {
 435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 436       };
 437     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
 438   jresult = SWIG_csharp_string_callback(result->c_str());
 439   return jresult;
 440 }
 441
 442 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AutofillContainer_GetAutofillServiceMessage(void * jarg1) {
 443   char * jresult ;
 444   Dali::Toolkit::AutofillContainer *arg1 = (Dali::Toolkit::AutofillContainer *) 0 ;
 445   std::string *result = 0;
 446
 447   arg1 = (Dali::Toolkit::AutofillContainer *)jarg1;
 448   {
 449     try {
 450       result = (std::string *) &((Dali::Toolkit::AutofillContainer const *)arg1)->GetAutofillServiceMessage();
 451     } catch (std::out_of_range& e) {
 452       {
 453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 454       };
 455     } catch (std::exception& e) {
 456       {
 457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 458       };
 459     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
 460   jresult = SWIG_csharp_string_callback(result->c_str());
 461   return jresult;
 462 }
 463
 464 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AutofillContainer_GetAutofillServiceImagePath(void * jarg1) {
 465   char * jresult ;
 466   Dali::Toolkit::AutofillContainer *arg1 = (Dali::Toolkit::AutofillContainer *) 0 ;
 467   std::string *result = 0;
 468
 469   arg1 = (Dali::Toolkit::AutofillContainer *)jarg1;
 470   {
 471     try {
 472       result = (std::string *) &((Dali::Toolkit::AutofillContainer const *)arg1)->GetAutofillServiceImagePath();
 473     } catch (std::out_of_range& e) {
 474       {
 475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 476       };
 477     } catch (std::exception& e) {
 478       {
 479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 480       };
 481     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
 482   jresult = SWIG_csharp_string_callback(result->c_str());
 483   return jresult;
 484 }
 485
 486
 487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AutofillContainer_GetListCount(void * jarg1) {
 488   unsigned int jresult ;
 489   Dali::Toolkit::AutofillContainer *arg1 = (Dali::Toolkit::AutofillContainer *) 0 ;
 490   unsigned int result;
 491
 492   arg1 = (Dali::Toolkit::AutofillContainer *)jarg1;
 493   {
 494     try {
 495       result = (arg1)->GetListCount();
 496     } catch (std::out_of_range& e) {
 497       {
 498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 499       };
 500     } catch (std::exception& e) {
 501       {
 502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 503       };
 504     } catch (...) {
 505       {
 506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 507       };
 508     }
 509   }
 510   jresult = result;
 511   return jresult;
 512 }
 513
 514
 515 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AutofillContainer_GetListItem(void * jarg1, unsigned int jarg2) {
 516   char * jresult ;
 517   Dali::Toolkit::AutofillContainer *arg1 = (Dali::Toolkit::AutofillContainer *) 0 ;
 518   unsigned int arg2 ;
 519   std::string *result = 0;
 520
 521   arg1 = (Dali::Toolkit::AutofillContainer *)jarg1;
 522   arg2 = (unsigned int)jarg2;
 523   {
 524     try {
 525       result = (std::string *) &((Dali::Toolkit::AutofillContainer const *)arg1)->GetListItem(arg2);
 526     } catch (std::out_of_range& e) {
 527       {
 528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 529       };
 530     } catch (std::exception& e) {
 531       {
 532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 533       };
 534     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
 535   jresult = SWIG_csharp_string_callback(result->c_str());
 536   return jresult;
 537 }
 538
 539
 540 SWIGEXPORT void SWIGSTDCALL CSharp_AutofillContainer_SetSelectedItem(void * jarg1, char * jarg2) {
 541   Dali::Toolkit::AutofillContainer *arg1 = (Dali::Toolkit::AutofillContainer *) 0 ;
 542   std::string *arg2 = 0 ;
 543
 544   arg1 = (Dali::Toolkit::AutofillContainer *)jarg1;
 545   if (!jarg2) {
 546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 547     return;
 548   }
 549   std::string arg2_str(jarg2);
 550   arg2 = &arg2_str;
 551   {
 552     try {
 553       (arg1)->SetSelectedItem((std::string const &)*arg2);
 554     } catch (std::out_of_range& e) {
 555       {
 556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
 557       };
 558     } catch (std::exception& e) {
 559       {
 560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
 561       };
 562     } catch (Dali::DaliException e) {
 563       {
 564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
 565       };
 566     } catch (...) {
 567       {
 568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
 569       };
 570     }
 571   }
 572
 573 }
 574
 575
 576 // Signals
 577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AutofillContainer_AutofillServiceShownSignal(void * jarg1) {
 578   void * jresult ;
 579   Dali::Toolkit::AutofillContainer *arg1 = (Dali::Toolkit::AutofillContainer *) 0 ;
 580   Dali::Toolkit::AutofillContainer::AuthenticationSignalType *result = 0 ;
 581
 582   arg1 = (Dali::Toolkit::AutofillContainer *)jarg1;
 583   {
 584     try {
 585       result = (Dali::Toolkit::AutofillContainer::AuthenticationSignalType *) &(arg1)->AutofillServiceShownSignal();
 586     } catch (std::out_of_range& e) {
 587       {
 588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 589       };
 590     } catch (std::exception& e) {
 591       {
 592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 593       };
 594     } catch (Dali::DaliException e) {
 595       {
 596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 597       };
 598     } catch (...) {
 599       {
 600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 601       };
 602     }
 603   }
 604
 605   jresult = (void *)result;
 606   return jresult;
 607 }
 608
 609
 610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AutofillContainer_AutofillListShownSignal(void * jarg1) {
 611   void * jresult ;
 612   Dali::Toolkit::AutofillContainer *arg1 = (Dali::Toolkit::AutofillContainer *) 0 ;
 613   Dali::Toolkit::AutofillContainer::ListShownSignalType *result = 0 ;
 614
 615   arg1 = (Dali::Toolkit::AutofillContainer *)jarg1;
 616   {
 617     try {
 618       result = (Dali::Toolkit::AutofillContainer::ListShownSignalType *) &(arg1)->AutofillListShownSignal();
 619     } catch (std::out_of_range& e) {
 620       {
 621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 622       };
 623     } catch (std::exception& e) {
 624       {
 625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 626       };
 627     } catch (Dali::DaliException e) {
 628       {
 629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 630       };
 631     } catch (...) {
 632       {
 633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 634       };
 635     }
 636   }
 637
 638   jresult = (void *)result;
 639   return jresult;
 640 }
 641
 642
 643 // AuthenticationSignalType
 644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AuthenticationSignalType_Empty(void * jarg1) {
 645   unsigned int jresult ;
 646   Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *) 0 ;
 647   bool result;
 648
 649   arg1 = (Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *)jarg1;
 650   {
 651     try {
 652       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_AutofillContainer_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > const *)arg1);
 653     } catch (std::out_of_range& e) {
 654       {
 655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 656       };
 657     } catch (std::exception& e) {
 658       {
 659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 660       };
 661     } catch (Dali::DaliException e) {
 662       {
 663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 664       };
 665     } catch (...) {
 666       {
 667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 668       };
 669     }
 670   }
 671
 672   jresult = result;
 673   return jresult;
 674 }
 675
 676
 677 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AuthenticationSignalType_GetConnectionCount(void * jarg1) {
 678   unsigned long jresult ;
 679   Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *) 0 ;
 680   std::size_t result;
 681
 682   arg1 = (Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *)jarg1;
 683   {
 684     try {
 685       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_AutofillContainer_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > const *)arg1);
 686     } catch (std::out_of_range& e) {
 687       {
 688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 689       };
 690     } catch (std::exception& e) {
 691       {
 692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 693       };
 694     } catch (Dali::DaliException e) {
 695       {
 696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 697       };
 698     } catch (...) {
 699       {
 700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 701       };
 702     }
 703   }
 704
 705   jresult = (unsigned long)result;
 706   return jresult;
 707 }
 708
 709
 710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AuthenticationSignalType_Connect(void * jarg1, void * jarg2) {
 711   Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *) 0 ;
 712   void (*arg2)(Dali::Toolkit::AutofillContainer &) = (void (*)(Dali::Toolkit::AutofillContainer &)) 0 ;
 713
 714   arg1 = (Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *)jarg1;
 715   arg2 = (void (*)(Dali::Toolkit::AutofillContainer &))jarg2;
 716   {
 717     try {
 718       Dali_Signal_Sl_void_Sp_Dali_Toolkit_AutofillContainer_SA__SP__Sg__Connect(arg1,arg2);
 719     } catch (std::out_of_range& e) {
 720       {
 721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 722       };
 723     } catch (std::exception& e) {
 724       {
 725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 726       };
 727     } catch (Dali::DaliException e) {
 728       {
 729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 730       };
 731     } catch (...) {
 732       {
 733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 734       };
 735     }
 736   }
 737
 738 }
 739
 740
 741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AuthenticationSignalType_Disconnect(void * jarg1, void * jarg2) {
 742   Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *) 0 ;
 743   void (*arg2)(Dali::Toolkit::AutofillContainer &) = (void (*)(Dali::Toolkit::AutofillContainer &)) 0 ;
 744
 745   arg1 = (Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *)jarg1;
 746   arg2 = (void (*)(Dali::Toolkit::AutofillContainer &))jarg2;
 747   {
 748     try {
 749       Dali_Signal_Sl_void_Sp_Dali_Toolkit_AutofillContainer_SA__SP__Sg__Disconnect(arg1,arg2);
 750     } catch (std::out_of_range& e) {
 751       {
 752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 753       };
 754     } catch (std::exception& e) {
 755       {
 756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 757       };
 758     } catch (Dali::DaliException e) {
 759       {
 760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 761       };
 762     } catch (...) {
 763       {
 764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 765       };
 766     }
 767   }
 768
 769 }
 770
 771
 772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AuthenticationSignalType_Emit(void * jarg1, void * jarg2) {
 773   Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *) 0 ;
 774   Dali::Toolkit::AutofillContainer *arg2 = 0;
 775
 776   arg1 = (Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *)jarg1;
 777   arg2 = (Dali::Toolkit::AutofillContainer *)jarg2;
 778   if(!arg2){
 779       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AutofillContainer & type is null", 0);
 780       return ;
 781   }
 782   {
 783     try {
 784       Dali_Signal_Sl_void_Sp_Dali_Toolkit_AutofillContainer_SA__SP__Sg__Emit(arg1,*arg2);
 785     } catch (std::out_of_range& e) {
 786       {
 787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 788       };
 789     } catch (std::exception& e) {
 790       {
 791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 792       };
 793     } catch (Dali::DaliException e) {
 794       {
 795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 796       };
 797     } catch (...) {
 798       {
 799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 800       };
 801     }
 802   }
 803
 804 }
 805
 806
 807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AuthenticationSignalType() {
 808   void * jresult ;
 809   Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *result = 0 ;
 810
 811   {
 812     try {
 813       result = (Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *)new Dali::Signal< void (Dali::Toolkit::AutofillContainer &) >();
 814     } catch (std::out_of_range& e) {
 815       {
 816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 817       };
 818     } catch (std::exception& e) {
 819       {
 820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 821       };
 822     } catch (Dali::DaliException e) {
 823       {
 824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 825       };
 826     } catch (...) {
 827       {
 828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 829       };
 830     }
 831   }
 832
 833   jresult = (void *)result;
 834   return jresult;
 835 }
 836
 837
 838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AuthenticationSignalType(void * jarg1) {
 839   Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *) 0 ;
 840
 841   arg1 = (Dali::Signal< void (Dali::Toolkit::AutofillContainer &) > *)jarg1;
 842   {
 843     try {
 844       delete arg1;
 845     } catch (std::out_of_range& e) {
 846       {
 847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 848       };
 849     } catch (std::exception& e) {
 850       {
 851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 852       };
 853     } catch (Dali::DaliException e) {
 854       {
 855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 856       };
 857     } catch (...) {
 858       {
 859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 860       };
 861     }
 862   }
 863
 864 }
 865
 866
 867 // ListShownSignalType
 868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ListShownSignalType_Empty(void * jarg1) {
 869   unsigned int jresult ;
 870   Dali::Signal< void (Dali::Toolkit::Control &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control &) > *) 0 ;
 871   bool result;
 872
 873   arg1 = (Dali::Signal< void (Dali::Toolkit::Control &) > *)jarg1;
 874   {
 875     try {
 876       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control &) > const *)arg1);
 877     } catch (std::out_of_range& e) {
 878       {
 879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 880       };
 881     } catch (std::exception& e) {
 882       {
 883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 884       };
 885     } catch (Dali::DaliException e) {
 886       {
 887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 888       };
 889     } catch (...) {
 890       {
 891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 892       };
 893     }
 894   }
 895
 896   jresult = result;
 897   return jresult;
 898 }
 899
 900
 901 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ListShownSignalType_GetConnectionCount(void * jarg1) {
 902   unsigned long jresult ;
 903   Dali::Signal< void (Dali::Toolkit::Control &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control &) > *) 0 ;
 904   std::size_t result;
 905
 906   arg1 = (Dali::Signal< void (Dali::Toolkit::Control &) > *)jarg1;
 907   {
 908     try {
 909       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SA__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control &) > const *)arg1);
 910     } catch (std::out_of_range& e) {
 911       {
 912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 913       };
 914     } catch (std::exception& e) {
 915       {
 916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 917       };
 918     } catch (Dali::DaliException e) {
 919       {
 920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 921       };
 922     } catch (...) {
 923       {
 924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 925       };
 926     }
 927   }
 928
 929   jresult = (unsigned long)result;
 930   return jresult;
 931 }
 932
 933
 934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ListShownSignalType_Connect(void * jarg1, void * jarg2) {
 935   Dali::Signal< void (Dali::Toolkit::Control &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control &) > *) 0 ;
 936   void (*arg2)(Dali::Toolkit::Control &) = (void (*)(Dali::Toolkit::Control &)) 0 ;
 937
 938   arg1 = (Dali::Signal< void (Dali::Toolkit::Control &) > *)jarg1;
 939   arg2 = (void (*)(Dali::Toolkit::Control &))jarg2;
 940   {
 941     try {
 942       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SA__Sg__Connect(arg1,arg2);
 943     } catch (std::out_of_range& e) {
 944       {
 945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 946       };
 947     } catch (std::exception& e) {
 948       {
 949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 950       };
 951     } catch (Dali::DaliException e) {
 952       {
 953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 954       };
 955     } catch (...) {
 956       {
 957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 958       };
 959     }
 960   }
 961
 962 }
 963
 964
 965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ListShownSignalType_Disconnect(void * jarg1, void * jarg2) {
 966   Dali::Signal< void (Dali::Toolkit::Control &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control &) > *) 0 ;
 967   void (*arg2)(Dali::Toolkit::Control &) = (void (*)(Dali::Toolkit::Control &)) 0 ;
 968
 969   arg1 = (Dali::Signal< void (Dali::Toolkit::Control &) > *)jarg1;
 970   arg2 = (void (*)(Dali::Toolkit::Control &))jarg2;
 971   {
 972     try {
 973       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SA__Sg__Disconnect(arg1,arg2);
 974     } catch (std::out_of_range& e) {
 975       {
 976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 977       };
 978     } catch (std::exception& e) {
 979       {
 980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 981       };
 982     } catch (Dali::DaliException e) {
 983       {
 984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 985       };
 986     } catch (...) {
 987       {
 988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 989       };
 990     }
 991   }
 992
 993 }
 994
 995
 996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ListShownSignalType_Emit(void * jarg1, void * jarg2) {
 997   Dali::Signal< void (Dali::Toolkit::Control &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control &) > *) 0 ;
 998   Dali::Toolkit::Control arg2 ;
 999   Dali::Toolkit::Control *argp2 ;
1000
1001   arg1 = (Dali::Signal< void (Dali::Toolkit::Control &) > *)jarg1;
1002   argp2 = (Dali::Toolkit::Control *)jarg2;
1003   if (!argp2) {
1004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
1005     return ;
1006   }
1007   arg2 = *argp2;
1008   {
1009     try {
1010       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SA__Sg__Emit(arg1,arg2);
1011     } catch (std::out_of_range& e) {
1012       {
1013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1014       };
1015     } catch (std::exception& e) {
1016       {
1017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1018       };
1019     } catch (Dali::DaliException e) {
1020       {
1021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1022       };
1023     } catch (...) {
1024       {
1025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1026       };
1027     }
1028   }
1029
1030 }
1031
1032
1033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ListShownSignalType() {
1034   void * jresult ;
1035   Dali::Signal< void (Dali::Toolkit::Control &) > *result = 0 ;
1036
1037   {
1038     try {
1039       result = (Dali::Signal< void (Dali::Toolkit::Control &g) > *)new Dali::Signal< void (Dali::Toolkit::Control &) >();
1040     } catch (std::out_of_range& e) {
1041       {
1042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1043       };
1044     } catch (std::exception& e) {
1045       {
1046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1047       };
1048     } catch (Dali::DaliException e) {
1049       {
1050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1051       };
1052     } catch (...) {
1053       {
1054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1055       };
1056     }
1057   }
1058
1059   jresult = (void *)result;
1060   return jresult;
1061 }
1062
1063
1064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ListShownSignalType(void * jarg1) {
1065   Dali::Signal< void (Dali::Toolkit::Control &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control &) > *) 0 ;
1066
1067   arg1 = (Dali::Signal< void (Dali::Toolkit::Control &) > *)jarg1;
1068   {
1069     try {
1070       delete arg1;
1071     } catch (std::out_of_range& e) {
1072       {
1073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1074       };
1075     } catch (std::exception& e) {
1076       {
1077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1078       };
1079     } catch (Dali::DaliException e) {
1080       {
1081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1082       };
1083     } catch (...) {
1084       {
1085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1086       };
1087     }
1088   }
1089
1090 }
1091
1092 #ifdef __cplusplus
1093 }
1094 #endif
1095