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