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