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