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