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
1172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_ActivatedSignal(void * jarg1) {
1173   void * jresult ;
1174   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1175   Dali::InputMethodContext::ActivatedSignalType *result = 0 ;
1176
1177   arg1 = (Dali::InputMethodContext *)jarg1;
1178   {
1179     try {
1180       result = (Dali::InputMethodContext::ActivatedSignalType *) &(arg1)->ActivatedSignal();
1181     } catch (std::out_of_range& e) {
1182       {
1183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1184       };
1185     } catch (std::exception& e) {
1186       {
1187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1188       };
1189     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1190   jresult = (void *)result;
1191   return jresult;
1192 }
1193
1194
1195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_EventReceivedSignal(void * jarg1) {
1196   void * jresult ;
1197   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1198   Dali::InputMethodContext::KeyboardEventSignalType *result = 0 ;
1199
1200   arg1 = (Dali::InputMethodContext *)jarg1;
1201   {
1202     try {
1203       result = (Dali::InputMethodContext::KeyboardEventSignalType *) &(arg1)->EventReceivedSignal();
1204     } catch (std::out_of_range& e) {
1205       {
1206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1207       };
1208     } catch (std::exception& e) {
1209       {
1210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1211       };
1212     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1213   jresult = (void *)result;
1214   return jresult;
1215 }
1216
1217
1218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_StatusChangedSignal(void * jarg1) {
1219   void * jresult ;
1220   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1221   Dali::InputMethodContext::StatusSignalType *result = 0 ;
1222
1223   arg1 = (Dali::InputMethodContext *)jarg1;
1224   {
1225     try {
1226       result = (Dali::InputMethodContext::StatusSignalType *) &(arg1)->StatusChangedSignal();
1227     } catch (std::out_of_range& e) {
1228       {
1229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1230       };
1231     } catch (std::exception& e) {
1232       {
1233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1234       };
1235     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1236   jresult = (void *)result;
1237   return jresult;
1238 }
1239
1240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_ResizedSignal(void * jarg1) {
1241   void * jresult ;
1242   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1243   Dali::InputMethodContext::KeyboardResizedSignalType *result = 0 ;
1244
1245   arg1 = (Dali::InputMethodContext *)jarg1;
1246   {
1247     try {
1248       result = (Dali::InputMethodContext::KeyboardResizedSignalType *) &(arg1)->ResizedSignal();
1249     } catch (std::out_of_range& e) {
1250       {
1251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1252       };
1253     } catch (std::exception& e) {
1254       {
1255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1256       };
1257     } catch (...) {
1258       {
1259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1260       };
1261     }
1262   }
1263   jresult = (void *)result;
1264   return jresult;
1265 }
1266
1267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_LanguageChangedSignal(void * jarg1) {
1268   void * jresult ;
1269   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1270   Dali::InputMethodContext::LanguageChangedSignalType *result = 0 ;
1271
1272   arg1 = (Dali::InputMethodContext *)jarg1;
1273   {
1274     try {
1275       result = (Dali::InputMethodContext::LanguageChangedSignalType *) &(arg1)->LanguageChangedSignal();
1276     } catch (std::out_of_range& e) {
1277       {
1278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1279       };
1280     } catch (std::exception& e) {
1281       {
1282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1283       };
1284     } catch (...) {
1285       {
1286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1287       };
1288     }
1289   }
1290   jresult = (void *)result;
1291   return jresult;
1292 }
1293
1294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_KeyboardTypeChangedSignal(void * jarg1) {
1295   void * jresult ;
1296   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1297   Dali::InputMethodContext::KeyboardTypeSignalType *result = 0 ;
1298
1299   arg1 = (Dali::InputMethodContext *)jarg1;
1300   {
1301     try {
1302       result = (Dali::InputMethodContext::KeyboardTypeSignalType *) &(arg1)->KeyboardTypeChangedSignal();
1303     } catch (std::out_of_range& e) {
1304       {
1305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1306       };
1307     } catch (std::exception& e) {
1308       {
1309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1310       };
1311     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1312   jresult = (void *)result;
1313   return jresult;
1314 }
1315
1316 // ActivatedSignalType
1317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Empty(void * jarg1) {
1318   unsigned int jresult ;
1319   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1320   bool result;
1321
1322   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1323   {
1324     try {
1325       result = (bool)Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Empty((Dali::Signal< void (Dali::InputMethodContext &) > const *)arg1);
1326     } catch (std::out_of_range& e) {
1327       {
1328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1329       };
1330     } catch (std::exception& e) {
1331       {
1332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1333       };
1334     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1335   jresult = result;
1336   return jresult;
1337 }
1338
1339
1340 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActivatedSignalType_GetConnectionCount(void * jarg1) {
1341   unsigned long jresult ;
1342   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1343   std::size_t result;
1344
1345   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1346   {
1347     try {
1348       result = Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::InputMethodContext &) > const *)arg1);
1349     } catch (std::out_of_range& e) {
1350       {
1351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1352       };
1353     } catch (std::exception& e) {
1354       {
1355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1356       };
1357     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1358   jresult = (unsigned long)result;
1359   return jresult;
1360 }
1361
1362
1363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Connect(void * jarg1, void * jarg2) {
1364   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1365   void (*arg2)(Dali::InputMethodContext &) = (void (*)(Dali::InputMethodContext &)) 0 ;
1366
1367   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1368   arg2 = (void (*)(Dali::InputMethodContext &))jarg2;
1369   {
1370     try {
1371       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Connect(arg1,arg2);
1372     } catch (std::out_of_range& e) {
1373       {
1374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1375       };
1376     } catch (std::exception& e) {
1377       {
1378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1379       };
1380     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1381 }
1382
1383
1384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Disconnect(void * jarg1, void * jarg2) {
1385   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1386   void (*arg2)(Dali::InputMethodContext &) = (void (*)(Dali::InputMethodContext &)) 0 ;
1387
1388   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1389   arg2 = (void (*)(Dali::InputMethodContext &))jarg2;
1390   {
1391     try {
1392       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Disconnect(arg1,arg2);
1393     } catch (std::out_of_range& e) {
1394       {
1395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1396       };
1397     } catch (std::exception& e) {
1398       {
1399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1400       };
1401     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1402 }
1403
1404
1405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Emit(void * jarg1, void * jarg2) {
1406   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1407   Dali::InputMethodContext *arg2 = 0 ;
1408
1409   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1410   arg2 = (Dali::InputMethodContext *)jarg2;
1411   if (!arg2) {
1412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext & type is null", 0);
1413     return ;
1414   }
1415   {
1416     try {
1417       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Emit(arg1,*arg2);
1418     } catch (std::out_of_range& e) {
1419       {
1420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1421       };
1422     } catch (std::exception& e) {
1423       {
1424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1425       };
1426     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1427 }
1428
1429
1430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActivatedSignalType() {
1431   void * jresult ;
1432   Dali::Signal< void (Dali::InputMethodContext &) > *result = 0 ;
1433
1434   {
1435     try {
1436       result = (Dali::Signal< void (Dali::InputMethodContext &) > *)new Dali::Signal< void (Dali::InputMethodContext &) >();
1437     } catch (std::out_of_range& e) {
1438       {
1439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1440       };
1441     } catch (std::exception& e) {
1442       {
1443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1444       };
1445     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1446   jresult = (void *)result;
1447   return jresult;
1448 }
1449
1450
1451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActivatedSignalType(void * jarg1) {
1452   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1453
1454   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1455   {
1456     try {
1457       delete arg1;
1458     } catch (std::out_of_range& e) {
1459       {
1460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1461       };
1462     } catch (std::exception& e) {
1463       {
1464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1465       };
1466     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1467 }
1468
1469 // KeyboardEventSignalType
1470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Empty(void * jarg1) {
1471   unsigned int jresult ;
1472   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1473   bool result;
1474
1475   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1476   {
1477     try {
1478       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);
1479     } catch (std::out_of_range& e) {
1480       {
1481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1482       };
1483     } catch (std::exception& e) {
1484       {
1485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1486       };
1487     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1488   jresult = result;
1489   return jresult;
1490 }
1491
1492
1493 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_GetConnectionCount(void * jarg1) {
1494   unsigned long jresult ;
1495   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1496   std::size_t result;
1497
1498   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1499   {
1500     try {
1501       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);
1502     } catch (std::out_of_range& e) {
1503       {
1504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1505       };
1506     } catch (std::exception& e) {
1507       {
1508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1509       };
1510     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1511   jresult = (unsigned long)result;
1512   return jresult;
1513 }
1514
1515 typedef Dali::InputMethodContext::CallbackData* (SWIGSTDCALL* SWIG_CallbackEventReceived)(Dali::InputMethodContext *, Dali::InputMethodContext::EventData *);
1516 SWIG_CallbackEventReceived swig_callbackOnEventReceived;
1517
1518 Dali::InputMethodContext::CallbackData OnEventReceivedCallback(Dali::InputMethodContext inputMethodContext, Dali::InputMethodContext::EventData eventData)
1519 {
1520     Dali::InputMethodContext::CallbackData *callbackDataP;
1521     Dali::InputMethodContext::CallbackData callbackData;
1522     Dali::InputMethodContext *inputMethodContextP = NULL;
1523     Dali::InputMethodContext::EventData *eventDataP = NULL;
1524
1525     if (inputMethodContext)
1526     {
1527       inputMethodContextP = (Dali::InputMethodContext *)&inputMethodContext;
1528     }
1529
1530     eventDataP = (Dali::InputMethodContext::EventData *)&eventData;
1531
1532     callbackDataP = (Dali::InputMethodContext::CallbackData *)swig_callbackOnEventReceived(inputMethodContextP, eventDataP);
1533     if (callbackDataP)
1534     {
1535       callbackData = *callbackDataP;
1536     }
1537
1538     return callbackData;
1539 }
1540
1541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Connect(void * jarg1, SWIG_CallbackEventReceived callbackOnEventReceived) {
1542
1543   swig_callbackOnEventReceived = callbackOnEventReceived;
1544
1545   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1546   Dali::InputMethodContext::CallbackData (*arg2)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &)) 0 ;
1547
1548   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1549   arg2 = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &))OnEventReceivedCallback;
1550   {
1551     try {
1552       Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
1553     } catch (std::out_of_range& e) {
1554       {
1555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1556       };
1557     } catch (std::exception& e) {
1558       {
1559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1560       };
1561     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1562 }
1563
1564
1565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Disconnect(void * jarg1, SWIG_CallbackEventReceived callbackOnEventReceived) {
1566
1567   swig_callbackOnEventReceived = callbackOnEventReceived;
1568
1569   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1570   Dali::InputMethodContext::CallbackData (*arg2)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &)) 0 ;
1571
1572   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1573   arg2 = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &))OnEventReceivedCallback;
1574   {
1575     try {
1576       Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
1577     } catch (std::out_of_range& e) {
1578       {
1579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1580       };
1581     } catch (std::exception& e) {
1582       {
1583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1584       };
1585     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1586 }
1587
1588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Emit(void * jarg1, void * jarg2, void * jarg3) {
1589   void * jresult ;
1590   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1591   Dali::InputMethodContext *arg2 = 0 ;
1592   Dali::InputMethodContext::EventData *arg3 = 0 ;
1593   Dali::InputMethodContext::CallbackData result;
1594
1595   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1596   arg2 = (Dali::InputMethodContext *)jarg2;
1597   if (!arg2) {
1598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext & type is null", 0);
1599     return 0;
1600   }
1601   arg3 = (Dali::InputMethodContext::EventData *)jarg3;
1602   if (!arg3) {
1603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext::EventData const & type is null", 0);
1604     return 0;
1605   }
1606   {
1607     try {
1608       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);
1609     } catch (std::out_of_range& e) {
1610       {
1611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1612       };
1613     } catch (std::exception& e) {
1614       {
1615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1616       };
1617     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1618   jresult = new Dali::InputMethodContext::CallbackData((const Dali::InputMethodContext::CallbackData &)result);
1619   return jresult;
1620 }
1621
1622
1623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyboardEventSignalType() {
1624   void * jresult ;
1625   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *result = 0 ;
1626
1627   {
1628     try {
1629       result = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)new Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) >();
1630     } catch (std::out_of_range& e) {
1631       {
1632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1633       };
1634     } catch (std::exception& e) {
1635       {
1636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1637       };
1638     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1639   jresult = (void *)result;
1640   return jresult;
1641 }
1642
1643
1644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyboardEventSignalType(void * jarg1) {
1645   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1646
1647   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1648   {
1649     try {
1650       delete arg1;
1651     } catch (std::out_of_range& e) {
1652       {
1653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1654       };
1655     } catch (std::exception& e) {
1656       {
1657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1658       };
1659     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1660 }
1661
1662
1663 // VoidSignalType
1664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignalType() {
1665   void * jresult ;
1666   Dali::Signal< void () > *result = 0 ;
1667
1668   {
1669     try {
1670       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
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_VoidSignalType(void * jarg1) {
1686   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1687
1688   arg1 = (Dali::Signal< void () > *)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 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignalType_Empty(void * jarg1) {
1705   unsigned int jresult ;
1706   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1707   bool result;
1708
1709   arg1 = (Dali::Signal< void () > *)jarg1;
1710   {
1711     try {
1712       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
1713     } catch (std::out_of_range& e) {
1714       {
1715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1716       };
1717     } catch (std::exception& e) {
1718       {
1719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1720       };
1721     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1722   jresult = result;
1723   return jresult;
1724 }
1725
1726
1727 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignalType_GetConnectionCount(void * jarg1) {
1728   unsigned long jresult ;
1729   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1730   std::size_t result;
1731
1732   arg1 = (Dali::Signal< void () > *)jarg1;
1733   {
1734     try {
1735       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
1736     } catch (std::out_of_range& e) {
1737       {
1738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1739       };
1740     } catch (std::exception& e) {
1741       {
1742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1743       };
1744     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1745   jresult = (unsigned long)result;
1746   return jresult;
1747 }
1748
1749
1750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Connect__SWIG_0(void * jarg1, void * jarg2) {
1751   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1752   void (*arg2)() = (void (*)()) 0 ;
1753
1754   arg1 = (Dali::Signal< void () > *)jarg1;
1755   arg2 = (void (*)())jarg2;
1756   {
1757     try {
1758       (arg1)->Connect(arg2);
1759     } catch (std::out_of_range& e) {
1760       {
1761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1762       };
1763     } catch (std::exception& e) {
1764       {
1765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1766       };
1767     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1768 }
1769
1770
1771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Disconnect(void * jarg1, void * jarg2) {
1772   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1773   void (*arg2)() = (void (*)()) 0 ;
1774
1775   arg1 = (Dali::Signal< void () > *)jarg1;
1776   arg2 = (void (*)())jarg2;
1777   {
1778     try {
1779       (arg1)->Disconnect(arg2);
1780     } catch (std::out_of_range& e) {
1781       {
1782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1783       };
1784     } catch (std::exception& e) {
1785       {
1786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1787       };
1788     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1789 }
1790
1791
1792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
1793   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1794   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
1795   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
1796
1797   arg1 = (Dali::Signal< void () > *)jarg1;
1798   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
1799   arg3 = (Dali::FunctorDelegate *)jarg3;
1800   {
1801     try {
1802       (arg1)->Connect(arg2,arg3);
1803     } catch (std::out_of_range& e) {
1804       {
1805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1806       };
1807     } catch (std::exception& e) {
1808       {
1809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1810       };
1811     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1812 }
1813
1814
1815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Emit(void * jarg1) {
1816   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1817
1818   arg1 = (Dali::Signal< void () > *)jarg1;
1819   {
1820     try {
1821       (arg1)->Emit();
1822     } catch (std::out_of_range& e) {
1823       {
1824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1825       };
1826     } catch (std::exception& e) {
1827       {
1828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1829       };
1830     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1831 }
1832
1833 //StatusSignalType
1834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StatusSignalType_Empty(void * jarg1) {
1835   unsigned int jresult ;
1836   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1837   bool result;
1838
1839   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1840   {
1841     try {
1842       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
1843     } catch (std::out_of_range& e) {
1844       {
1845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1846       };
1847     } catch (std::exception& e) {
1848       {
1849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1850       };
1851     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1852   jresult = result;
1853   return jresult;
1854 }
1855
1856
1857 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StatusSignalType_GetConnectionCount(void * jarg1) {
1858   unsigned long jresult ;
1859   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1860   std::size_t result;
1861
1862   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1863   {
1864     try {
1865       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
1866     } catch (std::out_of_range& e) {
1867       {
1868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1869       };
1870     } catch (std::exception& e) {
1871       {
1872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1873       };
1874     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1875   jresult = (unsigned long)result;
1876   return jresult;
1877 }
1878
1879
1880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Connect(void * jarg1, void * jarg2) {
1881   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1882   void (*arg2)(bool) = (void (*)(bool)) 0 ;
1883
1884   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1885   arg2 = (void (*)(bool))jarg2;
1886   {
1887     try {
1888       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
1889     } catch (std::out_of_range& e) {
1890       {
1891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1892       };
1893     } catch (std::exception& e) {
1894       {
1895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1896       };
1897     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1898 }
1899
1900
1901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Disconnect(void * jarg1, void * jarg2) {
1902   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1903   void (*arg2)(bool) = (void (*)(bool)) 0 ;
1904
1905   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1906   arg2 = (void (*)(bool))jarg2;
1907   {
1908     try {
1909       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
1910     } catch (std::out_of_range& e) {
1911       {
1912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1913       };
1914     } catch (std::exception& e) {
1915       {
1916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1917       };
1918     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1919 }
1920
1921
1922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Emit(void * jarg1, unsigned int jarg2) {
1923   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1924   bool arg2 ;
1925
1926   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1927   arg2 = jarg2 ? true : false;
1928   {
1929     try {
1930       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
1931     } catch (std::out_of_range& e) {
1932       {
1933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1934       };
1935     } catch (std::exception& e) {
1936       {
1937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1938       };
1939     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1940 }
1941
1942
1943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StatusSignalType() {
1944   void * jresult ;
1945   Dali::Signal< void (bool) > *result = 0 ;
1946
1947   {
1948     try {
1949       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
1950     } catch (std::out_of_range& e) {
1951       {
1952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1953       };
1954     } catch (std::exception& e) {
1955       {
1956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1957       };
1958     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1959   jresult = (void *)result;
1960   return jresult;
1961 }
1962
1963
1964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StatusSignalType(void * jarg1) {
1965   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1966
1967   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1968   {
1969     try {
1970       delete arg1;
1971     } catch (std::out_of_range& e) {
1972       {
1973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1974       };
1975     } catch (std::exception& e) {
1976       {
1977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1978       };
1979     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1980 }
1981
1982 //KeyboardTypeSignalType
1983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Empty(void * jarg1) {
1984   unsigned int jresult ;
1985   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
1986   bool result;
1987
1988   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
1989   {
1990     try {
1991       result = (bool)Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Empty((Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > const *)arg1);
1992     } catch (std::out_of_range& e) {
1993       {
1994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1995       };
1996     } catch (std::exception& e) {
1997       {
1998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1999       };
2000     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
2001   jresult = result;
2002   return jresult;
2003 }
2004
2005
2006 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_GetConnectionCount(void * jarg1) {
2007   unsigned long jresult ;
2008   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
2009   std::size_t result;
2010
2011   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
2012   {
2013     try {
2014       result = Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > const *)arg1);
2015     } catch (std::out_of_range& e) {
2016       {
2017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2018       };
2019     } catch (std::exception& e) {
2020       {
2021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2022       };
2023     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
2024   jresult = (unsigned long)result;
2025   return jresult;
2026 }
2027
2028
2029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Connect(void * jarg1, void * jarg2) {
2030   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
2031   void (*arg2)(Dali::InputMethodContext::KeyboardType) = (void (*)(Dali::InputMethodContext::KeyboardType)) 0 ;
2032
2033   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
2034   arg2 = (void (*)(Dali::InputMethodContext::KeyboardType))jarg2;
2035   {
2036     try {
2037       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Connect(arg1,arg2);
2038     } catch (std::out_of_range& e) {
2039       {
2040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2041       };
2042     } catch (std::exception& e) {
2043       {
2044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2045       };
2046     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
2047 }
2048
2049
2050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Disconnect(void * jarg1, void * jarg2) {
2051   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
2052   void (*arg2)(Dali::InputMethodContext::KeyboardType) = (void (*)(Dali::InputMethodContext::KeyboardType)) 0 ;
2053
2054   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
2055   arg2 = (void (*)(Dali::InputMethodContext::KeyboardType))jarg2;
2056   {
2057     try {
2058       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Disconnect(arg1,arg2);
2059     } catch (std::out_of_range& e) {
2060       {
2061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2062       };
2063     } catch (std::exception& e) {
2064       {
2065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2066       };
2067     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
2068 }
2069
2070
2071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Emit(void * jarg1, int jarg2) {
2072   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
2073   Dali::InputMethodContext::KeyboardType arg2 ;
2074
2075   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
2076   arg2 = (Dali::InputMethodContext::KeyboardType)jarg2;
2077   {
2078     try {
2079       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Emit(arg1,arg2);
2080     } catch (std::out_of_range& e) {
2081       {
2082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2083       };
2084     } catch (std::exception& e) {
2085       {
2086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2087       };
2088     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
2089 }
2090
2091
2092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyboardTypeSignalType() {
2093   void * jresult ;
2094   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *result = 0 ;
2095
2096   {
2097     try {
2098       result = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)new Dali::Signal< void (Dali::InputMethodContext::KeyboardType) >();
2099     } catch (std::out_of_range& e) {
2100       {
2101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2102       };
2103     } catch (std::exception& e) {
2104       {
2105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2106       };
2107     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
2108   jresult = (void *)result;
2109   return jresult;
2110 }
2111
2112
2113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyboardTypeSignalType(void * jarg1) {
2114   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
2115
2116   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
2117   {
2118     try {
2119       delete arg1;
2120     } catch (std::out_of_range& e) {
2121       {
2122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2123       };
2124     } catch (std::exception& e) {
2125       {
2126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2127       };
2128     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
2129 }
2130
2131 //LanguageChangedSignalType
2132
2133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Empty(void * jarg1) {
2134   unsigned int jresult ;
2135   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2136   bool result;
2137
2138   arg1 = (Dali::Signal< void (int) > *)jarg1;
2139   {
2140     try {
2141       result = (bool)Dali_Signal_Sl_void_Sp_int_SP__Sg__Empty((Dali::Signal< void (int) > const *)arg1);
2142     } catch (std::out_of_range& e) {
2143       {
2144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2145       };
2146     } catch (std::exception& e) {
2147       {
2148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2149       };
2150     } catch (...) {
2151       {
2152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2153       };
2154     }
2155   }
2156   jresult = result;
2157   return jresult;
2158 }
2159
2160
2161 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_GetConnectionCount(void * jarg1) {
2162   unsigned long jresult ;
2163   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2164   std::size_t result;
2165
2166   arg1 = (Dali::Signal< void (int) > *)jarg1;
2167   {
2168     try {
2169       result = Dali_Signal_Sl_void_Sp_int_SP__Sg__GetConnectionCount((Dali::Signal< void (int) > const *)arg1);
2170     } catch (std::out_of_range& e) {
2171       {
2172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2173       };
2174     } catch (std::exception& e) {
2175       {
2176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2177       };
2178     } catch (...) {
2179       {
2180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2181       };
2182     }
2183   }
2184   jresult = (unsigned long)result;
2185   return jresult;
2186 }
2187
2188
2189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Connect(void * jarg1, void * jarg2) {
2190   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2191   void (*arg2)(int) = (void (*)(int)) 0 ;
2192
2193   arg1 = (Dali::Signal< void (int) > *)jarg1;
2194   arg2 = (void (*)(int))jarg2;
2195   {
2196     try {
2197       Dali_Signal_Sl_void_Sp_int_SP__Sg__Connect(arg1,arg2);
2198     } catch (std::out_of_range& e) {
2199       {
2200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2201       };
2202     } catch (std::exception& e) {
2203       {
2204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2205       };
2206     } catch (...) {
2207       {
2208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2209       };
2210     }
2211   }
2212 }
2213
2214
2215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Disconnect(void * jarg1, void * jarg2) {
2216   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2217   void (*arg2)(int) = (void (*)(int)) 0 ;
2218
2219   arg1 = (Dali::Signal< void (int) > *)jarg1;
2220   arg2 = (void (*)(int))jarg2;
2221   {
2222     try {
2223       Dali_Signal_Sl_void_Sp_int_SP__Sg__Disconnect(arg1,arg2);
2224     } catch (std::out_of_range& e) {
2225       {
2226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2227       };
2228     } catch (std::exception& e) {
2229       {
2230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2231       };
2232     } catch (...) {
2233       {
2234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2235       };
2236     }
2237   }
2238 }
2239
2240
2241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Emit(void * jarg1, int jarg2) {
2242   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2243   int arg2 ;
2244
2245   arg1 = (Dali::Signal< void (int) > *)jarg1;
2246   arg2 = (int)jarg2;
2247   {
2248     try {
2249       Dali_Signal_Sl_void_Sp_int_SP__Sg__Emit(arg1,arg2);
2250     } catch (std::out_of_range& e) {
2251       {
2252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2253       };
2254     } catch (std::exception& e) {
2255       {
2256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2257       };
2258     } catch (...) {
2259       {
2260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2261       };
2262     }
2263   }
2264 }
2265
2266
2267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LanguageChangedSignalType() {
2268   void * jresult ;
2269   Dali::Signal< void (int) > *result = 0 ;
2270
2271   {
2272     try {
2273       result = (Dali::Signal< void (int) > *)new Dali::Signal< void (int) >();
2274     } catch (std::out_of_range& e) {
2275       {
2276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2277       };
2278     } catch (std::exception& e) {
2279       {
2280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2281       };
2282     } catch (...) {
2283       {
2284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2285       };
2286     }
2287   }
2288   jresult = (void *)result;
2289   return jresult;
2290 }
2291
2292
2293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LanguageChangedSignalType(void * jarg1) {
2294   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2295
2296   arg1 = (Dali::Signal< void (int) > *)jarg1;
2297   {
2298     try {
2299       delete arg1;
2300     } catch (std::out_of_range& e) {
2301       {
2302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2303       };
2304     } catch (std::exception& e) {
2305       {
2306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2307       };
2308     } catch (...) {
2309       {
2310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2311       };
2312     }
2313   }
2314 }
2315
2316 //KeyboardTypeSignalType
2317
2318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Empty(void * jarg1) {
2319   unsigned int jresult ;
2320   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2321   bool result;
2322
2323   arg1 = (Dali::Signal< void (int) > *)jarg1;
2324   {
2325     try {
2326       result = (bool)Dali_Signal_Sl_void_Sp_int_SP__Sg__Empty((Dali::Signal< void (int) > const *)arg1);
2327     } catch (std::out_of_range& e) {
2328       {
2329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2330       };
2331     } catch (std::exception& e) {
2332       {
2333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2334       };
2335     } catch (...) {
2336       {
2337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2338       };
2339     }
2340   }
2341   jresult = result;
2342   return jresult;
2343 }
2344
2345
2346 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_GetConnectionCount(void * jarg1) {
2347   unsigned long jresult ;
2348   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2349   std::size_t result;
2350
2351   arg1 = (Dali::Signal< void (int) > *)jarg1;
2352   {
2353     try {
2354       result = Dali_Signal_Sl_void_Sp_int_SP__Sg__GetConnectionCount((Dali::Signal< void (int) > const *)arg1);
2355     } catch (std::out_of_range& e) {
2356       {
2357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2358       };
2359     } catch (std::exception& e) {
2360       {
2361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2362       };
2363     } catch (...) {
2364       {
2365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2366       };
2367     }
2368   }
2369   jresult = (unsigned long)result;
2370   return jresult;
2371 }
2372
2373
2374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Connect(void * jarg1, void * jarg2) {
2375   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2376   void (*arg2)(int) = (void (*)(int)) 0 ;
2377
2378   arg1 = (Dali::Signal< void (int) > *)jarg1;
2379   arg2 = (void (*)(int))jarg2;
2380   {
2381     try {
2382       Dali_Signal_Sl_void_Sp_int_SP__Sg__Connect(arg1,arg2);
2383     } catch (std::out_of_range& e) {
2384       {
2385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2386       };
2387     } catch (std::exception& e) {
2388       {
2389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2390       };
2391     } catch (...) {
2392       {
2393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2394       };
2395     }
2396   }
2397 }
2398
2399
2400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Disconnect(void * jarg1, void * jarg2) {
2401   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2402   void (*arg2)(int) = (void (*)(int)) 0 ;
2403
2404   arg1 = (Dali::Signal< void (int) > *)jarg1;
2405   arg2 = (void (*)(int))jarg2;
2406   {
2407     try {
2408       Dali_Signal_Sl_void_Sp_int_SP__Sg__Disconnect(arg1,arg2);
2409     } catch (std::out_of_range& e) {
2410       {
2411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2412       };
2413     } catch (std::exception& e) {
2414       {
2415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2416       };
2417     } catch (...) {
2418       {
2419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2420       };
2421     }
2422   }
2423 }
2424
2425
2426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Emit(void * jarg1, int jarg2) {
2427   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2428   int arg2 ;
2429
2430   arg1 = (Dali::Signal< void (int) > *)jarg1;
2431   arg2 = (int)jarg2;
2432   {
2433     try {
2434       Dali_Signal_Sl_void_Sp_int_SP__Sg__Emit(arg1,arg2);
2435     } catch (std::out_of_range& e) {
2436       {
2437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2438       };
2439     } catch (std::exception& e) {
2440       {
2441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2442       };
2443     } catch (...) {
2444       {
2445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2446       };
2447     }
2448   }
2449 }
2450
2451
2452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyboardResizedSignalType() {
2453   void * jresult ;
2454   Dali::Signal< void (int) > *result = 0 ;
2455
2456   {
2457     try {
2458       result = (Dali::Signal< void (int) > *)new Dali::Signal< void (int) >();
2459     } catch (std::out_of_range& e) {
2460       {
2461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2462       };
2463     } catch (std::exception& e) {
2464       {
2465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2466       };
2467     } catch (...) {
2468       {
2469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2470       };
2471     }
2472   }
2473   jresult = (void *)result;
2474   return jresult;
2475 }
2476
2477
2478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyboardResizedSignalType(void * jarg1) {
2479   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2480
2481   arg1 = (Dali::Signal< void (int) > *)jarg1;
2482   {
2483     try {
2484       delete arg1;
2485     } catch (std::out_of_range& e) {
2486       {
2487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2488       };
2489     } catch (std::exception& e) {
2490       {
2491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2492       };
2493     } catch (...) {
2494       {
2495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2496       };
2497     }
2498   }
2499 }
2500
2501 #ifdef __cplusplus
2502 }
2503 #endif
2504