dali-csharp-binder/src/imf-manager.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_IMF_MANAGER
  18 #define CSHARP_IMF_MANAGER
  19 #endif
  20
  21 #include "common.h"
  22 #include <dali/devel-api/adaptor-framework/imf-manager.h>
  23
  24 /* Callback for returning strings to C# without leaking memory */
  25 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
  26 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
  27
  28
  29 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ImfManager_SA__SP__Sg__Empty(Dali::Signal< void (Dali::ImfManager &) > const *self){
  30          return self->Empty();
  31       }
  32 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ImfManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ImfManager &) > const *self){
  33         return self->GetConnectionCount();
  34       }
  35 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ImfManager_SA__SP__Sg__Connect(Dali::Signal< void (Dali::ImfManager &) > *self,void (*func)(Dali::ImfManager &)){
  36           self->Connect( func );
  37       }
  38 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ImfManager_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::ImfManager &) > *self,void (*func)(Dali::ImfManager &)){
  39           self->Disconnect( func );
  40       }
  41 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ImfManager_SA__SP__Sg__Emit(Dali::Signal< void (Dali::ImfManager &) > *self,Dali::ImfManager &arg){
  42           self->Emit( arg );
  43       }
  44 SWIGINTERN bool Dali_Signal_Sl_Dali_ImfManager_ImfCallbackData_Sp_Dali_ImfManager_SA__Sc_Dali_ImfManager_ImfEventData_SS_const_SA__SP__Sg__Empty(Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > const *self){
  45          return self->Empty();
  46       }
  47 SWIGINTERN std::size_t Dali_Signal_Sl_Dali_ImfManager_ImfCallbackData_Sp_Dali_ImfManager_SA__Sc_Dali_ImfManager_ImfEventData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > const *self){
  48         return self->GetConnectionCount();
  49       }
  50 SWIGINTERN void Dali_Signal_Sl_Dali_ImfManager_ImfCallbackData_Sp_Dali_ImfManager_SA__Sc_Dali_ImfManager_ImfEventData_SS_const_SA__SP__Sg__Connect(Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *self,Dali::ImfManager::ImfCallbackData (*func)(Dali::ImfManager &,Dali::ImfManager::ImfEventData const &)){
  51         self->Connect( func );
  52       }
  53 SWIGINTERN void Dali_Signal_Sl_Dali_ImfManager_ImfCallbackData_Sp_Dali_ImfManager_SA__Sc_Dali_ImfManager_ImfEventData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *self,Dali::ImfManager::ImfCallbackData (*func)(Dali::ImfManager &,Dali::ImfManager::ImfEventData const &)){
  54         self->Disconnect( func );
  55       }
  56 SWIGINTERN Dali::ImfManager::ImfCallbackData Dali_Signal_Sl_Dali_ImfManager_ImfCallbackData_Sp_Dali_ImfManager_SA__Sc_Dali_ImfManager_ImfEventData_SS_const_SA__SP__Sg__Emit(Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *self,Dali::ImfManager &arg1,Dali::ImfManager::ImfEventData const &arg2){
  57         return self->Emit( arg1, arg2 );
  58       }
  59 SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (bool) > const *self){
  60          return self->Empty();
  61       }
  62 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (bool) > const *self){
  63         return self->GetConnectionCount();
  64       }
  65 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
  66           self->Connect( func );
  67       }
  68 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
  69           self->Disconnect( func );
  70       }
  71 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (bool) > *self,bool arg){
  72           self->Emit( arg );
  73       }
  74 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ImfManager_KeyboardType_SP__Sg__Empty(Dali::Signal< void (Dali::ImfManager::KeyboardType) > const *self){
  75          return self->Empty();
  76       }
  77 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ImfManager_KeyboardType_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ImfManager::KeyboardType) > const *self){
  78         return self->GetConnectionCount();
  79       }
  80 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ImfManager_KeyboardType_SP__Sg__Connect(Dali::Signal< void (Dali::ImfManager::KeyboardType) > *self,void (*func)(Dali::ImfManager::KeyboardType)){
  81           self->Connect( func );
  82       }
  83 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ImfManager_KeyboardType_SP__Sg__Disconnect(Dali::Signal< void (Dali::ImfManager::KeyboardType) > *self,void (*func)(Dali::ImfManager::KeyboardType)){
  84           self->Disconnect( func );
  85       }
  86 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ImfManager_KeyboardType_SP__Sg__Emit(Dali::Signal< void (Dali::ImfManager::KeyboardType) > *self,Dali::ImfManager::KeyboardType arg){
  87           self->Emit( arg );
  88       }
  89
  90 #ifdef __cplusplus
  91 extern "C" {
  92 #endif
  93
  94 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_0() {
  95   void * jresult ;
  96   Dali::ImfManager::ImfEventData *result = 0 ;
  97
  98   {
  99     try {
 100       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData();
 101     } catch (std::out_of_range& e) {
 102       {
 103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 104       };
 105     } catch (std::exception& e) {
 106       {
 107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 108       };
 109     } catch (...) {
 110       {
 111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 112       };
 113     }
 114   }
 115   jresult = (void *)result;
 116   return jresult;
 117 }
 118
 119
 120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_1(int jarg1, char * jarg2, int jarg3, int jarg4) {
 121   void * jresult ;
 122   Dali::ImfManager::ImfEvent arg1 ;
 123   std::string *arg2 = 0 ;
 124   int arg3 ;
 125   int arg4 ;
 126   Dali::ImfManager::ImfEventData *result = 0 ;
 127
 128   arg1 = (Dali::ImfManager::ImfEvent)jarg1;
 129   if (!jarg2) {
 130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 131     return 0;
 132   }
 133   std::string arg2_str(jarg2);
 134   arg2 = &arg2_str;
 135   arg3 = (int)jarg3;
 136   arg4 = (int)jarg4;
 137   {
 138     try {
 139       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData(arg1,(std::string const &)*arg2,arg3,arg4);
 140     } catch (std::out_of_range& e) {
 141       {
 142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 143       };
 144     } catch (std::exception& e) {
 145       {
 146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 147       };
 148     } catch (...) {
 149       {
 150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 151       };
 152     }
 153   }
 154   jresult = (void *)result;
 155
 156   //argout typemap for const std::string&
 157
 158   return jresult;
 159 }
 160
 161
 162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_set(void * jarg1, char * jarg2) {
 163   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
 164   std::string *arg2 = 0 ;
 165
 166   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
 167   if (!jarg2) {
 168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 169     return ;
 170   }
 171   std::string arg2_str(jarg2);
 172   arg2 = &arg2_str;
 173   if (arg1) (arg1)->predictiveString = *arg2;
 174
 175   //argout typemap for const std::string&
 176
 177 }
 178
 179
 180 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_get(void * jarg1) {
 181   char * jresult ;
 182   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
 183   std::string *result = 0 ;
 184
 185   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
 186   result = (std::string *) & ((arg1)->predictiveString);
 187   jresult = SWIG_csharp_string_callback(result->c_str());
 188   return jresult;
 189 }
 190
 191
 192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_set(void * jarg1, int jarg2) {
 193   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
 194   Dali::ImfManager::ImfEvent arg2 ;
 195
 196   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
 197   arg2 = (Dali::ImfManager::ImfEvent)jarg2;
 198   if (arg1) (arg1)->eventName = arg2;
 199 }
 200
 201
 202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_get(void * jarg1) {
 203   int jresult ;
 204   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
 205   Dali::ImfManager::ImfEvent result;
 206
 207   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
 208   result = (Dali::ImfManager::ImfEvent) ((arg1)->eventName);
 209   jresult = (int)result;
 210   return jresult;
 211 }
 212
 213
 214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_set(void * jarg1, int jarg2) {
 215   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
 216   int arg2 ;
 217
 218   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
 219   arg2 = (int)jarg2;
 220   if (arg1) (arg1)->cursorOffset = arg2;
 221 }
 222
 223
 224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_get(void * jarg1) {
 225   int jresult ;
 226   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
 227   int result;
 228
 229   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
 230   result = (int) ((arg1)->cursorOffset);
 231   jresult = result;
 232   return jresult;
 233 }
 234
 235
 236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_set(void * jarg1, int jarg2) {
 237   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
 238   int arg2 ;
 239
 240   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
 241   arg2 = (int)jarg2;
 242   if (arg1) (arg1)->numberOfChars = arg2;
 243 }
 244
 245
 246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_get(void * jarg1) {
 247   int jresult ;
 248   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
 249   int result;
 250
 251   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
 252   result = (int) ((arg1)->numberOfChars);
 253   jresult = result;
 254   return jresult;
 255 }
 256
 257
 258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfEventData(void * jarg1) {
 259   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
 260
 261   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
 262   {
 263     try {
 264       delete arg1;
 265     } catch (std::out_of_range& e) {
 266       {
 267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 268       };
 269     } catch (std::exception& e) {
 270       {
 271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 272       };
 273     } catch (...) {
 274       {
 275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 276       };
 277     }
 278   }
 279 }
 280
 281
 282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_0() {
 283   void * jresult ;
 284   Dali::ImfManager::ImfCallbackData *result = 0 ;
 285
 286   {
 287     try {
 288       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData();
 289     } catch (std::out_of_range& e) {
 290       {
 291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 292       };
 293     } catch (std::exception& e) {
 294       {
 295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 296       };
 297     } catch (...) {
 298       {
 299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 300       };
 301     }
 302   }
 303   jresult = (void *)result;
 304   return jresult;
 305 }
 306
 307
 308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_1(unsigned int jarg1, int jarg2, char * jarg3, unsigned int jarg4) {
 309   void * jresult ;
 310   bool arg1 ;
 311   int arg2 ;
 312   std::string *arg3 = 0 ;
 313   bool arg4 ;
 314   Dali::ImfManager::ImfCallbackData *result = 0 ;
 315
 316   arg1 = jarg1 ? true : false;
 317   arg2 = (int)jarg2;
 318   if (!jarg3) {
 319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 320     return 0;
 321   }
 322   std::string arg3_str(jarg3);
 323   arg3 = &arg3_str;
 324   arg4 = jarg4 ? true : false;
 325   {
 326     try {
 327       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData(arg1,arg2,(std::string const &)*arg3,arg4);
 328     } catch (std::out_of_range& e) {
 329       {
 330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 331       };
 332     } catch (std::exception& e) {
 333       {
 334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 335       };
 336     } catch (...) {
 337       {
 338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 339       };
 340     }
 341   }
 342   jresult = (void *)result;
 343
 344   //argout typemap for const std::string&
 345
 346   return jresult;
 347 }
 348
 349
 350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_set(void * jarg1, char * jarg2) {
 351   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
 352   std::string *arg2 = 0 ;
 353
 354   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
 355   if (!jarg2) {
 356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 357     return ;
 358   }
 359   std::string arg2_str(jarg2);
 360   arg2 = &arg2_str;
 361   if (arg1) (arg1)->currentText = *arg2;
 362
 363   //argout typemap for const std::string&
 364
 365 }
 366
 367
 368 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_get(void * jarg1) {
 369   char * jresult ;
 370   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
 371   std::string *result = 0 ;
 372
 373   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
 374   result = (std::string *) & ((arg1)->currentText);
 375   jresult = SWIG_csharp_string_callback(result->c_str());
 376   return jresult;
 377 }
 378
 379
 380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_set(void * jarg1, int jarg2) {
 381   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
 382   int arg2 ;
 383
 384   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
 385   arg2 = (int)jarg2;
 386   if (arg1) (arg1)->cursorPosition = arg2;
 387 }
 388
 389
 390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_get(void * jarg1) {
 391   int jresult ;
 392   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
 393   int result;
 394
 395   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
 396   result = (int) ((arg1)->cursorPosition);
 397   jresult = result;
 398   return jresult;
 399 }
 400
 401
 402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_set(void * jarg1, unsigned int jarg2) {
 403   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
 404   bool arg2 ;
 405
 406   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
 407   arg2 = jarg2 ? true : false;
 408   if (arg1) (arg1)->update = arg2;
 409 }
 410
 411
 412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_get(void * jarg1) {
 413   unsigned int jresult ;
 414   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
 415   bool result;
 416
 417   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
 418   result = (bool) ((arg1)->update);
 419   jresult = result;
 420   return jresult;
 421 }
 422
 423
 424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_set(void * jarg1, unsigned int jarg2) {
 425   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
 426   bool arg2 ;
 427
 428   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
 429   arg2 = jarg2 ? true : false;
 430   if (arg1) (arg1)->preeditResetRequired = arg2;
 431 }
 432
 433
 434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_get(void * jarg1) {
 435   unsigned int jresult ;
 436   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
 437   bool result;
 438
 439   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
 440   result = (bool) ((arg1)->preeditResetRequired);
 441   jresult = result;
 442   return jresult;
 443 }
 444
 445
 446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfCallbackData(void * jarg1) {
 447   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
 448
 449   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
 450   {
 451     try {
 452       delete arg1;
 453     } catch (std::out_of_range& e) {
 454       {
 455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 456       };
 457     } catch (std::exception& e) {
 458       {
 459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 460       };
 461     } catch (...) {
 462       {
 463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 464       };
 465     }
 466   }
 467 }
 468
 469
 470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_Get() {
 471   void * jresult ;
 472   Dali::ImfManager result;
 473
 474   {
 475     try {
 476       result = Dali::ImfManager::Get();
 477     } catch (std::out_of_range& e) {
 478       {
 479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 480       };
 481     } catch (std::exception& e) {
 482       {
 483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 484       };
 485     } catch (...) {
 486       {
 487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 488       };
 489     }
 490   }
 491   jresult = new Dali::ImfManager((const Dali::ImfManager &)result);
 492   return jresult;
 493 }
 494
 495
 496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Activate(void * jarg1) {
 497   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 498
 499   arg1 = (Dali::ImfManager *)jarg1;
 500   {
 501     try {
 502       (arg1)->Activate();
 503     } catch (std::out_of_range& e) {
 504       {
 505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 506       };
 507     } catch (std::exception& e) {
 508       {
 509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 510       };
 511     } catch (...) {
 512       {
 513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 514       };
 515     }
 516   }
 517 }
 518
 519
 520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Deactivate(void * jarg1) {
 521   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 522
 523   arg1 = (Dali::ImfManager *)jarg1;
 524   {
 525     try {
 526       (arg1)->Deactivate();
 527     } catch (std::out_of_range& e) {
 528       {
 529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 530       };
 531     } catch (std::exception& e) {
 532       {
 533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 534       };
 535     } catch (...) {
 536       {
 537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 538       };
 539     }
 540   }
 541 }
 542
 543
 544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_RestoreAfterFocusLost(void * jarg1) {
 545   unsigned int jresult ;
 546   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 547   bool result;
 548
 549   arg1 = (Dali::ImfManager *)jarg1;
 550   {
 551     try {
 552       result = (bool)((Dali::ImfManager const *)arg1)->RestoreAfterFocusLost();
 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 (...) {
 562       {
 563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 564       };
 565     }
 566   }
 567   jresult = result;
 568   return jresult;
 569 }
 570
 571
 572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetRestoreAfterFocusLost(void * jarg1, unsigned int jarg2) {
 573   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 574   bool arg2 ;
 575
 576   arg1 = (Dali::ImfManager *)jarg1;
 577   arg2 = jarg2 ? true : false;
 578   {
 579     try {
 580       (arg1)->SetRestoreAfterFocusLost(arg2);
 581     } catch (std::out_of_range& e) {
 582       {
 583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 584       };
 585     } catch (std::exception& e) {
 586       {
 587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 588       };
 589     } catch (...) {
 590       {
 591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 592       };
 593     }
 594   }
 595 }
 596
 597
 598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Reset(void * jarg1) {
 599   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 600
 601   arg1 = (Dali::ImfManager *)jarg1;
 602   {
 603     try {
 604       (arg1)->Reset();
 605     } catch (std::out_of_range& e) {
 606       {
 607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 608       };
 609     } catch (std::exception& e) {
 610       {
 611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 612       };
 613     } catch (...) {
 614       {
 615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 616       };
 617     }
 618   }
 619 }
 620
 621
 622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyCursorPosition(void * jarg1) {
 623   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 624
 625   arg1 = (Dali::ImfManager *)jarg1;
 626   {
 627     try {
 628       (arg1)->NotifyCursorPosition();
 629     } catch (std::out_of_range& e) {
 630       {
 631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 632       };
 633     } catch (std::exception& e) {
 634       {
 635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 636       };
 637     } catch (...) {
 638       {
 639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 640       };
 641     }
 642   }
 643 }
 644
 645
 646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetCursorPosition(void * jarg1, unsigned int jarg2) {
 647   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 648   unsigned int arg2 ;
 649
 650   arg1 = (Dali::ImfManager *)jarg1;
 651   arg2 = (unsigned int)jarg2;
 652   {
 653     try {
 654       (arg1)->SetCursorPosition(arg2);
 655     } catch (std::out_of_range& e) {
 656       {
 657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 658       };
 659     } catch (std::exception& e) {
 660       {
 661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 662       };
 663     } catch (...) {
 664       {
 665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 666       };
 667     }
 668   }
 669 }
 670
 671
 672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_GetCursorPosition(void * jarg1) {
 673   unsigned int jresult ;
 674   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 675   unsigned int result;
 676
 677   arg1 = (Dali::ImfManager *)jarg1;
 678   {
 679     try {
 680       result = (unsigned int)((Dali::ImfManager const *)arg1)->GetCursorPosition();
 681     } catch (std::out_of_range& e) {
 682       {
 683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 684       };
 685     } catch (std::exception& e) {
 686       {
 687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 688       };
 689     } catch (...) {
 690       {
 691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 692       };
 693     }
 694   }
 695   jresult = result;
 696   return jresult;
 697 }
 698
 699
 700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetSurroundingText(void * jarg1, char * jarg2) {
 701   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 702   std::string *arg2 = 0 ;
 703
 704   arg1 = (Dali::ImfManager *)jarg1;
 705   if (!jarg2) {
 706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 707     return ;
 708   }
 709   std::string arg2_str(jarg2);
 710   arg2 = &arg2_str;
 711   {
 712     try {
 713       (arg1)->SetSurroundingText((std::string const &)*arg2);
 714     } catch (std::out_of_range& e) {
 715       {
 716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 717       };
 718     } catch (std::exception& e) {
 719       {
 720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 721       };
 722     } catch (...) {
 723       {
 724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 725       };
 726     }
 727   }
 728
 729   //argout typemap for const std::string&
 730
 731 }
 732
 733
 734 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_GetSurroundingText(void * jarg1) {
 735   char * jresult ;
 736   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 737   std::string *result = 0 ;
 738
 739   arg1 = (Dali::ImfManager *)jarg1;
 740   {
 741     try {
 742       result = (std::string *) &((Dali::ImfManager const *)arg1)->GetSurroundingText();
 743     } catch (std::out_of_range& e) {
 744       {
 745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 746       };
 747     } catch (std::exception& e) {
 748       {
 749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 750       };
 751     } catch (...) {
 752       {
 753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 754       };
 755     }
 756   }
 757   jresult = SWIG_csharp_string_callback(result->c_str());
 758   return jresult;
 759 }
 760
 761
 762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyTextInputMultiLine(void * jarg1, unsigned int jarg2) {
 763   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 764   bool arg2 ;
 765
 766   arg1 = (Dali::ImfManager *)jarg1;
 767   arg2 = jarg2 ? true : false;
 768   {
 769     try {
 770       (arg1)->NotifyTextInputMultiLine(arg2);
 771     } catch (std::out_of_range& e) {
 772       {
 773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 774       };
 775     } catch (std::exception& e) {
 776       {
 777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 778       };
 779     } catch (...) {
 780       {
 781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 782       };
 783     }
 784   }
 785 }
 786
 787
 788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetTextDirection(void * jarg1) {
 789   int jresult ;
 790   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 791   Dali::ImfManager::TextDirection result;
 792
 793   arg1 = (Dali::ImfManager *)jarg1;
 794   {
 795     try {
 796       result = (Dali::ImfManager::TextDirection)(arg1)->GetTextDirection();
 797     } catch (std::out_of_range& e) {
 798       {
 799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 800       };
 801     } catch (std::exception& e) {
 802       {
 803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 804       };
 805     } catch (...) {
 806       {
 807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 808       };
 809     }
 810   }
 811   jresult = (int)result;
 812   return jresult;
 813 }
 814
 815
 816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_GetInputMethodArea(void * jarg1) {
 817   void * jresult ;
 818   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 819   Dali::Rect< int > result;
 820
 821   arg1 = (Dali::ImfManager *)jarg1;
 822   {
 823     try {
 824       result = (arg1)->GetInputMethodArea();
 825     } catch (std::out_of_range& e) {
 826       {
 827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 828       };
 829     } catch (std::exception& e) {
 830       {
 831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 832       };
 833     } catch (...) {
 834       {
 835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 836       };
 837     }
 838   }
 839   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
 840   return jresult;
 841 }
 842
 843
 844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ApplyOptions(void * jarg1, void * jarg2) {
 845   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 846   Dali::InputMethodOptions *arg2 = 0 ;
 847
 848   arg1 = (Dali::ImfManager *)jarg1;
 849   arg2 = (Dali::InputMethodOptions *)jarg2;
 850   if (!arg2) {
 851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InputMethodOptions const & type is null", 0);
 852     return ;
 853   }
 854   {
 855     try {
 856       (arg1)->ApplyOptions((Dali::InputMethodOptions const &)*arg2);
 857     } catch (std::out_of_range& e) {
 858       {
 859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 860       };
 861     } catch (std::exception& e) {
 862       {
 863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 864       };
 865     } catch (...) {
 866       {
 867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 868       };
 869     }
 870   }
 871 }
 872
 873
 874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetInputPanelUserData(void * jarg1, char * jarg2) {
 875   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 876   std::string *arg2 = 0 ;
 877
 878   arg1 = (Dali::ImfManager *)jarg1;
 879   if (!jarg2) {
 880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 881     return ;
 882   }
 883   std::string arg2_str(jarg2);
 884   arg2 = &arg2_str;
 885   {
 886     try {
 887       (arg1)->SetInputPanelUserData((std::string const &)*arg2);
 888     } catch (std::out_of_range& e) {
 889       {
 890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 891       };
 892     } catch (std::exception& e) {
 893       {
 894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 895       };
 896     } catch (...) {
 897       {
 898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 899       };
 900     }
 901   }
 902
 903   //argout typemap for const std::string&
 904
 905 }
 906
 907
 908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelUserData(void * jarg1, char** jarg2) {
 909   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 910   std::string *arg2 = 0 ;
 911
 912   arg1 = (Dali::ImfManager *)jarg1;
 913
 914   //typemap in
 915   std::string temp;
 916   arg2 = &temp;
 917
 918   {
 919     try {
 920       (arg1)->GetInputPanelUserData(*arg2);
 921     } catch (std::out_of_range& e) {
 922       {
 923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 924       };
 925     } catch (std::exception& e) {
 926       {
 927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 928       };
 929     } catch (...) {
 930       {
 931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 932       };
 933     }
 934   }
 935
 936   //Typemap argout in c++ file.
 937   //This will convert c++ string to c# string
 938   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
 939
 940 }
 941
 942
 943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelState(void * jarg1) {
 944   int jresult ;
 945   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 946   Dali::ImfManager::State result;
 947
 948   arg1 = (Dali::ImfManager *)jarg1;
 949   {
 950     try {
 951       result = (Dali::ImfManager::State)(arg1)->GetInputPanelState();
 952     } catch (std::out_of_range& e) {
 953       {
 954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 955       };
 956     } catch (std::exception& e) {
 957       {
 958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 959       };
 960     } catch (...) {
 961       {
 962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 963       };
 964     }
 965   }
 966   jresult = (int)result;
 967   return jresult;
 968 }
 969
 970
 971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetReturnKeyState(void * jarg1, unsigned int jarg2) {
 972   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 973   bool arg2 ;
 974
 975   arg1 = (Dali::ImfManager *)jarg1;
 976   arg2 = jarg2 ? true : false;
 977   {
 978     try {
 979       (arg1)->SetReturnKeyState(arg2);
 980     } catch (std::out_of_range& e) {
 981       {
 982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 983       };
 984     } catch (std::exception& e) {
 985       {
 986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 987       };
 988     } catch (...) {
 989       {
 990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 991       };
 992     }
 993   }
 994 }
 995
 996
 997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_AutoEnableInputPanel(void * jarg1, unsigned int jarg2) {
 998   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
 999   bool arg2 ;
1000
1001   arg1 = (Dali::ImfManager *)jarg1;
1002   arg2 = jarg2 ? true : false;
1003   {
1004     try {
1005       (arg1)->AutoEnableInputPanel(arg2);
1006     } catch (std::out_of_range& e) {
1007       {
1008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1009       };
1010     } catch (std::exception& e) {
1011       {
1012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1013       };
1014     } catch (...) {
1015       {
1016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1017       };
1018     }
1019   }
1020 }
1021
1022
1023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ShowInputPanel(void * jarg1) {
1024   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
1025
1026   arg1 = (Dali::ImfManager *)jarg1;
1027   {
1028     try {
1029       (arg1)->ShowInputPanel();
1030     } catch (std::out_of_range& e) {
1031       {
1032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1033       };
1034     } catch (std::exception& e) {
1035       {
1036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1037       };
1038     } catch (...) {
1039       {
1040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1041       };
1042     }
1043   }
1044 }
1045
1046
1047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_HideInputPanel(void * jarg1) {
1048   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
1049
1050   arg1 = (Dali::ImfManager *)jarg1;
1051   {
1052     try {
1053       (arg1)->HideInputPanel();
1054     } catch (std::out_of_range& e) {
1055       {
1056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1057       };
1058     } catch (std::exception& e) {
1059       {
1060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1061       };
1062     } catch (...) {
1063       {
1064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1065       };
1066     }
1067   }
1068 }
1069
1070
1071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetKeyboardType(void * jarg1) {
1072   int jresult ;
1073   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
1074   Dali::ImfManager::KeyboardType result;
1075
1076   arg1 = (Dali::ImfManager *)jarg1;
1077   {
1078     try {
1079       result = (Dali::ImfManager::KeyboardType)(arg1)->GetKeyboardType();
1080     } catch (std::out_of_range& e) {
1081       {
1082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1083       };
1084     } catch (std::exception& e) {
1085       {
1086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1087       };
1088     } catch (...) {
1089       {
1090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1091       };
1092     }
1093   }
1094   jresult = (int)result;
1095   return jresult;
1096 }
1097
1098
1099 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelLocale(void * jarg1) {
1100   char * jresult ;
1101   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
1102   std::string result;
1103
1104   arg1 = (Dali::ImfManager *)jarg1;
1105   {
1106     try {
1107       result = (arg1)->GetInputPanelLocale();
1108     } catch (std::out_of_range& e) {
1109       {
1110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1111       };
1112     } catch (std::exception& e) {
1113       {
1114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1115       };
1116     } catch (...) {
1117       {
1118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1119       };
1120     }
1121   }
1122   jresult = SWIG_csharp_string_callback((&result)->c_str());
1123   return jresult;
1124 }
1125
1126
1127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ActivatedSignal(void * jarg1) {
1128   void * jresult ;
1129   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
1130   Dali::ImfManager::ImfManagerSignalType *result = 0 ;
1131
1132   arg1 = (Dali::ImfManager *)jarg1;
1133   {
1134     try {
1135       result = (Dali::ImfManager::ImfManagerSignalType *) &(arg1)->ActivatedSignal();
1136     } catch (std::out_of_range& e) {
1137       {
1138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1139       };
1140     } catch (std::exception& e) {
1141       {
1142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1143       };
1144     } catch (...) {
1145       {
1146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1147       };
1148     }
1149   }
1150   jresult = (void *)result;
1151   return jresult;
1152 }
1153
1154
1155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_EventReceivedSignal(void * jarg1) {
1156   void * jresult ;
1157   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
1158   Dali::ImfManager::ImfEventSignalType *result = 0 ;
1159
1160   arg1 = (Dali::ImfManager *)jarg1;
1161   {
1162     try {
1163       result = (Dali::ImfManager::ImfEventSignalType *) &(arg1)->EventReceivedSignal();
1164     } catch (std::out_of_range& e) {
1165       {
1166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1167       };
1168     } catch (std::exception& e) {
1169       {
1170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1171       };
1172     } catch (...) {
1173       {
1174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1175       };
1176     }
1177   }
1178   jresult = (void *)result;
1179   return jresult;
1180 }
1181
1182
1183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_StatusChangedSignal(void * jarg1) {
1184   void * jresult ;
1185   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
1186   Dali::ImfManager::StatusSignalType *result = 0 ;
1187
1188   arg1 = (Dali::ImfManager *)jarg1;
1189   {
1190     try {
1191       result = (Dali::ImfManager::StatusSignalType *) &(arg1)->StatusChangedSignal();
1192     } catch (std::out_of_range& e) {
1193       {
1194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1195       };
1196     } catch (std::exception& e) {
1197       {
1198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1199       };
1200     } catch (...) {
1201       {
1202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1203       };
1204     }
1205   }
1206   jresult = (void *)result;
1207   return jresult;
1208 }
1209
1210
1211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ResizedSignal(void * jarg1) {
1212   void * jresult ;
1213   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
1214   Dali::ImfManager::VoidSignalType *result = 0 ;
1215
1216   arg1 = (Dali::ImfManager *)jarg1;
1217   {
1218     try {
1219       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->ResizedSignal();
1220     } catch (std::out_of_range& e) {
1221       {
1222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1223       };
1224     } catch (std::exception& e) {
1225       {
1226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1227       };
1228     } catch (...) {
1229       {
1230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1231       };
1232     }
1233   }
1234   jresult = (void *)result;
1235   return jresult;
1236 }
1237
1238
1239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_LanguageChangedSignal(void * jarg1) {
1240   void * jresult ;
1241   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
1242   Dali::ImfManager::VoidSignalType *result = 0 ;
1243
1244   arg1 = (Dali::ImfManager *)jarg1;
1245   {
1246     try {
1247       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->LanguageChangedSignal();
1248     } catch (std::out_of_range& e) {
1249       {
1250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1251       };
1252     } catch (std::exception& e) {
1253       {
1254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1255       };
1256     } catch (...) {
1257       {
1258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1259       };
1260     }
1261   }
1262   jresult = (void *)result;
1263   return jresult;
1264 }
1265
1266
1267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_KeyboardTypeChangedSignal(void * jarg1) {
1268   void * jresult ;
1269   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
1270   Dali::ImfManager::KeyboardTypeSignalType *result = 0 ;
1271
1272   arg1 = (Dali::ImfManager *)jarg1;
1273   {
1274     try {
1275       result = (Dali::ImfManager::KeyboardTypeSignalType *) &(arg1)->KeyboardTypeChangedSignal();
1276     } catch (std::out_of_range& e) {
1277       {
1278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1279       };
1280     } catch (std::exception& e) {
1281       {
1282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1283       };
1284     } catch (...) {
1285       {
1286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1287       };
1288     }
1289   }
1290   jresult = (void *)result;
1291   return jresult;
1292 }
1293
1294
1295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager() {
1296   void * jresult ;
1297   Dali::ImfManager *result = 0 ;
1298
1299   {
1300     try {
1301       result = (Dali::ImfManager *)new Dali::ImfManager();
1302     } catch (std::out_of_range& e) {
1303       {
1304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1305       };
1306     } catch (std::exception& e) {
1307       {
1308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1309       };
1310     } catch (...) {
1311       {
1312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1313       };
1314     }
1315   }
1316   jresult = (void *)result;
1317   return jresult;
1318 }
1319
1320
1321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager(void * jarg1) {
1322   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
1323
1324   arg1 = (Dali::ImfManager *)jarg1;
1325   {
1326     try {
1327       delete arg1;
1328     } catch (std::out_of_range& e) {
1329       {
1330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1331       };
1332     } catch (std::exception& e) {
1333       {
1334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1335       };
1336     } catch (...) {
1337       {
1338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1339       };
1340     }
1341   }
1342 }
1343
1344
1345
1346 // ActivatedSignalType
1347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Empty(void * jarg1) {
1348   unsigned int jresult ;
1349   Dali::Signal< void (Dali::ImfManager &) > *arg1 = (Dali::Signal< void (Dali::ImfManager &) > *) 0 ;
1350   bool result;
1351
1352   arg1 = (Dali::Signal< void (Dali::ImfManager &) > *)jarg1;
1353   {
1354     try {
1355       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ImfManager_SA__SP__Sg__Empty((Dali::Signal< void (Dali::ImfManager &) > const *)arg1);
1356     } catch (std::out_of_range& e) {
1357       {
1358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1359       };
1360     } catch (std::exception& e) {
1361       {
1362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1363       };
1364     } catch (...) {
1365       {
1366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1367       };
1368     }
1369   }
1370   jresult = result;
1371   return jresult;
1372 }
1373
1374
1375 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActivatedSignalType_GetConnectionCount(void * jarg1) {
1376   unsigned long jresult ;
1377   Dali::Signal< void (Dali::ImfManager &) > *arg1 = (Dali::Signal< void (Dali::ImfManager &) > *) 0 ;
1378   std::size_t result;
1379
1380   arg1 = (Dali::Signal< void (Dali::ImfManager &) > *)jarg1;
1381   {
1382     try {
1383       result = Dali_Signal_Sl_void_Sp_Dali_ImfManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ImfManager &) > const *)arg1);
1384     } catch (std::out_of_range& e) {
1385       {
1386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1387       };
1388     } catch (std::exception& e) {
1389       {
1390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1391       };
1392     } catch (...) {
1393       {
1394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1395       };
1396     }
1397   }
1398   jresult = (unsigned long)result;
1399   return jresult;
1400 }
1401
1402
1403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Connect(void * jarg1, void * jarg2) {
1404   Dali::Signal< void (Dali::ImfManager &) > *arg1 = (Dali::Signal< void (Dali::ImfManager &) > *) 0 ;
1405   void (*arg2)(Dali::ImfManager &) = (void (*)(Dali::ImfManager &)) 0 ;
1406
1407   arg1 = (Dali::Signal< void (Dali::ImfManager &) > *)jarg1;
1408   arg2 = (void (*)(Dali::ImfManager &))jarg2;
1409   {
1410     try {
1411       Dali_Signal_Sl_void_Sp_Dali_ImfManager_SA__SP__Sg__Connect(arg1,arg2);
1412     } catch (std::out_of_range& e) {
1413       {
1414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1415       };
1416     } catch (std::exception& e) {
1417       {
1418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1419       };
1420     } catch (...) {
1421       {
1422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1423       };
1424     }
1425   }
1426 }
1427
1428
1429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Disconnect(void * jarg1, void * jarg2) {
1430   Dali::Signal< void (Dali::ImfManager &) > *arg1 = (Dali::Signal< void (Dali::ImfManager &) > *) 0 ;
1431   void (*arg2)(Dali::ImfManager &) = (void (*)(Dali::ImfManager &)) 0 ;
1432
1433   arg1 = (Dali::Signal< void (Dali::ImfManager &) > *)jarg1;
1434   arg2 = (void (*)(Dali::ImfManager &))jarg2;
1435   {
1436     try {
1437       Dali_Signal_Sl_void_Sp_Dali_ImfManager_SA__SP__Sg__Disconnect(arg1,arg2);
1438     } catch (std::out_of_range& e) {
1439       {
1440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1441       };
1442     } catch (std::exception& e) {
1443       {
1444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1445       };
1446     } catch (...) {
1447       {
1448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1449       };
1450     }
1451   }
1452 }
1453
1454
1455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Emit(void * jarg1, void * jarg2) {
1456   Dali::Signal< void (Dali::ImfManager &) > *arg1 = (Dali::Signal< void (Dali::ImfManager &) > *) 0 ;
1457   Dali::ImfManager *arg2 = 0 ;
1458
1459   arg1 = (Dali::Signal< void (Dali::ImfManager &) > *)jarg1;
1460   arg2 = (Dali::ImfManager *)jarg2;
1461   if (!arg2) {
1462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ImfManager & type is null", 0);
1463     return ;
1464   }
1465   {
1466     try {
1467       Dali_Signal_Sl_void_Sp_Dali_ImfManager_SA__SP__Sg__Emit(arg1,*arg2);
1468     } catch (std::out_of_range& e) {
1469       {
1470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1471       };
1472     } catch (std::exception& e) {
1473       {
1474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1475       };
1476     } catch (...) {
1477       {
1478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1479       };
1480     }
1481   }
1482 }
1483
1484
1485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActivatedSignalType() {
1486   void * jresult ;
1487   Dali::Signal< void (Dali::ImfManager &) > *result = 0 ;
1488
1489   {
1490     try {
1491       result = (Dali::Signal< void (Dali::ImfManager &) > *)new Dali::Signal< void (Dali::ImfManager &) >();
1492     } catch (std::out_of_range& e) {
1493       {
1494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1495       };
1496     } catch (std::exception& e) {
1497       {
1498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1499       };
1500     } catch (...) {
1501       {
1502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1503       };
1504     }
1505   }
1506   jresult = (void *)result;
1507   return jresult;
1508 }
1509
1510
1511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActivatedSignalType(void * jarg1) {
1512   Dali::Signal< void (Dali::ImfManager &) > *arg1 = (Dali::Signal< void (Dali::ImfManager &) > *) 0 ;
1513
1514   arg1 = (Dali::Signal< void (Dali::ImfManager &) > *)jarg1;
1515   {
1516     try {
1517       delete arg1;
1518     } catch (std::out_of_range& e) {
1519       {
1520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1521       };
1522     } catch (std::exception& e) {
1523       {
1524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1525       };
1526     } catch (...) {
1527       {
1528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1529       };
1530     }
1531   }
1532 }
1533
1534 // ImfEventSignalType
1535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfEventSignalType_Empty(void * jarg1) {
1536   unsigned int jresult ;
1537   Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *arg1 = (Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *) 0 ;
1538   bool result;
1539
1540   arg1 = (Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *)jarg1;
1541   {
1542     try {
1543       result = (bool)Dali_Signal_Sl_Dali_ImfManager_ImfCallbackData_Sp_Dali_ImfManager_SA__Sc_Dali_ImfManager_ImfEventData_SS_const_SA__SP__Sg__Empty((Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > const *)arg1);
1544     } catch (std::out_of_range& e) {
1545       {
1546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1547       };
1548     } catch (std::exception& e) {
1549       {
1550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1551       };
1552     } catch (...) {
1553       {
1554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1555       };
1556     }
1557   }
1558   jresult = result;
1559   return jresult;
1560 }
1561
1562
1563 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImfEventSignalType_GetConnectionCount(void * jarg1) {
1564   unsigned long jresult ;
1565   Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *arg1 = (Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *) 0 ;
1566   std::size_t result;
1567
1568   arg1 = (Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *)jarg1;
1569   {
1570     try {
1571       result = Dali_Signal_Sl_Dali_ImfManager_ImfCallbackData_Sp_Dali_ImfManager_SA__Sc_Dali_ImfManager_ImfEventData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > const *)arg1);
1572     } catch (std::out_of_range& e) {
1573       {
1574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1575       };
1576     } catch (std::exception& e) {
1577       {
1578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1579       };
1580     } catch (...) {
1581       {
1582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1583       };
1584     }
1585   }
1586   jresult = (unsigned long)result;
1587   return jresult;
1588 }
1589
1590
1591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfEventSignalType_Connect(void * jarg1, void * jarg2) {
1592   Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *arg1 = (Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *) 0 ;
1593   Dali::ImfManager::ImfCallbackData (*arg2)(Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) = (Dali::ImfManager::ImfCallbackData (*)(Dali::ImfManager &,Dali::ImfManager::ImfEventData const &)) 0 ;
1594
1595   arg1 = (Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *)jarg1;
1596   arg2 = (Dali::ImfManager::ImfCallbackData (*)(Dali::ImfManager &,Dali::ImfManager::ImfEventData const &))jarg2;
1597   {
1598     try {
1599       Dali_Signal_Sl_Dali_ImfManager_ImfCallbackData_Sp_Dali_ImfManager_SA__Sc_Dali_ImfManager_ImfEventData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
1600     } catch (std::out_of_range& e) {
1601       {
1602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1603       };
1604     } catch (std::exception& e) {
1605       {
1606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1607       };
1608     } catch (...) {
1609       {
1610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1611       };
1612     }
1613   }
1614 }
1615
1616
1617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfEventSignalType_Disconnect(void * jarg1, void * jarg2) {
1618   Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *arg1 = (Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *) 0 ;
1619   Dali::ImfManager::ImfCallbackData (*arg2)(Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) = (Dali::ImfManager::ImfCallbackData (*)(Dali::ImfManager &,Dali::ImfManager::ImfEventData const &)) 0 ;
1620
1621   arg1 = (Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *)jarg1;
1622   arg2 = (Dali::ImfManager::ImfCallbackData (*)(Dali::ImfManager &,Dali::ImfManager::ImfEventData const &))jarg2;
1623   {
1624     try {
1625       Dali_Signal_Sl_Dali_ImfManager_ImfCallbackData_Sp_Dali_ImfManager_SA__Sc_Dali_ImfManager_ImfEventData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
1626     } catch (std::out_of_range& e) {
1627       {
1628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1629       };
1630     } catch (std::exception& e) {
1631       {
1632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1633       };
1634     } catch (...) {
1635       {
1636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1637       };
1638     }
1639   }
1640 }
1641
1642
1643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfEventSignalType_Emit(void * jarg1, void * jarg2, void * jarg3) {
1644   void * jresult ;
1645   Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *arg1 = (Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *) 0 ;
1646   Dali::ImfManager *arg2 = 0 ;
1647   Dali::ImfManager::ImfEventData *arg3 = 0 ;
1648   Dali::ImfManager::ImfCallbackData result;
1649
1650   arg1 = (Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *)jarg1;
1651   arg2 = (Dali::ImfManager *)jarg2;
1652   if (!arg2) {
1653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ImfManager & type is null", 0);
1654     return 0;
1655   }
1656   arg3 = (Dali::ImfManager::ImfEventData *)jarg3;
1657   if (!arg3) {
1658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ImfManager::ImfEventData const & type is null", 0);
1659     return 0;
1660   }
1661   {
1662     try {
1663       result = Dali_Signal_Sl_Dali_ImfManager_ImfCallbackData_Sp_Dali_ImfManager_SA__Sc_Dali_ImfManager_ImfEventData_SS_const_SA__SP__Sg__Emit(arg1,*arg2,(Dali::ImfManager::ImfEventData const &)*arg3);
1664     } catch (std::out_of_range& e) {
1665       {
1666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1667       };
1668     } catch (std::exception& e) {
1669       {
1670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1671       };
1672     } catch (...) {
1673       {
1674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1675       };
1676     }
1677   }
1678   jresult = new Dali::ImfManager::ImfCallbackData((const Dali::ImfManager::ImfCallbackData &)result);
1679   return jresult;
1680 }
1681
1682
1683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfEventSignalType() {
1684   void * jresult ;
1685   Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *result = 0 ;
1686
1687   {
1688     try {
1689       result = (Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *)new Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) >();
1690     } catch (std::out_of_range& e) {
1691       {
1692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1693       };
1694     } catch (std::exception& e) {
1695       {
1696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1697       };
1698     } catch (...) {
1699       {
1700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1701       };
1702     }
1703   }
1704   jresult = (void *)result;
1705   return jresult;
1706 }
1707
1708
1709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfEventSignalType(void * jarg1) {
1710   Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *arg1 = (Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *) 0 ;
1711
1712   arg1 = (Dali::Signal< Dali::ImfManager::ImfCallbackData (Dali::ImfManager &,Dali::ImfManager::ImfEventData const &) > *)jarg1;
1713   {
1714     try {
1715       delete arg1;
1716     } catch (std::out_of_range& e) {
1717       {
1718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1719       };
1720     } catch (std::exception& e) {
1721       {
1722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1723       };
1724     } catch (...) {
1725       {
1726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1727       };
1728     }
1729   }
1730 }
1731
1732
1733 // ImfVoidSignalType
1734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfVoidSignalType() {
1735   void * jresult ;
1736   Dali::Signal< void () > *result = 0 ;
1737
1738   {
1739     try {
1740       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
1741     } catch (std::out_of_range& e) {
1742       {
1743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1744       };
1745     } catch (std::exception& e) {
1746       {
1747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1748       };
1749     } catch (...) {
1750       {
1751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1752       };
1753     }
1754   }
1755   jresult = (void *)result;
1756   return jresult;
1757 }
1758
1759
1760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfVoidSignalType(void * jarg1) {
1761   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1762
1763   arg1 = (Dali::Signal< void () > *)jarg1;
1764   {
1765     try {
1766       delete arg1;
1767     } catch (std::out_of_range& e) {
1768       {
1769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1770       };
1771     } catch (std::exception& e) {
1772       {
1773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1774       };
1775     } catch (...) {
1776       {
1777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1778       };
1779     }
1780   }
1781 }
1782
1783
1784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfVoidSignalType_Empty(void * jarg1) {
1785   unsigned int jresult ;
1786   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1787   bool result;
1788
1789   arg1 = (Dali::Signal< void () > *)jarg1;
1790   {
1791     try {
1792       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
1793     } catch (std::out_of_range& e) {
1794       {
1795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1796       };
1797     } catch (std::exception& e) {
1798       {
1799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1800       };
1801     } catch (...) {
1802       {
1803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1804       };
1805     }
1806   }
1807   jresult = result;
1808   return jresult;
1809 }
1810
1811
1812 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImfVoidSignalType_GetConnectionCount(void * jarg1) {
1813   unsigned long jresult ;
1814   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1815   std::size_t result;
1816
1817   arg1 = (Dali::Signal< void () > *)jarg1;
1818   {
1819     try {
1820       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
1821     } catch (std::out_of_range& e) {
1822       {
1823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1824       };
1825     } catch (std::exception& e) {
1826       {
1827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1828       };
1829     } catch (...) {
1830       {
1831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1832       };
1833     }
1834   }
1835   jresult = (unsigned long)result;
1836   return jresult;
1837 }
1838
1839
1840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfVoidSignalType_Connect__SWIG_0(void * jarg1, void * jarg2) {
1841   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1842   void (*arg2)() = (void (*)()) 0 ;
1843
1844   arg1 = (Dali::Signal< void () > *)jarg1;
1845   arg2 = (void (*)())jarg2;
1846   {
1847     try {
1848       (arg1)->Connect(arg2);
1849     } catch (std::out_of_range& e) {
1850       {
1851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1852       };
1853     } catch (std::exception& e) {
1854       {
1855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1856       };
1857     } catch (...) {
1858       {
1859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1860       };
1861     }
1862   }
1863 }
1864
1865
1866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfVoidSignalType_Disconnect(void * jarg1, void * jarg2) {
1867   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1868   void (*arg2)() = (void (*)()) 0 ;
1869
1870   arg1 = (Dali::Signal< void () > *)jarg1;
1871   arg2 = (void (*)())jarg2;
1872   {
1873     try {
1874       (arg1)->Disconnect(arg2);
1875     } catch (std::out_of_range& e) {
1876       {
1877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1878       };
1879     } catch (std::exception& e) {
1880       {
1881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1882       };
1883     } catch (...) {
1884       {
1885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1886       };
1887     }
1888   }
1889 }
1890
1891
1892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfVoidSignalType_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
1893   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1894   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
1895   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
1896
1897   arg1 = (Dali::Signal< void () > *)jarg1;
1898   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
1899   arg3 = (Dali::FunctorDelegate *)jarg3;
1900   {
1901     try {
1902       (arg1)->Connect(arg2,arg3);
1903     } catch (std::out_of_range& e) {
1904       {
1905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1906       };
1907     } catch (std::exception& e) {
1908       {
1909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1910       };
1911     } catch (...) {
1912       {
1913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1914       };
1915     }
1916   }
1917 }
1918
1919
1920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfVoidSignalType_Emit(void * jarg1) {
1921   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1922
1923   arg1 = (Dali::Signal< void () > *)jarg1;
1924   {
1925     try {
1926       (arg1)->Emit();
1927     } catch (std::out_of_range& e) {
1928       {
1929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1930       };
1931     } catch (std::exception& e) {
1932       {
1933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1934       };
1935     } catch (...) {
1936       {
1937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1938       };
1939     }
1940   }
1941 }
1942
1943 //StatusSignalType
1944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StatusSignalType_Empty(void * jarg1) {
1945   unsigned int jresult ;
1946   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1947   bool result;
1948
1949   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1950   {
1951     try {
1952       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
1953     } catch (std::out_of_range& e) {
1954       {
1955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1956       };
1957     } catch (std::exception& e) {
1958       {
1959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1960       };
1961     } catch (...) {
1962       {
1963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1964       };
1965     }
1966   }
1967   jresult = result;
1968   return jresult;
1969 }
1970
1971
1972 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StatusSignalType_GetConnectionCount(void * jarg1) {
1973   unsigned long jresult ;
1974   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1975   std::size_t result;
1976
1977   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1978   {
1979     try {
1980       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
1981     } catch (std::out_of_range& e) {
1982       {
1983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1984       };
1985     } catch (std::exception& e) {
1986       {
1987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1988       };
1989     } catch (...) {
1990       {
1991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1992       };
1993     }
1994   }
1995   jresult = (unsigned long)result;
1996   return jresult;
1997 }
1998
1999
2000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Connect(void * jarg1, void * jarg2) {
2001   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
2002   void (*arg2)(bool) = (void (*)(bool)) 0 ;
2003
2004   arg1 = (Dali::Signal< void (bool) > *)jarg1;
2005   arg2 = (void (*)(bool))jarg2;
2006   {
2007     try {
2008       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
2009     } catch (std::out_of_range& e) {
2010       {
2011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2012       };
2013     } catch (std::exception& e) {
2014       {
2015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2016       };
2017     } catch (...) {
2018       {
2019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2020       };
2021     }
2022   }
2023 }
2024
2025
2026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Disconnect(void * jarg1, void * jarg2) {
2027   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
2028   void (*arg2)(bool) = (void (*)(bool)) 0 ;
2029
2030   arg1 = (Dali::Signal< void (bool) > *)jarg1;
2031   arg2 = (void (*)(bool))jarg2;
2032   {
2033     try {
2034       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
2035     } catch (std::out_of_range& e) {
2036       {
2037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2038       };
2039     } catch (std::exception& e) {
2040       {
2041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2042       };
2043     } catch (...) {
2044       {
2045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2046       };
2047     }
2048   }
2049 }
2050
2051
2052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Emit(void * jarg1, unsigned int jarg2) {
2053   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
2054   bool arg2 ;
2055
2056   arg1 = (Dali::Signal< void (bool) > *)jarg1;
2057   arg2 = jarg2 ? true : false;
2058   {
2059     try {
2060       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
2061     } catch (std::out_of_range& e) {
2062       {
2063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2064       };
2065     } catch (std::exception& e) {
2066       {
2067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2068       };
2069     } catch (...) {
2070       {
2071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2072       };
2073     }
2074   }
2075 }
2076
2077
2078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StatusSignalType() {
2079   void * jresult ;
2080   Dali::Signal< void (bool) > *result = 0 ;
2081
2082   {
2083     try {
2084       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
2085     } catch (std::out_of_range& e) {
2086       {
2087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2088       };
2089     } catch (std::exception& e) {
2090       {
2091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2092       };
2093     } catch (...) {
2094       {
2095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2096       };
2097     }
2098   }
2099   jresult = (void *)result;
2100   return jresult;
2101 }
2102
2103
2104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StatusSignalType(void * jarg1) {
2105   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
2106
2107   arg1 = (Dali::Signal< void (bool) > *)jarg1;
2108   {
2109     try {
2110       delete arg1;
2111     } catch (std::out_of_range& e) {
2112       {
2113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2114       };
2115     } catch (std::exception& e) {
2116       {
2117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2118       };
2119     } catch (...) {
2120       {
2121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2122       };
2123     }
2124   }
2125 }
2126
2127 //KeyboardTypeSignalType
2128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Empty(void * jarg1) {
2129   unsigned int jresult ;
2130   Dali::Signal< void (Dali::ImfManager::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::ImfManager::KeyboardType) > *) 0 ;
2131   bool result;
2132
2133   arg1 = (Dali::Signal< void (Dali::ImfManager::KeyboardType) > *)jarg1;
2134   {
2135     try {
2136       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ImfManager_KeyboardType_SP__Sg__Empty((Dali::Signal< void (Dali::ImfManager::KeyboardType) > const *)arg1);
2137     } catch (std::out_of_range& e) {
2138       {
2139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2140       };
2141     } catch (std::exception& e) {
2142       {
2143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2144       };
2145     } catch (...) {
2146       {
2147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2148       };
2149     }
2150   }
2151   jresult = result;
2152   return jresult;
2153 }
2154
2155
2156 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_GetConnectionCount(void * jarg1) {
2157   unsigned long jresult ;
2158   Dali::Signal< void (Dali::ImfManager::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::ImfManager::KeyboardType) > *) 0 ;
2159   std::size_t result;
2160
2161   arg1 = (Dali::Signal< void (Dali::ImfManager::KeyboardType) > *)jarg1;
2162   {
2163     try {
2164       result = Dali_Signal_Sl_void_Sp_Dali_ImfManager_KeyboardType_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ImfManager::KeyboardType) > const *)arg1);
2165     } catch (std::out_of_range& e) {
2166       {
2167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2168       };
2169     } catch (std::exception& e) {
2170       {
2171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2172       };
2173     } catch (...) {
2174       {
2175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2176       };
2177     }
2178   }
2179   jresult = (unsigned long)result;
2180   return jresult;
2181 }
2182
2183
2184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Connect(void * jarg1, void * jarg2) {
2185   Dali::Signal< void (Dali::ImfManager::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::ImfManager::KeyboardType) > *) 0 ;
2186   void (*arg2)(Dali::ImfManager::KeyboardType) = (void (*)(Dali::ImfManager::KeyboardType)) 0 ;
2187
2188   arg1 = (Dali::Signal< void (Dali::ImfManager::KeyboardType) > *)jarg1;
2189   arg2 = (void (*)(Dali::ImfManager::KeyboardType))jarg2;
2190   {
2191     try {
2192       Dali_Signal_Sl_void_Sp_Dali_ImfManager_KeyboardType_SP__Sg__Connect(arg1,arg2);
2193     } catch (std::out_of_range& e) {
2194       {
2195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2196       };
2197     } catch (std::exception& e) {
2198       {
2199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2200       };
2201     } catch (...) {
2202       {
2203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2204       };
2205     }
2206   }
2207 }
2208
2209
2210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Disconnect(void * jarg1, void * jarg2) {
2211   Dali::Signal< void (Dali::ImfManager::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::ImfManager::KeyboardType) > *) 0 ;
2212   void (*arg2)(Dali::ImfManager::KeyboardType) = (void (*)(Dali::ImfManager::KeyboardType)) 0 ;
2213
2214   arg1 = (Dali::Signal< void (Dali::ImfManager::KeyboardType) > *)jarg1;
2215   arg2 = (void (*)(Dali::ImfManager::KeyboardType))jarg2;
2216   {
2217     try {
2218       Dali_Signal_Sl_void_Sp_Dali_ImfManager_KeyboardType_SP__Sg__Disconnect(arg1,arg2);
2219     } catch (std::out_of_range& e) {
2220       {
2221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2222       };
2223     } catch (std::exception& e) {
2224       {
2225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2226       };
2227     } catch (...) {
2228       {
2229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2230       };
2231     }
2232   }
2233 }
2234
2235
2236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Emit(void * jarg1, int jarg2) {
2237   Dali::Signal< void (Dali::ImfManager::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::ImfManager::KeyboardType) > *) 0 ;
2238   Dali::ImfManager::KeyboardType arg2 ;
2239
2240   arg1 = (Dali::Signal< void (Dali::ImfManager::KeyboardType) > *)jarg1;
2241   arg2 = (Dali::ImfManager::KeyboardType)jarg2;
2242   {
2243     try {
2244       Dali_Signal_Sl_void_Sp_Dali_ImfManager_KeyboardType_SP__Sg__Emit(arg1,arg2);
2245     } catch (std::out_of_range& e) {
2246       {
2247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2248       };
2249     } catch (std::exception& e) {
2250       {
2251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2252       };
2253     } catch (...) {
2254       {
2255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2256       };
2257     }
2258   }
2259 }
2260
2261
2262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyboardTypeSignalType() {
2263   void * jresult ;
2264   Dali::Signal< void (Dali::ImfManager::KeyboardType) > *result = 0 ;
2265
2266   {
2267     try {
2268       result = (Dali::Signal< void (Dali::ImfManager::KeyboardType) > *)new Dali::Signal< void (Dali::ImfManager::KeyboardType) >();
2269     } catch (std::out_of_range& e) {
2270       {
2271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2272       };
2273     } catch (std::exception& e) {
2274       {
2275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2276       };
2277     } catch (...) {
2278       {
2279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2280       };
2281     }
2282   }
2283   jresult = (void *)result;
2284   return jresult;
2285 }
2286
2287
2288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyboardTypeSignalType(void * jarg1) {
2289   Dali::Signal< void (Dali::ImfManager::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::ImfManager::KeyboardType) > *) 0 ;
2290
2291   arg1 = (Dali::Signal< void (Dali::ImfManager::KeyboardType) > *)jarg1;
2292   {
2293     try {
2294       delete arg1;
2295     } catch (std::out_of_range& e) {
2296       {
2297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2298       };
2299     } catch (std::exception& e) {
2300       {
2301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2302       };
2303     } catch (...) {
2304       {
2305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2306       };
2307     }
2308   }
2309 }
2310
2311
2312
2313
2314 #ifdef __cplusplus
2315 }
2316 #endif
2317