dali-csharp-binder/src/input-method-context.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_INPUT_METHOD_CONTEXT
  18 #define CSHARP_INPUT_METHOD_CONTEXT
  19 #endif
  20
  21 #include "common.h"
  22 #include <dali/devel-api/adaptor-framework/input-method-context.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_InputMethodContext_SA__SP__Sg__Empty(Dali::Signal< void (Dali::InputMethodContext &) > const *self){
  30   return self->Empty();
  31 }
  32 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::InputMethodContext &) > const *self){
  33   return self->GetConnectionCount();
  34 }
  35 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Connect(Dali::Signal< void (Dali::InputMethodContext &) > *self,void (*func)(Dali::InputMethodContext &)){
  36   self->Connect( func );
  37 }
  38 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::InputMethodContext &) > *self,void (*func)(Dali::InputMethodContext &)){
  39   self->Disconnect( func );
  40 }
  41 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Emit(Dali::Signal< void (Dali::InputMethodContext &) > *self,Dali::InputMethodContext &arg){
  42   self->Emit( arg );
  43 }
  44
  45 SWIGINTERN bool Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Empty(Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > const *self){
  46   return self->Empty();
  47 }
  48 SWIGINTERN std::size_t Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > const *self){
  49   return self->GetConnectionCount();
  50 }
  51 SWIGINTERN void Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Connect(Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *self,Dali::InputMethodContext::CallbackData (*func)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &)){
  52   self->Connect( func );
  53 }
  54 SWIGINTERN void Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *self,Dali::InputMethodContext::CallbackData (*func)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &)){
  55   self->Disconnect( func );
  56 }
  57 SWIGINTERN Dali::InputMethodContext::CallbackData Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Emit(Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *self,Dali::InputMethodContext &arg1,Dali::InputMethodContext::EventData 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_InputMethodContext_KeyboardType_SP__Sg__Empty(Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > const *self){
  78   return self->Empty();
  79 }
  80 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > const *self){
  81   return self->GetConnectionCount();
  82 }
  83 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Connect(Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *self,void (*func)(Dali::InputMethodContext::KeyboardType)){
  84   self->Connect( func );
  85 }
  86 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Disconnect(Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *self,void (*func)(Dali::InputMethodContext::KeyboardType)){
  87   self->Disconnect( func );
  88 }
  89 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Emit(Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *self,Dali::InputMethodContext::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_InputMethodContext_SWIGUpcast(Dali::InputMethodContext *jarg1) {
 114   return (Dali::BaseHandle *)jarg1;
 115 }
 116
 117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_InputMethodContext_EventData__SWIG_0() {
 118   void * jresult ;
 119   Dali::InputMethodContext::EventData *result = 0 ;
 120
 121   {
 122     try {
 123       result = (Dali::InputMethodContext::EventData *)new Dali::InputMethodContext::EventData();
 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_InputMethodContext_EventData__SWIG_1(int jarg1, char * jarg2, int jarg3, int jarg4) {
 139   void * jresult ;
 140   Dali::InputMethodContext::EventType arg1 ;
 141   std::string *arg2 = 0 ;
 142   int arg3 ;
 143   int arg4 ;
 144   Dali::InputMethodContext::EventData *result = 0 ;
 145
 146   arg1 = (Dali::InputMethodContext::EventType)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::InputMethodContext::EventData *)new Dali::InputMethodContext::EventData(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_InputMethodContext_EventData_predictiveString_set(void * jarg1, char * jarg2) {
 176   Dali::InputMethodContext::EventData *arg1 = (Dali::InputMethodContext::EventData *) 0 ;
 177   std::string *arg2 = 0 ;
 178
 179   arg1 = (Dali::InputMethodContext::EventData *)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_InputMethodContext_EventData_predictiveString_get(void * jarg1) {
 194   char * jresult ;
 195   Dali::InputMethodContext::EventData *arg1 = (Dali::InputMethodContext::EventData *) 0 ;
 196   std::string *result = 0 ;
 197
 198   arg1 = (Dali::InputMethodContext::EventData *)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_InputMethodContext_EventData_eventName_set(void * jarg1, int jarg2) {
 206   Dali::InputMethodContext::EventData *arg1 = (Dali::InputMethodContext::EventData *) 0 ;
 207   Dali::InputMethodContext::EventType arg2 ;
 208
 209   arg1 = (Dali::InputMethodContext::EventData *)jarg1;
 210   arg2 = (Dali::InputMethodContext::EventType)jarg2;
 211   if (arg1) (arg1)->eventName = arg2;
 212 }
 213
 214
 215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_eventName_get(void * jarg1) {
 216   int jresult ;
 217   Dali::InputMethodContext::EventData *arg1 = (Dali::InputMethodContext::EventData *) 0 ;
 218   Dali::InputMethodContext::EventType result;
 219
 220   arg1 = (Dali::InputMethodContext::EventData *)jarg1;
 221   result = (Dali::InputMethodContext::EventType) ((arg1)->eventName);
 222   jresult = (int)result;
 223   return jresult;
 224 }
 225
 226
 227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_cursorOffset_set(void * jarg1, int jarg2) {
 228   Dali::InputMethodContext::EventData *arg1 = (Dali::InputMethodContext::EventData *) 0 ;
 229   int arg2 ;
 230
 231   arg1 = (Dali::InputMethodContext::EventData *)jarg1;
 232   arg2 = (int)jarg2;
 233   if (arg1) (arg1)->cursorOffset = arg2;
 234 }
 235
 236
 237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_cursorOffset_get(void * jarg1) {
 238   int jresult ;
 239   Dali::InputMethodContext::EventData *arg1 = (Dali::InputMethodContext::EventData *) 0 ;
 240   int result;
 241
 242   arg1 = (Dali::InputMethodContext::EventData *)jarg1;
 243   result = (int) ((arg1)->cursorOffset);
 244   jresult = result;
 245   return jresult;
 246 }
 247
 248
 249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_numberOfChars_set(void * jarg1, int jarg2) {
 250   Dali::InputMethodContext::EventData *arg1 = (Dali::InputMethodContext::EventData *) 0 ;
 251   int arg2 ;
 252
 253   arg1 = (Dali::InputMethodContext::EventData *)jarg1;
 254   arg2 = (int)jarg2;
 255   if (arg1) (arg1)->numberOfChars = arg2;
 256 }
 257
 258
 259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_numberOfChars_get(void * jarg1) {
 260   int jresult ;
 261   Dali::InputMethodContext::EventData *arg1 = (Dali::InputMethodContext::EventData *) 0 ;
 262   int result;
 263
 264   arg1 = (Dali::InputMethodContext::EventData *)jarg1;
 265   result = (int) ((arg1)->numberOfChars);
 266   jresult = result;
 267   return jresult;
 268 }
 269
 270
 271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_InputMethodContext_EventData(void * jarg1) {
 272   Dali::InputMethodContext::EventData *arg1 = (Dali::InputMethodContext::EventData *) 0 ;
 273
 274   arg1 = (Dali::InputMethodContext::EventData *)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_InputMethodContext_CallbackData__SWIG_0() {
 291   void * jresult ;
 292   Dali::InputMethodContext::CallbackData *result = 0 ;
 293
 294   {
 295     try {
 296       result = (Dali::InputMethodContext::CallbackData *)new Dali::InputMethodContext::CallbackData();
 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_InputMethodContext_CallbackData__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::InputMethodContext::CallbackData *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::InputMethodContext::CallbackData *)new Dali::InputMethodContext::CallbackData(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_InputMethodContext_CallbackData_currentText_set(void * jarg1, char * jarg2) {
 349   Dali::InputMethodContext::CallbackData *arg1 = (Dali::InputMethodContext::CallbackData *) 0 ;
 350   std::string *arg2 = 0 ;
 351
 352   arg1 = (Dali::InputMethodContext::CallbackData *)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_InputMethodContext_CallbackData_currentText_get(void * jarg1) {
 367   char * jresult ;
 368   Dali::InputMethodContext::CallbackData *arg1 = (Dali::InputMethodContext::CallbackData *) 0 ;
 369   std::string *result = 0 ;
 370
 371   arg1 = (Dali::InputMethodContext::CallbackData *)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_InputMethodContext_CallbackData_cursorPosition_set(void * jarg1, int jarg2) {
 379   Dali::InputMethodContext::CallbackData *arg1 = (Dali::InputMethodContext::CallbackData *) 0 ;
 380   int arg2 ;
 381
 382   arg1 = (Dali::InputMethodContext::CallbackData *)jarg1;
 383   arg2 = (int)jarg2;
 384   if (arg1) (arg1)->cursorPosition = arg2;
 385 }
 386
 387
 388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_cursorPosition_get(void * jarg1) {
 389   int jresult ;
 390   Dali::InputMethodContext::CallbackData *arg1 = (Dali::InputMethodContext::CallbackData *) 0 ;
 391   int result;
 392
 393   arg1 = (Dali::InputMethodContext::CallbackData *)jarg1;
 394   result = (int) ((arg1)->cursorPosition);
 395   jresult = result;
 396   return jresult;
 397 }
 398
 399
 400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_update_set(void * jarg1, unsigned int jarg2) {
 401   Dali::InputMethodContext::CallbackData *arg1 = (Dali::InputMethodContext::CallbackData *) 0 ;
 402   bool arg2 ;
 403
 404   arg1 = (Dali::InputMethodContext::CallbackData *)jarg1;
 405   arg2 = jarg2 ? true : false;
 406   if (arg1) (arg1)->update = arg2;
 407 }
 408
 409
 410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_update_get(void * jarg1) {
 411   unsigned int jresult ;
 412   Dali::InputMethodContext::CallbackData *arg1 = (Dali::InputMethodContext::CallbackData *) 0 ;
 413   bool result;
 414
 415   arg1 = (Dali::InputMethodContext::CallbackData *)jarg1;
 416   result = (bool) ((arg1)->update);
 417   jresult = result;
 418   return jresult;
 419 }
 420
 421
 422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_preeditResetRequired_set(void * jarg1, unsigned int jarg2) {
 423   Dali::InputMethodContext::CallbackData *arg1 = (Dali::InputMethodContext::CallbackData *) 0 ;
 424   bool arg2 ;
 425
 426   arg1 = (Dali::InputMethodContext::CallbackData *)jarg1;
 427   arg2 = jarg2 ? true : false;
 428   if (arg1) (arg1)->preeditResetRequired = arg2;
 429 }
 430
 431
 432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_preeditResetRequired_get(void * jarg1) {
 433   unsigned int jresult ;
 434   Dali::InputMethodContext::CallbackData *arg1 = (Dali::InputMethodContext::CallbackData *) 0 ;
 435   bool result;
 436
 437   arg1 = (Dali::InputMethodContext::CallbackData *)jarg1;
 438   result = (bool) ((arg1)->preeditResetRequired);
 439   jresult = result;
 440   return jresult;
 441 }
 442
 443
 444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_InputMethodContext_CallbackData(void * jarg1) {
 445   Dali::InputMethodContext::CallbackData *arg1 = (Dali::InputMethodContext::CallbackData *) 0 ;
 446
 447   arg1 = (Dali::InputMethodContext::CallbackData *)jarg1;
 448   {
 449     try {
 450       delete arg1;
 451     } catch (std::out_of_range& e) {
 452       {
 453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 454       };
 455     } catch (std::exception& e) {
 456       {
 457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 458       };
 459     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
 460 }
 461
 462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_Finalize(void * jarg1) {
 463   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 464
 465   arg1 = (Dali::InputMethodContext *)jarg1;
 466   {
 467     try {
 468       (arg1)->Finalize();
 469     } catch (std::out_of_range& e) {
 470       {
 471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 472       };
 473     } catch (std::exception& e) {
 474       {
 475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 476       };
 477     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
 478 }
 479
 480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_InputMethodContext__SWIG_0() {
 481   void * jresult ;
 482   Dali::InputMethodContext *result = 0 ;
 483
 484   {
 485     try {
 486       result = (Dali::InputMethodContext *)new Dali::InputMethodContext();
 487     } catch (std::out_of_range& e) {
 488       {
 489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 490       };
 491     } catch (std::exception& e) {
 492       {
 493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 494       };
 495     } catch (...) {
 496       {
 497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 498       };
 499     }
 500   }
 501   jresult = (void *)result;
 502   return jresult;
 503 }
 504
 505
 506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_InputMethodContext(void * jarg1) {
 507   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 508
 509   arg1 = (Dali::InputMethodContext *)jarg1;
 510   {
 511     try {
 512       delete arg1;
 513     } catch (std::out_of_range& e) {
 514       {
 515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 516       };
 517     } catch (std::exception& e) {
 518       {
 519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 520       };
 521     } catch (...) {
 522       {
 523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 524       };
 525     }
 526   }
 527 }
 528
 529
 530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_New() {
 531   void * jresult ;
 532   Dali::InputMethodContext result;
 533
 534   {
 535     try {
 536       result = Dali::InputMethodContext::New();
 537     } catch (std::out_of_range& e) {
 538       {
 539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 540       };
 541     } catch (std::exception& e) {
 542       {
 543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 544       };
 545     } catch (...) {
 546       {
 547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 548       };
 549     }
 550   }
 551   jresult = new Dali::InputMethodContext((const Dali::InputMethodContext &)result);
 552   return jresult;
 553 }
 554
 555
 556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_InputMethodContext__SWIG_1(void * jarg1) {
 557   void * jresult ;
 558   Dali::InputMethodContext *arg1 = 0 ;
 559   Dali::InputMethodContext *result = 0 ;
 560
 561   arg1 = (Dali::InputMethodContext *)jarg1;
 562   if (!arg1) {
 563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext const & type is null", 0);
 564     return 0;
 565   }
 566   {
 567     try {
 568       result = (Dali::InputMethodContext *)new Dali::InputMethodContext((Dali::InputMethodContext const &)*arg1);
 569     } catch (std::out_of_range& e) {
 570       {
 571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 572       };
 573     } catch (std::exception& e) {
 574       {
 575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 576       };
 577     } catch (...) {
 578       {
 579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 580       };
 581     }
 582   }
 583   jresult = (void *)result;
 584   return jresult;
 585 }
 586
 587
 588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_Assign(void * jarg1, void * jarg2) {
 589   void * jresult ;
 590   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 591   Dali::InputMethodContext *arg2 = 0 ;
 592   Dali::InputMethodContext *result = 0 ;
 593
 594   arg1 = (Dali::InputMethodContext *)jarg1;
 595   arg2 = (Dali::InputMethodContext *)jarg2;
 596   if (!arg2) {
 597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext const & type is null", 0);
 598     return 0;
 599   }
 600   {
 601     try {
 602       result = (Dali::InputMethodContext *) &(arg1)->operator =((Dali::InputMethodContext const &)*arg2);
 603     } catch (std::out_of_range& e) {
 604       {
 605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 606       };
 607     } catch (std::exception& e) {
 608       {
 609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 610       };
 611     } catch (...) {
 612       {
 613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 614       };
 615     }
 616   }
 617   jresult = (void *)result;
 618   return jresult;
 619 }
 620
 621
 622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_DownCast(void * jarg1) {
 623   void * jresult ;
 624   Dali::BaseHandle arg1 ;
 625   Dali::BaseHandle *argp1 ;
 626   Dali::InputMethodContext result;
 627
 628   argp1 = (Dali::BaseHandle *)jarg1;
 629   if (!argp1) {
 630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
 631     return 0;
 632   }
 633   arg1 = *argp1;
 634   {
 635     try {
 636       result = Dali::InputMethodContext::DownCast(arg1);
 637     } catch (std::out_of_range& e) {
 638       {
 639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 640       };
 641     } catch (std::exception& e) {
 642       {
 643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 644       };
 645     } catch (...) {
 646       {
 647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 648       };
 649     }
 650   }
 651   jresult = new Dali::InputMethodContext((const Dali::InputMethodContext &)result);
 652   return jresult;
 653 }
 654
 655
 656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_Activate(void * jarg1) {
 657   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 658
 659   arg1 = (Dali::InputMethodContext *)jarg1;
 660   {
 661     try {
 662       (arg1)->Activate();
 663     } catch (std::out_of_range& e) {
 664       {
 665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 666       };
 667     } catch (std::exception& e) {
 668       {
 669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 670       };
 671     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
 672 }
 673
 674
 675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_Deactivate(void * jarg1) {
 676   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 677
 678   arg1 = (Dali::InputMethodContext *)jarg1;
 679   {
 680     try {
 681       (arg1)->Deactivate();
 682     } catch (std::out_of_range& e) {
 683       {
 684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 685       };
 686     } catch (std::exception& e) {
 687       {
 688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 689       };
 690     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
 691 }
 692
 693
 694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_InputMethodContext_RestoreAfterFocusLost(void * jarg1) {
 695   unsigned int jresult ;
 696   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 697   bool result;
 698
 699   arg1 = (Dali::InputMethodContext *)jarg1;
 700   {
 701     try {
 702       result = (bool)((Dali::InputMethodContext const *)arg1)->RestoreAfterFocusLost();
 703     } catch (std::out_of_range& e) {
 704       {
 705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 706       };
 707     } catch (std::exception& e) {
 708       {
 709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 710       };
 711     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
 712   jresult = result;
 713   return jresult;
 714 }
 715
 716
 717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetRestoreAfterFocusLost(void * jarg1, unsigned int jarg2) {
 718   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 719   bool arg2 ;
 720
 721   arg1 = (Dali::InputMethodContext *)jarg1;
 722   arg2 = jarg2 ? true : false;
 723   {
 724     try {
 725       (arg1)->SetRestoreAfterFocusLost(arg2);
 726     } catch (std::out_of_range& e) {
 727       {
 728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 729       };
 730     } catch (std::exception& e) {
 731       {
 732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 733       };
 734     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
 735 }
 736
 737
 738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_Reset(void * jarg1) {
 739   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 740
 741   arg1 = (Dali::InputMethodContext *)jarg1;
 742   {
 743     try {
 744       (arg1)->Reset();
 745     } catch (std::out_of_range& e) {
 746       {
 747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 748       };
 749     } catch (std::exception& e) {
 750       {
 751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 752       };
 753     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
 754 }
 755
 756
 757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_NotifyCursorPosition(void * jarg1) {
 758   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 759
 760   arg1 = (Dali::InputMethodContext *)jarg1;
 761   {
 762     try {
 763       (arg1)->NotifyCursorPosition();
 764     } catch (std::out_of_range& e) {
 765       {
 766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 767       };
 768     } catch (std::exception& e) {
 769       {
 770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 771       };
 772     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
 773 }
 774
 775
 776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetCursorPosition(void * jarg1, unsigned int jarg2) {
 777   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 778   unsigned int arg2 ;
 779
 780   arg1 = (Dali::InputMethodContext *)jarg1;
 781   arg2 = (unsigned int)jarg2;
 782   {
 783     try {
 784       (arg1)->SetCursorPosition(arg2);
 785     } catch (std::out_of_range& e) {
 786       {
 787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 788       };
 789     } catch (std::exception& e) {
 790       {
 791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 792       };
 793     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
 794 }
 795
 796
 797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_InputMethodContext_GetCursorPosition(void * jarg1) {
 798   unsigned int jresult ;
 799   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 800   unsigned int result;
 801
 802   arg1 = (Dali::InputMethodContext *)jarg1;
 803   {
 804     try {
 805       result = (unsigned int)((Dali::InputMethodContext const *)arg1)->GetCursorPosition();
 806     } catch (std::out_of_range& e) {
 807       {
 808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 809       };
 810     } catch (std::exception& e) {
 811       {
 812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 813       };
 814     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
 815   jresult = result;
 816   return jresult;
 817 }
 818
 819
 820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetSurroundingText(void * jarg1, char * jarg2) {
 821   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 822   std::string *arg2 = 0 ;
 823
 824   arg1 = (Dali::InputMethodContext *)jarg1;
 825   if (!jarg2) {
 826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 827     return ;
 828   }
 829   std::string arg2_str(jarg2);
 830   arg2 = &arg2_str;
 831   {
 832     try {
 833       (arg1)->SetSurroundingText((std::string const &)*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   //argout typemap for const std::string&
 845
 846 }
 847
 848
 849 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_InputMethodContext_GetSurroundingText(void * jarg1) {
 850   char * jresult ;
 851   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 852   std::string *result = 0 ;
 853
 854   arg1 = (Dali::InputMethodContext *)jarg1;
 855   {
 856     try {
 857       result = (std::string *) &((Dali::InputMethodContext const *)arg1)->GetSurroundingText();
 858     } catch (std::out_of_range& e) {
 859       {
 860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 861       };
 862     } catch (std::exception& e) {
 863       {
 864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 865       };
 866     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
 867   jresult = SWIG_csharp_string_callback(result->c_str());
 868   return jresult;
 869 }
 870
 871
 872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_NotifyTextInputMultiLine(void * jarg1, unsigned int jarg2) {
 873   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 874   bool arg2 ;
 875
 876   arg1 = (Dali::InputMethodContext *)jarg1;
 877   arg2 = jarg2 ? true : false;
 878   {
 879     try {
 880       (arg1)->NotifyTextInputMultiLine(arg2);
 881     } catch (std::out_of_range& e) {
 882       {
 883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 884       };
 885     } catch (std::exception& e) {
 886       {
 887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 888       };
 889     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
 890 }
 891
 892
 893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_GetTextDirection(void * jarg1) {
 894   int jresult ;
 895   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 896   Dali::InputMethodContext::TextDirection result;
 897
 898   arg1 = (Dali::InputMethodContext *)jarg1;
 899   {
 900     try {
 901       result = (Dali::InputMethodContext::TextDirection)(arg1)->GetTextDirection();
 902     } catch (std::out_of_range& e) {
 903       {
 904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 905       };
 906     } catch (std::exception& e) {
 907       {
 908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 909       };
 910     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
 911   jresult = (int)result;
 912   return jresult;
 913 }
 914
 915
 916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_GetInputMethodArea(void * jarg1) {
 917   void * jresult ;
 918   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 919   Dali::Rect< int > result;
 920
 921   arg1 = (Dali::InputMethodContext *)jarg1;
 922   {
 923     try {
 924       result = (arg1)->GetInputMethodArea();
 925     } catch (std::out_of_range& e) {
 926       {
 927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 928       };
 929     } catch (std::exception& e) {
 930       {
 931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 932       };
 933     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
 934   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
 935   return jresult;
 936 }
 937
 938
 939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_ApplyOptions(void * jarg1, void * jarg2) {
 940   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 941   Dali::InputMethodOptions *arg2 = 0 ;
 942
 943   arg1 = (Dali::InputMethodContext *)jarg1;
 944   arg2 = (Dali::InputMethodOptions *)jarg2;
 945   if (!arg2) {
 946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InputMethodOptions const & type is null", 0);
 947     return ;
 948   }
 949   {
 950     try {
 951       (arg1)->ApplyOptions((Dali::InputMethodOptions const &)*arg2);
 952     } catch (std::out_of_range& e) {
 953       {
 954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 955       };
 956     } catch (std::exception& e) {
 957       {
 958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 959       };
 960     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
 961 }
 962
 963
 964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetInputPanelUserData(void * jarg1, char * jarg2) {
 965   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 966   std::string *arg2 = 0 ;
 967
 968   arg1 = (Dali::InputMethodContext *)jarg1;
 969   if (!jarg2) {
 970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 971     return ;
 972   }
 973   std::string arg2_str(jarg2);
 974   arg2 = &arg2_str;
 975   {
 976     try {
 977       (arg1)->SetInputPanelData((std::string const &)*arg2);
 978     } catch (std::out_of_range& e) {
 979       {
 980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 981       };
 982     } catch (std::exception& e) {
 983       {
 984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 985       };
 986     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
 987
 988   //argout typemap for const std::string&
 989
 990 }
 991
 992
 993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_GetInputPanelUserData(void * jarg1, char** jarg2) {
 994   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
 995   std::string *arg2 = 0 ;
 996
 997   arg1 = (Dali::InputMethodContext *)jarg1;
 998
 999   //typemap in
1000   std::string temp;
1001   arg2 = &temp;
1002
1003   {
1004     try {
1005       (arg1)->GetInputPanelData(*arg2);
1006     } catch (std::out_of_range& e) {
1007       {
1008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1009       };
1010     } catch (std::exception& e) {
1011       {
1012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1013       };
1014     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1015
1016   //Typemap argout in c++ file.
1017   //This will convert c++ string to c# string
1018   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
1019
1020 }
1021
1022
1023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_GetInputPanelState(void * jarg1) {
1024   int jresult ;
1025   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1026   Dali::InputMethodContext::State result;
1027
1028   arg1 = (Dali::InputMethodContext *)jarg1;
1029   {
1030     try {
1031       result = (Dali::InputMethodContext::State)(arg1)->GetInputPanelState();
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 = (int)result;
1042   return jresult;
1043 }
1044
1045
1046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetReturnKeyState(void * jarg1, unsigned int jarg2) {
1047   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1048   bool arg2 ;
1049
1050   arg1 = (Dali::InputMethodContext *)jarg1;
1051   arg2 = jarg2 ? true : false;
1052   {
1053     try {
1054       (arg1)->SetReturnKeyState(arg2);
1055     } catch (std::out_of_range& e) {
1056       {
1057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1058       };
1059     } catch (std::exception& e) {
1060       {
1061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1062       };
1063     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1064 }
1065
1066
1067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_AutoEnableInputPanel(void * jarg1, unsigned int jarg2) {
1068   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1069   bool arg2 ;
1070
1071   arg1 = (Dali::InputMethodContext *)jarg1;
1072   arg2 = jarg2 ? true : false;
1073   {
1074     try {
1075       (arg1)->AutoEnableInputPanel(arg2);
1076     } catch (std::out_of_range& e) {
1077       {
1078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1079       };
1080     } catch (std::exception& e) {
1081       {
1082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1083       };
1084     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1085 }
1086
1087
1088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_ShowInputPanel(void * jarg1) {
1089   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1090
1091   arg1 = (Dali::InputMethodContext *)jarg1;
1092   {
1093     try {
1094       (arg1)->ShowInputPanel();
1095     } catch (std::out_of_range& e) {
1096       {
1097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1098       };
1099     } catch (std::exception& e) {
1100       {
1101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1102       };
1103     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1104 }
1105
1106
1107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_HideInputPanel(void * jarg1) {
1108   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1109
1110   arg1 = (Dali::InputMethodContext *)jarg1;
1111   {
1112     try {
1113       (arg1)->HideInputPanel();
1114     } catch (std::out_of_range& e) {
1115       {
1116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1117       };
1118     } catch (std::exception& e) {
1119       {
1120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1121       };
1122     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1123 }
1124
1125
1126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_GetKeyboardType(void * jarg1) {
1127   int jresult ;
1128   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1129   Dali::InputMethodContext::KeyboardType result;
1130
1131   arg1 = (Dali::InputMethodContext *)jarg1;
1132   {
1133     try {
1134       result = (Dali::InputMethodContext::KeyboardType)(arg1)->GetKeyboardType();
1135     } catch (std::out_of_range& e) {
1136       {
1137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1138       };
1139     } catch (std::exception& e) {
1140       {
1141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1142       };
1143     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1144   jresult = (int)result;
1145   return jresult;
1146 }
1147
1148
1149 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_InputMethodContext_GetInputPanelLocale(void * jarg1) {
1150   char * jresult ;
1151   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1152   std::string result;
1153
1154   arg1 = (Dali::InputMethodContext *)jarg1;
1155   {
1156     try {
1157       result = (arg1)->GetInputPanelLocale();
1158     } catch (std::out_of_range& e) {
1159       {
1160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1161       };
1162     } catch (std::exception& e) {
1163       {
1164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1165       };
1166     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1167   jresult = SWIG_csharp_string_callback((&result)->c_str());
1168   return jresult;
1169 }
1170
1171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_AllowTextPrediction(void * jarg1, unsigned int jarg2) {
1172   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1173   bool arg2 ;
1174
1175   arg1 = (Dali::InputMethodContext *)jarg1;
1176   arg2 = jarg2 ? true : false;
1177   {
1178     try {
1179       (arg1)->AllowTextPrediction(arg2);
1180     } catch (std::out_of_range& e) {
1181       {
1182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1183       };
1184     } catch (std::exception& e) {
1185       {
1186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1187       };
1188     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1189 }
1190
1191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_InputMethodContext_IsTextPredictionAllowed(void * jarg1) {
1192   unsigned int jresult ;
1193   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1194   bool result;
1195
1196   arg1 = (Dali::InputMethodContext *)jarg1;
1197   {
1198     try {
1199       result = (bool)((Dali::InputMethodContext const *)arg1)->IsTextPredictionAllowed();
1200     } catch (std::out_of_range& e) {
1201       {
1202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1203       };
1204     } catch (std::exception& e) {
1205       {
1206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1207       };
1208     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1209   jresult = result;
1210   return jresult;
1211 }
1212
1213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_ActivatedSignal(void * jarg1) {
1214   void * jresult ;
1215   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1216   Dali::InputMethodContext::ActivatedSignalType *result = 0 ;
1217
1218   arg1 = (Dali::InputMethodContext *)jarg1;
1219   {
1220     try {
1221       result = (Dali::InputMethodContext::ActivatedSignalType *) &(arg1)->ActivatedSignal();
1222     } catch (std::out_of_range& e) {
1223       {
1224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1225       };
1226     } catch (std::exception& e) {
1227       {
1228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1229       };
1230     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1231   jresult = (void *)result;
1232   return jresult;
1233 }
1234
1235
1236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_EventReceivedSignal(void * jarg1) {
1237   void * jresult ;
1238   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1239   Dali::InputMethodContext::KeyboardEventSignalType *result = 0 ;
1240
1241   arg1 = (Dali::InputMethodContext *)jarg1;
1242   {
1243     try {
1244       result = (Dali::InputMethodContext::KeyboardEventSignalType *) &(arg1)->EventReceivedSignal();
1245     } catch (std::out_of_range& e) {
1246       {
1247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1248       };
1249     } catch (std::exception& e) {
1250       {
1251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1252       };
1253     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1254   jresult = (void *)result;
1255   return jresult;
1256 }
1257
1258
1259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_StatusChangedSignal(void * jarg1) {
1260   void * jresult ;
1261   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1262   Dali::InputMethodContext::StatusSignalType *result = 0 ;
1263
1264   arg1 = (Dali::InputMethodContext *)jarg1;
1265   {
1266     try {
1267       result = (Dali::InputMethodContext::StatusSignalType *) &(arg1)->StatusChangedSignal();
1268     } catch (std::out_of_range& e) {
1269       {
1270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1271       };
1272     } catch (std::exception& e) {
1273       {
1274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1275       };
1276     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1277   jresult = (void *)result;
1278   return jresult;
1279 }
1280
1281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_ResizedSignal(void * jarg1) {
1282   void * jresult ;
1283   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1284   Dali::InputMethodContext::KeyboardResizedSignalType *result = 0 ;
1285
1286   arg1 = (Dali::InputMethodContext *)jarg1;
1287   {
1288     try {
1289       result = (Dali::InputMethodContext::KeyboardResizedSignalType *) &(arg1)->ResizedSignal();
1290     } catch (std::out_of_range& e) {
1291       {
1292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1293       };
1294     } catch (std::exception& e) {
1295       {
1296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1297       };
1298     } catch (...) {
1299       {
1300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1301       };
1302     }
1303   }
1304   jresult = (void *)result;
1305   return jresult;
1306 }
1307
1308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_LanguageChangedSignal(void * jarg1) {
1309   void * jresult ;
1310   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1311   Dali::InputMethodContext::LanguageChangedSignalType *result = 0 ;
1312
1313   arg1 = (Dali::InputMethodContext *)jarg1;
1314   {
1315     try {
1316       result = (Dali::InputMethodContext::LanguageChangedSignalType *) &(arg1)->LanguageChangedSignal();
1317     } catch (std::out_of_range& e) {
1318       {
1319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1320       };
1321     } catch (std::exception& e) {
1322       {
1323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1324       };
1325     } catch (...) {
1326       {
1327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1328       };
1329     }
1330   }
1331   jresult = (void *)result;
1332   return jresult;
1333 }
1334
1335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_KeyboardTypeChangedSignal(void * jarg1) {
1336   void * jresult ;
1337   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1338   Dali::InputMethodContext::KeyboardTypeSignalType *result = 0 ;
1339
1340   arg1 = (Dali::InputMethodContext *)jarg1;
1341   {
1342     try {
1343       result = (Dali::InputMethodContext::KeyboardTypeSignalType *) &(arg1)->KeyboardTypeChangedSignal();
1344     } catch (std::out_of_range& e) {
1345       {
1346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1347       };
1348     } catch (std::exception& e) {
1349       {
1350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1351       };
1352     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1353   jresult = (void *)result;
1354   return jresult;
1355 }
1356
1357 // ActivatedSignalType
1358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Empty(void * jarg1) {
1359   unsigned int jresult ;
1360   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1361   bool result;
1362
1363   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1364   {
1365     try {
1366       result = (bool)Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Empty((Dali::Signal< void (Dali::InputMethodContext &) > const *)arg1);
1367     } catch (std::out_of_range& e) {
1368       {
1369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1370       };
1371     } catch (std::exception& e) {
1372       {
1373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1374       };
1375     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1376   jresult = result;
1377   return jresult;
1378 }
1379
1380
1381 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActivatedSignalType_GetConnectionCount(void * jarg1) {
1382   unsigned long jresult ;
1383   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1384   std::size_t result;
1385
1386   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1387   {
1388     try {
1389       result = Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::InputMethodContext &) > const *)arg1);
1390     } catch (std::out_of_range& e) {
1391       {
1392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1393       };
1394     } catch (std::exception& e) {
1395       {
1396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1397       };
1398     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1399   jresult = (unsigned long)result;
1400   return jresult;
1401 }
1402
1403
1404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Connect(void * jarg1, void * jarg2) {
1405   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1406   void (*arg2)(Dali::InputMethodContext &) = (void (*)(Dali::InputMethodContext &)) 0 ;
1407
1408   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1409   arg2 = (void (*)(Dali::InputMethodContext &))jarg2;
1410   {
1411     try {
1412       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Connect(arg1,arg2);
1413     } catch (std::out_of_range& e) {
1414       {
1415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1416       };
1417     } catch (std::exception& e) {
1418       {
1419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1420       };
1421     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1422 }
1423
1424
1425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Disconnect(void * jarg1, void * jarg2) {
1426   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1427   void (*arg2)(Dali::InputMethodContext &) = (void (*)(Dali::InputMethodContext &)) 0 ;
1428
1429   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1430   arg2 = (void (*)(Dali::InputMethodContext &))jarg2;
1431   {
1432     try {
1433       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Disconnect(arg1,arg2);
1434     } catch (std::out_of_range& e) {
1435       {
1436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1437       };
1438     } catch (std::exception& e) {
1439       {
1440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1441       };
1442     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1443 }
1444
1445
1446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Emit(void * jarg1, void * jarg2) {
1447   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1448   Dali::InputMethodContext *arg2 = 0 ;
1449
1450   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1451   arg2 = (Dali::InputMethodContext *)jarg2;
1452   if (!arg2) {
1453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext & type is null", 0);
1454     return ;
1455   }
1456   {
1457     try {
1458       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Emit(arg1,*arg2);
1459     } catch (std::out_of_range& e) {
1460       {
1461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1462       };
1463     } catch (std::exception& e) {
1464       {
1465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1466       };
1467     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1468 }
1469
1470
1471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActivatedSignalType() {
1472   void * jresult ;
1473   Dali::Signal< void (Dali::InputMethodContext &) > *result = 0 ;
1474
1475   {
1476     try {
1477       result = (Dali::Signal< void (Dali::InputMethodContext &) > *)new Dali::Signal< void (Dali::InputMethodContext &) >();
1478     } catch (std::out_of_range& e) {
1479       {
1480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1481       };
1482     } catch (std::exception& e) {
1483       {
1484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1485       };
1486     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1487   jresult = (void *)result;
1488   return jresult;
1489 }
1490
1491
1492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActivatedSignalType(void * jarg1) {
1493   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1494
1495   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1496   {
1497     try {
1498       delete arg1;
1499     } catch (std::out_of_range& e) {
1500       {
1501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1502       };
1503     } catch (std::exception& e) {
1504       {
1505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1506       };
1507     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1508 }
1509
1510 // KeyboardEventSignalType
1511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Empty(void * jarg1) {
1512   unsigned int jresult ;
1513   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1514   bool result;
1515
1516   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1517   {
1518     try {
1519       result = (bool)Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Empty((Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > const *)arg1);
1520     } catch (std::out_of_range& e) {
1521       {
1522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1523       };
1524     } catch (std::exception& e) {
1525       {
1526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1527       };
1528     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1529   jresult = result;
1530   return jresult;
1531 }
1532
1533
1534 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_GetConnectionCount(void * jarg1) {
1535   unsigned long jresult ;
1536   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1537   std::size_t result;
1538
1539   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1540   {
1541     try {
1542       result = Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > const *)arg1);
1543     } catch (std::out_of_range& e) {
1544       {
1545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1546       };
1547     } catch (std::exception& e) {
1548       {
1549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1550       };
1551     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1552   jresult = (unsigned long)result;
1553   return jresult;
1554 }
1555
1556 typedef Dali::InputMethodContext::CallbackData* (SWIGSTDCALL* SWIG_CallbackEventReceived)(Dali::InputMethodContext *, Dali::InputMethodContext::EventData *);
1557 SWIG_CallbackEventReceived swig_callbackOnEventReceived;
1558
1559 Dali::InputMethodContext::CallbackData OnEventReceivedCallback(Dali::InputMethodContext inputMethodContext, Dali::InputMethodContext::EventData eventData)
1560 {
1561     Dali::InputMethodContext::CallbackData *callbackDataP;
1562     Dali::InputMethodContext::CallbackData callbackData;
1563     Dali::InputMethodContext *inputMethodContextP = NULL;
1564     Dali::InputMethodContext::EventData *eventDataP = NULL;
1565
1566     if (inputMethodContext)
1567     {
1568       inputMethodContextP = (Dali::InputMethodContext *)&inputMethodContext;
1569     }
1570
1571     eventDataP = (Dali::InputMethodContext::EventData *)&eventData;
1572
1573     callbackDataP = (Dali::InputMethodContext::CallbackData *)swig_callbackOnEventReceived(inputMethodContextP, eventDataP);
1574     if (callbackDataP)
1575     {
1576       callbackData = *callbackDataP;
1577     }
1578
1579     return callbackData;
1580 }
1581
1582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Connect(void * jarg1, SWIG_CallbackEventReceived callbackOnEventReceived) {
1583
1584   swig_callbackOnEventReceived = callbackOnEventReceived;
1585
1586   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1587   Dali::InputMethodContext::CallbackData (*arg2)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &)) 0 ;
1588
1589   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1590   arg2 = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &))OnEventReceivedCallback;
1591   {
1592     try {
1593       Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
1594     } catch (std::out_of_range& e) {
1595       {
1596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1597       };
1598     } catch (std::exception& e) {
1599       {
1600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1601       };
1602     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1603 }
1604
1605
1606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Disconnect(void * jarg1, SWIG_CallbackEventReceived callbackOnEventReceived) {
1607
1608   swig_callbackOnEventReceived = callbackOnEventReceived;
1609
1610   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1611   Dali::InputMethodContext::CallbackData (*arg2)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &)) 0 ;
1612
1613   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1614   arg2 = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &))OnEventReceivedCallback;
1615   {
1616     try {
1617       Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
1618     } catch (std::out_of_range& e) {
1619       {
1620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1621       };
1622     } catch (std::exception& e) {
1623       {
1624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1625       };
1626     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1627 }
1628
1629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Emit(void * jarg1, void * jarg2, void * jarg3) {
1630   void * jresult ;
1631   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1632   Dali::InputMethodContext *arg2 = 0 ;
1633   Dali::InputMethodContext::EventData *arg3 = 0 ;
1634   Dali::InputMethodContext::CallbackData result;
1635
1636   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1637   arg2 = (Dali::InputMethodContext *)jarg2;
1638   if (!arg2) {
1639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext & type is null", 0);
1640     return 0;
1641   }
1642   arg3 = (Dali::InputMethodContext::EventData *)jarg3;
1643   if (!arg3) {
1644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext::EventData const & type is null", 0);
1645     return 0;
1646   }
1647   {
1648     try {
1649       result = Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Emit(arg1,*arg2,(Dali::InputMethodContext::EventData const &)*arg3);
1650     } catch (std::out_of_range& e) {
1651       {
1652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1653       };
1654     } catch (std::exception& e) {
1655       {
1656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1657       };
1658     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1659   jresult = new Dali::InputMethodContext::CallbackData((const Dali::InputMethodContext::CallbackData &)result);
1660   return jresult;
1661 }
1662
1663
1664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyboardEventSignalType() {
1665   void * jresult ;
1666   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *result = 0 ;
1667
1668   {
1669     try {
1670       result = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)new Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) >();
1671     } catch (std::out_of_range& e) {
1672       {
1673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1674       };
1675     } catch (std::exception& e) {
1676       {
1677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1678       };
1679     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1680   jresult = (void *)result;
1681   return jresult;
1682 }
1683
1684
1685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyboardEventSignalType(void * jarg1) {
1686   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1687
1688   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1689   {
1690     try {
1691       delete arg1;
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
1704 // VoidSignalType
1705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignalType() {
1706   void * jresult ;
1707   Dali::Signal< void () > *result = 0 ;
1708
1709   {
1710     try {
1711       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
1712     } catch (std::out_of_range& e) {
1713       {
1714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1715       };
1716     } catch (std::exception& e) {
1717       {
1718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1719       };
1720     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1721   jresult = (void *)result;
1722   return jresult;
1723 }
1724
1725
1726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignalType(void * jarg1) {
1727   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1728
1729   arg1 = (Dali::Signal< void () > *)jarg1;
1730   {
1731     try {
1732       delete arg1;
1733     } catch (std::out_of_range& e) {
1734       {
1735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1736       };
1737     } catch (std::exception& e) {
1738       {
1739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1740       };
1741     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1742 }
1743
1744
1745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignalType_Empty(void * jarg1) {
1746   unsigned int jresult ;
1747   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1748   bool result;
1749
1750   arg1 = (Dali::Signal< void () > *)jarg1;
1751   {
1752     try {
1753       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
1754     } catch (std::out_of_range& e) {
1755       {
1756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1757       };
1758     } catch (std::exception& e) {
1759       {
1760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1761       };
1762     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1763   jresult = result;
1764   return jresult;
1765 }
1766
1767
1768 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignalType_GetConnectionCount(void * jarg1) {
1769   unsigned long jresult ;
1770   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1771   std::size_t result;
1772
1773   arg1 = (Dali::Signal< void () > *)jarg1;
1774   {
1775     try {
1776       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
1777     } catch (std::out_of_range& e) {
1778       {
1779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1780       };
1781     } catch (std::exception& e) {
1782       {
1783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1784       };
1785     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1786   jresult = (unsigned long)result;
1787   return jresult;
1788 }
1789
1790
1791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Connect__SWIG_0(void * jarg1, void * jarg2) {
1792   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1793   void (*arg2)() = (void (*)()) 0 ;
1794
1795   arg1 = (Dali::Signal< void () > *)jarg1;
1796   arg2 = (void (*)())jarg2;
1797   {
1798     try {
1799       (arg1)->Connect(arg2);
1800     } catch (std::out_of_range& e) {
1801       {
1802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1803       };
1804     } catch (std::exception& e) {
1805       {
1806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1807       };
1808     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1809 }
1810
1811
1812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Disconnect(void * jarg1, void * jarg2) {
1813   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1814   void (*arg2)() = (void (*)()) 0 ;
1815
1816   arg1 = (Dali::Signal< void () > *)jarg1;
1817   arg2 = (void (*)())jarg2;
1818   {
1819     try {
1820       (arg1)->Disconnect(arg2);
1821     } catch (std::out_of_range& e) {
1822       {
1823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1824       };
1825     } catch (std::exception& e) {
1826       {
1827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1828       };
1829     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1830 }
1831
1832
1833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
1834   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1835   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
1836   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
1837
1838   arg1 = (Dali::Signal< void () > *)jarg1;
1839   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
1840   arg3 = (Dali::FunctorDelegate *)jarg3;
1841   {
1842     try {
1843       (arg1)->Connect(arg2,arg3);
1844     } catch (std::out_of_range& e) {
1845       {
1846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1847       };
1848     } catch (std::exception& e) {
1849       {
1850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1851       };
1852     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1853 }
1854
1855
1856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Emit(void * jarg1) {
1857   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1858
1859   arg1 = (Dali::Signal< void () > *)jarg1;
1860   {
1861     try {
1862       (arg1)->Emit();
1863     } catch (std::out_of_range& e) {
1864       {
1865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1866       };
1867     } catch (std::exception& e) {
1868       {
1869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1870       };
1871     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1872 }
1873
1874 //StatusSignalType
1875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StatusSignalType_Empty(void * jarg1) {
1876   unsigned int jresult ;
1877   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1878   bool result;
1879
1880   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1881   {
1882     try {
1883       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
1884     } catch (std::out_of_range& e) {
1885       {
1886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1887       };
1888     } catch (std::exception& e) {
1889       {
1890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1891       };
1892     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1893   jresult = result;
1894   return jresult;
1895 }
1896
1897
1898 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StatusSignalType_GetConnectionCount(void * jarg1) {
1899   unsigned long jresult ;
1900   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1901   std::size_t result;
1902
1903   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1904   {
1905     try {
1906       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
1907     } catch (std::out_of_range& e) {
1908       {
1909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1910       };
1911     } catch (std::exception& e) {
1912       {
1913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1914       };
1915     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1916   jresult = (unsigned long)result;
1917   return jresult;
1918 }
1919
1920
1921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Connect(void * jarg1, void * jarg2) {
1922   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1923   void (*arg2)(bool) = (void (*)(bool)) 0 ;
1924
1925   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1926   arg2 = (void (*)(bool))jarg2;
1927   {
1928     try {
1929       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
1930     } catch (std::out_of_range& e) {
1931       {
1932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1933       };
1934     } catch (std::exception& e) {
1935       {
1936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1937       };
1938     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1939 }
1940
1941
1942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Disconnect(void * jarg1, void * jarg2) {
1943   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1944   void (*arg2)(bool) = (void (*)(bool)) 0 ;
1945
1946   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1947   arg2 = (void (*)(bool))jarg2;
1948   {
1949     try {
1950       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
1951     } catch (std::out_of_range& e) {
1952       {
1953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1954       };
1955     } catch (std::exception& e) {
1956       {
1957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1958       };
1959     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1960 }
1961
1962
1963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Emit(void * jarg1, unsigned int jarg2) {
1964   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1965   bool arg2 ;
1966
1967   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1968   arg2 = jarg2 ? true : false;
1969   {
1970     try {
1971       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
1972     } catch (std::out_of_range& e) {
1973       {
1974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1975       };
1976     } catch (std::exception& e) {
1977       {
1978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1979       };
1980     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1981 }
1982
1983
1984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StatusSignalType() {
1985   void * jresult ;
1986   Dali::Signal< void (bool) > *result = 0 ;
1987
1988   {
1989     try {
1990       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
1991     } catch (std::out_of_range& e) {
1992       {
1993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1994       };
1995     } catch (std::exception& e) {
1996       {
1997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1998       };
1999     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
2000   jresult = (void *)result;
2001   return jresult;
2002 }
2003
2004
2005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StatusSignalType(void * jarg1) {
2006   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
2007
2008   arg1 = (Dali::Signal< void (bool) > *)jarg1;
2009   {
2010     try {
2011       delete arg1;
2012     } catch (std::out_of_range& e) {
2013       {
2014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2015       };
2016     } catch (std::exception& e) {
2017       {
2018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2019       };
2020     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
2021 }
2022
2023 //KeyboardTypeSignalType
2024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Empty(void * jarg1) {
2025   unsigned int jresult ;
2026   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
2027   bool result;
2028
2029   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
2030   {
2031     try {
2032       result = (bool)Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Empty((Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > const *)arg1);
2033     } catch (std::out_of_range& e) {
2034       {
2035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2036       };
2037     } catch (std::exception& e) {
2038       {
2039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2040       };
2041     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
2042   jresult = result;
2043   return jresult;
2044 }
2045
2046
2047 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_GetConnectionCount(void * jarg1) {
2048   unsigned long jresult ;
2049   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
2050   std::size_t result;
2051
2052   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
2053   {
2054     try {
2055       result = Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > const *)arg1);
2056     } catch (std::out_of_range& e) {
2057       {
2058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2059       };
2060     } catch (std::exception& e) {
2061       {
2062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2063       };
2064     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
2065   jresult = (unsigned long)result;
2066   return jresult;
2067 }
2068
2069
2070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Connect(void * jarg1, void * jarg2) {
2071   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
2072   void (*arg2)(Dali::InputMethodContext::KeyboardType) = (void (*)(Dali::InputMethodContext::KeyboardType)) 0 ;
2073
2074   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
2075   arg2 = (void (*)(Dali::InputMethodContext::KeyboardType))jarg2;
2076   {
2077     try {
2078       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Connect(arg1,arg2);
2079     } catch (std::out_of_range& e) {
2080       {
2081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2082       };
2083     } catch (std::exception& e) {
2084       {
2085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2086       };
2087     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
2088 }
2089
2090
2091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Disconnect(void * jarg1, void * jarg2) {
2092   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
2093   void (*arg2)(Dali::InputMethodContext::KeyboardType) = (void (*)(Dali::InputMethodContext::KeyboardType)) 0 ;
2094
2095   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
2096   arg2 = (void (*)(Dali::InputMethodContext::KeyboardType))jarg2;
2097   {
2098     try {
2099       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Disconnect(arg1,arg2);
2100     } catch (std::out_of_range& e) {
2101       {
2102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2103       };
2104     } catch (std::exception& e) {
2105       {
2106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2107       };
2108     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
2109 }
2110
2111
2112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Emit(void * jarg1, int jarg2) {
2113   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
2114   Dali::InputMethodContext::KeyboardType arg2 ;
2115
2116   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
2117   arg2 = (Dali::InputMethodContext::KeyboardType)jarg2;
2118   {
2119     try {
2120       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Emit(arg1,arg2);
2121     } catch (std::out_of_range& e) {
2122       {
2123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2124       };
2125     } catch (std::exception& e) {
2126       {
2127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2128       };
2129     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
2130 }
2131
2132
2133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyboardTypeSignalType() {
2134   void * jresult ;
2135   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *result = 0 ;
2136
2137   {
2138     try {
2139       result = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)new Dali::Signal< void (Dali::InputMethodContext::KeyboardType) >();
2140     } catch (std::out_of_range& e) {
2141       {
2142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2143       };
2144     } catch (std::exception& e) {
2145       {
2146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2147       };
2148     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
2149   jresult = (void *)result;
2150   return jresult;
2151 }
2152
2153
2154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyboardTypeSignalType(void * jarg1) {
2155   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
2156
2157   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
2158   {
2159     try {
2160       delete arg1;
2161     } catch (std::out_of_range& e) {
2162       {
2163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2164       };
2165     } catch (std::exception& e) {
2166       {
2167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2168       };
2169     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
2170 }
2171
2172 //LanguageChangedSignalType
2173
2174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Empty(void * jarg1) {
2175   unsigned int jresult ;
2176   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2177   bool result;
2178
2179   arg1 = (Dali::Signal< void (int) > *)jarg1;
2180   {
2181     try {
2182       result = (bool)Dali_Signal_Sl_void_Sp_int_SP__Sg__Empty((Dali::Signal< void (int) > const *)arg1);
2183     } catch (std::out_of_range& e) {
2184       {
2185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2186       };
2187     } catch (std::exception& e) {
2188       {
2189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2190       };
2191     } catch (...) {
2192       {
2193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2194       };
2195     }
2196   }
2197   jresult = result;
2198   return jresult;
2199 }
2200
2201
2202 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_GetConnectionCount(void * jarg1) {
2203   unsigned long jresult ;
2204   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2205   std::size_t result;
2206
2207   arg1 = (Dali::Signal< void (int) > *)jarg1;
2208   {
2209     try {
2210       result = Dali_Signal_Sl_void_Sp_int_SP__Sg__GetConnectionCount((Dali::Signal< void (int) > const *)arg1);
2211     } catch (std::out_of_range& e) {
2212       {
2213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2214       };
2215     } catch (std::exception& e) {
2216       {
2217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2218       };
2219     } catch (...) {
2220       {
2221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2222       };
2223     }
2224   }
2225   jresult = (unsigned long)result;
2226   return jresult;
2227 }
2228
2229
2230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Connect(void * jarg1, void * jarg2) {
2231   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2232   void (*arg2)(int) = (void (*)(int)) 0 ;
2233
2234   arg1 = (Dali::Signal< void (int) > *)jarg1;
2235   arg2 = (void (*)(int))jarg2;
2236   {
2237     try {
2238       Dali_Signal_Sl_void_Sp_int_SP__Sg__Connect(arg1,arg2);
2239     } catch (std::out_of_range& e) {
2240       {
2241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2242       };
2243     } catch (std::exception& e) {
2244       {
2245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2246       };
2247     } catch (...) {
2248       {
2249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2250       };
2251     }
2252   }
2253 }
2254
2255
2256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Disconnect(void * jarg1, void * jarg2) {
2257   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2258   void (*arg2)(int) = (void (*)(int)) 0 ;
2259
2260   arg1 = (Dali::Signal< void (int) > *)jarg1;
2261   arg2 = (void (*)(int))jarg2;
2262   {
2263     try {
2264       Dali_Signal_Sl_void_Sp_int_SP__Sg__Disconnect(arg1,arg2);
2265     } catch (std::out_of_range& e) {
2266       {
2267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2268       };
2269     } catch (std::exception& e) {
2270       {
2271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2272       };
2273     } catch (...) {
2274       {
2275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2276       };
2277     }
2278   }
2279 }
2280
2281
2282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Emit(void * jarg1, int jarg2) {
2283   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2284   int arg2 ;
2285
2286   arg1 = (Dali::Signal< void (int) > *)jarg1;
2287   arg2 = (int)jarg2;
2288   {
2289     try {
2290       Dali_Signal_Sl_void_Sp_int_SP__Sg__Emit(arg1,arg2);
2291     } catch (std::out_of_range& e) {
2292       {
2293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2294       };
2295     } catch (std::exception& e) {
2296       {
2297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2298       };
2299     } catch (...) {
2300       {
2301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2302       };
2303     }
2304   }
2305 }
2306
2307
2308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LanguageChangedSignalType() {
2309   void * jresult ;
2310   Dali::Signal< void (int) > *result = 0 ;
2311
2312   {
2313     try {
2314       result = (Dali::Signal< void (int) > *)new Dali::Signal< void (int) >();
2315     } catch (std::out_of_range& e) {
2316       {
2317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2318       };
2319     } catch (std::exception& e) {
2320       {
2321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2322       };
2323     } catch (...) {
2324       {
2325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2326       };
2327     }
2328   }
2329   jresult = (void *)result;
2330   return jresult;
2331 }
2332
2333
2334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LanguageChangedSignalType(void * jarg1) {
2335   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2336
2337   arg1 = (Dali::Signal< void (int) > *)jarg1;
2338   {
2339     try {
2340       delete arg1;
2341     } catch (std::out_of_range& e) {
2342       {
2343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2344       };
2345     } catch (std::exception& e) {
2346       {
2347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2348       };
2349     } catch (...) {
2350       {
2351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2352       };
2353     }
2354   }
2355 }
2356
2357 //KeyboardTypeSignalType
2358
2359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Empty(void * jarg1) {
2360   unsigned int jresult ;
2361   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2362   bool result;
2363
2364   arg1 = (Dali::Signal< void (int) > *)jarg1;
2365   {
2366     try {
2367       result = (bool)Dali_Signal_Sl_void_Sp_int_SP__Sg__Empty((Dali::Signal< void (int) > const *)arg1);
2368     } catch (std::out_of_range& e) {
2369       {
2370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2371       };
2372     } catch (std::exception& e) {
2373       {
2374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2375       };
2376     } catch (...) {
2377       {
2378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2379       };
2380     }
2381   }
2382   jresult = result;
2383   return jresult;
2384 }
2385
2386
2387 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_GetConnectionCount(void * jarg1) {
2388   unsigned long jresult ;
2389   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2390   std::size_t result;
2391
2392   arg1 = (Dali::Signal< void (int) > *)jarg1;
2393   {
2394     try {
2395       result = Dali_Signal_Sl_void_Sp_int_SP__Sg__GetConnectionCount((Dali::Signal< void (int) > const *)arg1);
2396     } catch (std::out_of_range& e) {
2397       {
2398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2399       };
2400     } catch (std::exception& e) {
2401       {
2402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2403       };
2404     } catch (...) {
2405       {
2406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2407       };
2408     }
2409   }
2410   jresult = (unsigned long)result;
2411   return jresult;
2412 }
2413
2414
2415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Connect(void * jarg1, void * jarg2) {
2416   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2417   void (*arg2)(int) = (void (*)(int)) 0 ;
2418
2419   arg1 = (Dali::Signal< void (int) > *)jarg1;
2420   arg2 = (void (*)(int))jarg2;
2421   {
2422     try {
2423       Dali_Signal_Sl_void_Sp_int_SP__Sg__Connect(arg1,arg2);
2424     } catch (std::out_of_range& e) {
2425       {
2426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2427       };
2428     } catch (std::exception& e) {
2429       {
2430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2431       };
2432     } catch (...) {
2433       {
2434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2435       };
2436     }
2437   }
2438 }
2439
2440
2441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Disconnect(void * jarg1, void * jarg2) {
2442   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2443   void (*arg2)(int) = (void (*)(int)) 0 ;
2444
2445   arg1 = (Dali::Signal< void (int) > *)jarg1;
2446   arg2 = (void (*)(int))jarg2;
2447   {
2448     try {
2449       Dali_Signal_Sl_void_Sp_int_SP__Sg__Disconnect(arg1,arg2);
2450     } catch (std::out_of_range& e) {
2451       {
2452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2453       };
2454     } catch (std::exception& e) {
2455       {
2456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2457       };
2458     } catch (...) {
2459       {
2460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2461       };
2462     }
2463   }
2464 }
2465
2466
2467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Emit(void * jarg1, int jarg2) {
2468   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2469   int arg2 ;
2470
2471   arg1 = (Dali::Signal< void (int) > *)jarg1;
2472   arg2 = (int)jarg2;
2473   {
2474     try {
2475       Dali_Signal_Sl_void_Sp_int_SP__Sg__Emit(arg1,arg2);
2476     } catch (std::out_of_range& e) {
2477       {
2478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2479       };
2480     } catch (std::exception& e) {
2481       {
2482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2483       };
2484     } catch (...) {
2485       {
2486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2487       };
2488     }
2489   }
2490 }
2491
2492
2493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyboardResizedSignalType() {
2494   void * jresult ;
2495   Dali::Signal< void (int) > *result = 0 ;
2496
2497   {
2498     try {
2499       result = (Dali::Signal< void (int) > *)new Dali::Signal< void (int) >();
2500     } catch (std::out_of_range& e) {
2501       {
2502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2503       };
2504     } catch (std::exception& e) {
2505       {
2506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2507       };
2508     } catch (...) {
2509       {
2510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2511       };
2512     }
2513   }
2514   jresult = (void *)result;
2515   return jresult;
2516 }
2517
2518
2519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyboardResizedSignalType(void * jarg1) {
2520   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2521
2522   arg1 = (Dali::Signal< void (int) > *)jarg1;
2523   {
2524     try {
2525       delete arg1;
2526     } catch (std::out_of_range& e) {
2527       {
2528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2529       };
2530     } catch (std::exception& e) {
2531       {
2532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2533       };
2534     } catch (...) {
2535       {
2536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2537       };
2538     }
2539   }
2540 }
2541
2542 #ifdef __cplusplus
2543 }
2544 #endif
2545