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