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 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetInputPanelPosition(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
1258   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1259   unsigned int arg2 ;
1260   unsigned int arg3 ;
1261
1262   arg1 = (Dali::InputMethodContext *)jarg1;
1263   arg2 = (unsigned int)jarg2;
1264   arg3 = (unsigned int)jarg3;
1265   {
1266     try {
1267       (arg1)->SetInputPanelPosition(arg2, arg3);
1268     } catch (std::out_of_range& e) {
1269       {
1270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1271       };
1272     } catch (std::exception& e) {
1273       {
1274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1275       };
1276     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1277 }
1278
1279
1280 // Signals
1281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_ActivatedSignal(void * jarg1) {
1282   void * jresult ;
1283   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1284   Dali::InputMethodContext::ActivatedSignalType *result = 0 ;
1285
1286   arg1 = (Dali::InputMethodContext *)jarg1;
1287   {
1288     try {
1289       result = (Dali::InputMethodContext::ActivatedSignalType *) &(arg1)->ActivatedSignal();
1290     } catch (std::out_of_range& e) {
1291       {
1292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1293       };
1294     } catch (std::exception& e) {
1295       {
1296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1297       };
1298     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1299   jresult = (void *)result;
1300   return jresult;
1301 }
1302
1303
1304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_EventReceivedSignal(void * jarg1) {
1305   void * jresult ;
1306   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1307   Dali::InputMethodContext::KeyboardEventSignalType *result = 0 ;
1308
1309   arg1 = (Dali::InputMethodContext *)jarg1;
1310   {
1311     try {
1312       result = (Dali::InputMethodContext::KeyboardEventSignalType *) &(arg1)->EventReceivedSignal();
1313     } catch (std::out_of_range& e) {
1314       {
1315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1316       };
1317     } catch (std::exception& e) {
1318       {
1319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1320       };
1321     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1322   jresult = (void *)result;
1323   return jresult;
1324 }
1325
1326
1327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_StatusChangedSignal(void * jarg1) {
1328   void * jresult ;
1329   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1330   Dali::InputMethodContext::StatusSignalType *result = 0 ;
1331
1332   arg1 = (Dali::InputMethodContext *)jarg1;
1333   {
1334     try {
1335       result = (Dali::InputMethodContext::StatusSignalType *) &(arg1)->StatusChangedSignal();
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 (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1345   jresult = (void *)result;
1346   return jresult;
1347 }
1348
1349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_ResizedSignal(void * jarg1) {
1350   void * jresult ;
1351   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1352   Dali::InputMethodContext::KeyboardResizedSignalType *result = 0 ;
1353
1354   arg1 = (Dali::InputMethodContext *)jarg1;
1355   {
1356     try {
1357       result = (Dali::InputMethodContext::KeyboardResizedSignalType *) &(arg1)->ResizedSignal();
1358     } catch (std::out_of_range& e) {
1359       {
1360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1361       };
1362     } catch (std::exception& e) {
1363       {
1364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1365       };
1366     } catch (...) {
1367       {
1368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1369       };
1370     }
1371   }
1372   jresult = (void *)result;
1373   return jresult;
1374 }
1375
1376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_LanguageChangedSignal(void * jarg1) {
1377   void * jresult ;
1378   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1379   Dali::InputMethodContext::LanguageChangedSignalType *result = 0 ;
1380
1381   arg1 = (Dali::InputMethodContext *)jarg1;
1382   {
1383     try {
1384       result = (Dali::InputMethodContext::LanguageChangedSignalType *) &(arg1)->LanguageChangedSignal();
1385     } catch (std::out_of_range& e) {
1386       {
1387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1388       };
1389     } catch (std::exception& e) {
1390       {
1391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1392       };
1393     } catch (...) {
1394       {
1395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1396       };
1397     }
1398   }
1399   jresult = (void *)result;
1400   return jresult;
1401 }
1402
1403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_KeyboardTypeChangedSignal(void * jarg1) {
1404   void * jresult ;
1405   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1406   Dali::InputMethodContext::KeyboardTypeSignalType *result = 0 ;
1407
1408   arg1 = (Dali::InputMethodContext *)jarg1;
1409   {
1410     try {
1411       result = (Dali::InputMethodContext::KeyboardTypeSignalType *) &(arg1)->KeyboardTypeChangedSignal();
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 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_ContentReceivedSignal(void * jarg1) {
1426   void * jresult ;
1427   Dali::InputMethodContext *arg1 = (Dali::InputMethodContext *) 0 ;
1428   Dali::InputMethodContext::ContentReceivedSignalType *result = 0 ;
1429
1430   arg1 = (Dali::InputMethodContext *)jarg1;
1431   {
1432     try {
1433       result = (Dali::InputMethodContext::ContentReceivedSignalType *) &(arg1)->ContentReceivedSignal();
1434     } catch (std::out_of_range& e) {
1435       {
1436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1437       };
1438     } catch (std::exception& e) {
1439       {
1440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1441       };
1442     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1443   jresult = (void *)result;
1444   return jresult;
1445 }
1446
1447 // ActivatedSignalType
1448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Empty(void * jarg1) {
1449   unsigned int jresult ;
1450   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1451   bool result;
1452
1453   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1454   {
1455     try {
1456       result = (bool)Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Empty((Dali::Signal< void (Dali::InputMethodContext &) > const *)arg1);
1457     } catch (std::out_of_range& e) {
1458       {
1459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1460       };
1461     } catch (std::exception& e) {
1462       {
1463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1464       };
1465     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1466   jresult = result;
1467   return jresult;
1468 }
1469
1470
1471 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActivatedSignalType_GetConnectionCount(void * jarg1) {
1472   unsigned long jresult ;
1473   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1474   std::size_t result;
1475
1476   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1477   {
1478     try {
1479       result = Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::InputMethodContext &) > const *)arg1);
1480     } catch (std::out_of_range& e) {
1481       {
1482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1483       };
1484     } catch (std::exception& e) {
1485       {
1486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1487       };
1488     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1489   jresult = (unsigned long)result;
1490   return jresult;
1491 }
1492
1493
1494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Connect(void * jarg1, void * jarg2) {
1495   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1496   void (*arg2)(Dali::InputMethodContext &) = (void (*)(Dali::InputMethodContext &)) 0 ;
1497
1498   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1499   arg2 = (void (*)(Dali::InputMethodContext &))jarg2;
1500   {
1501     try {
1502       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Connect(arg1,arg2);
1503     } catch (std::out_of_range& e) {
1504       {
1505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1506       };
1507     } catch (std::exception& e) {
1508       {
1509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1510       };
1511     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1512 }
1513
1514
1515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Disconnect(void * jarg1, void * jarg2) {
1516   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1517   void (*arg2)(Dali::InputMethodContext &) = (void (*)(Dali::InputMethodContext &)) 0 ;
1518
1519   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1520   arg2 = (void (*)(Dali::InputMethodContext &))jarg2;
1521   {
1522     try {
1523       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Disconnect(arg1,arg2);
1524     } catch (std::out_of_range& e) {
1525       {
1526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1527       };
1528     } catch (std::exception& e) {
1529       {
1530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1531       };
1532     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1533 }
1534
1535
1536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Emit(void * jarg1, void * jarg2) {
1537   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1538   Dali::InputMethodContext *arg2 = 0 ;
1539
1540   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1541   arg2 = (Dali::InputMethodContext *)jarg2;
1542   if (!arg2) {
1543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext & type is null", 0);
1544     return ;
1545   }
1546   {
1547     try {
1548       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Emit(arg1,*arg2);
1549     } catch (std::out_of_range& e) {
1550       {
1551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1552       };
1553     } catch (std::exception& e) {
1554       {
1555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1556       };
1557     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1558 }
1559
1560
1561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActivatedSignalType() {
1562   void * jresult ;
1563   Dali::Signal< void (Dali::InputMethodContext &) > *result = 0 ;
1564
1565   {
1566     try {
1567       result = (Dali::Signal< void (Dali::InputMethodContext &) > *)new Dali::Signal< void (Dali::InputMethodContext &) >();
1568     } catch (std::out_of_range& e) {
1569       {
1570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1571       };
1572     } catch (std::exception& e) {
1573       {
1574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1575       };
1576     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1577   jresult = (void *)result;
1578   return jresult;
1579 }
1580
1581
1582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActivatedSignalType(void * jarg1) {
1583   Dali::Signal< void (Dali::InputMethodContext &) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ;
1584
1585   arg1 = (Dali::Signal< void (Dali::InputMethodContext &) > *)jarg1;
1586   {
1587     try {
1588       delete arg1;
1589     } catch (std::out_of_range& e) {
1590       {
1591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1592       };
1593     } catch (std::exception& e) {
1594       {
1595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1596       };
1597     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1598 }
1599
1600 // KeyboardEventSignalType
1601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Empty(void * jarg1) {
1602   unsigned int jresult ;
1603   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1604   bool result;
1605
1606   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1607   {
1608     try {
1609       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);
1610     } catch (std::out_of_range& e) {
1611       {
1612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1613       };
1614     } catch (std::exception& e) {
1615       {
1616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1617       };
1618     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1619   jresult = result;
1620   return jresult;
1621 }
1622
1623
1624 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_GetConnectionCount(void * jarg1) {
1625   unsigned long jresult ;
1626   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1627   std::size_t result;
1628
1629   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1630   {
1631     try {
1632       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);
1633     } catch (std::out_of_range& e) {
1634       {
1635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1636       };
1637     } catch (std::exception& e) {
1638       {
1639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1640       };
1641     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1642   jresult = (unsigned long)result;
1643   return jresult;
1644 }
1645
1646 typedef Dali::InputMethodContext::CallbackData* (SWIGSTDCALL* SWIG_CallbackEventReceived)(Dali::InputMethodContext *, Dali::InputMethodContext::EventData *);
1647 SWIG_CallbackEventReceived swig_callbackOnEventReceived;
1648
1649 Dali::InputMethodContext::CallbackData OnEventReceivedCallback(Dali::InputMethodContext inputMethodContext, Dali::InputMethodContext::EventData eventData)
1650 {
1651     Dali::InputMethodContext::CallbackData *callbackDataP;
1652     Dali::InputMethodContext::CallbackData callbackData;
1653     Dali::InputMethodContext *inputMethodContextP = NULL;
1654     Dali::InputMethodContext::EventData *eventDataP = NULL;
1655
1656     if (inputMethodContext)
1657     {
1658       inputMethodContextP = (Dali::InputMethodContext *)&inputMethodContext;
1659     }
1660
1661     eventDataP = (Dali::InputMethodContext::EventData *)&eventData;
1662
1663     callbackDataP = (Dali::InputMethodContext::CallbackData *)swig_callbackOnEventReceived(inputMethodContextP, eventDataP);
1664     if (callbackDataP)
1665     {
1666       callbackData = *callbackDataP;
1667     }
1668
1669     return callbackData;
1670 }
1671
1672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Connect(void * jarg1, SWIG_CallbackEventReceived callbackOnEventReceived) {
1673
1674   swig_callbackOnEventReceived = callbackOnEventReceived;
1675
1676   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1677   Dali::InputMethodContext::CallbackData (*arg2)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &)) 0 ;
1678
1679   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1680   arg2 = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &))OnEventReceivedCallback;
1681   {
1682     try {
1683       Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
1684     } catch (std::out_of_range& e) {
1685       {
1686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1687       };
1688     } catch (std::exception& e) {
1689       {
1690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1691       };
1692     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1693 }
1694
1695
1696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Disconnect(void * jarg1, SWIG_CallbackEventReceived callbackOnEventReceived) {
1697
1698   swig_callbackOnEventReceived = callbackOnEventReceived;
1699
1700   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1701   Dali::InputMethodContext::CallbackData (*arg2)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &)) 0 ;
1702
1703   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1704   arg2 = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &))OnEventReceivedCallback;
1705   {
1706     try {
1707       Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
1708     } catch (std::out_of_range& e) {
1709       {
1710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1711       };
1712     } catch (std::exception& e) {
1713       {
1714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1715       };
1716     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1717 }
1718
1719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Emit(void * jarg1, void * jarg2, void * jarg3) {
1720   void * jresult ;
1721   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1722   Dali::InputMethodContext *arg2 = 0 ;
1723   Dali::InputMethodContext::EventData *arg3 = 0 ;
1724   Dali::InputMethodContext::CallbackData result;
1725
1726   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1727   arg2 = (Dali::InputMethodContext *)jarg2;
1728   if (!arg2) {
1729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext & type is null", 0);
1730     return 0;
1731   }
1732   arg3 = (Dali::InputMethodContext::EventData *)jarg3;
1733   if (!arg3) {
1734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext::EventData const & type is null", 0);
1735     return 0;
1736   }
1737   {
1738     try {
1739       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);
1740     } catch (std::out_of_range& e) {
1741       {
1742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1743       };
1744     } catch (std::exception& e) {
1745       {
1746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1747       };
1748     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1749   jresult = new Dali::InputMethodContext::CallbackData((const Dali::InputMethodContext::CallbackData &)result);
1750   return jresult;
1751 }
1752
1753
1754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyboardEventSignalType() {
1755   void * jresult ;
1756   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *result = 0 ;
1757
1758   {
1759     try {
1760       result = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)new Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) >();
1761     } catch (std::out_of_range& e) {
1762       {
1763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1764       };
1765     } catch (std::exception& e) {
1766       {
1767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1768       };
1769     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1770   jresult = (void *)result;
1771   return jresult;
1772 }
1773
1774
1775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyboardEventSignalType(void * jarg1) {
1776   Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ;
1777
1778   arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1;
1779   {
1780     try {
1781       delete arg1;
1782     } catch (std::out_of_range& e) {
1783       {
1784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1785       };
1786     } catch (std::exception& e) {
1787       {
1788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1789       };
1790     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1791 }
1792
1793
1794 // VoidSignalType
1795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignalType() {
1796   void * jresult ;
1797   Dali::Signal< void () > *result = 0 ;
1798
1799   {
1800     try {
1801       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
1802     } catch (std::out_of_range& e) {
1803       {
1804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1805       };
1806     } catch (std::exception& e) {
1807       {
1808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1809       };
1810     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1811   jresult = (void *)result;
1812   return jresult;
1813 }
1814
1815
1816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignalType(void * jarg1) {
1817   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1818
1819   arg1 = (Dali::Signal< void () > *)jarg1;
1820   {
1821     try {
1822       delete arg1;
1823     } catch (std::out_of_range& e) {
1824       {
1825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1826       };
1827     } catch (std::exception& e) {
1828       {
1829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1830       };
1831     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1832 }
1833
1834
1835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignalType_Empty(void * jarg1) {
1836   unsigned int jresult ;
1837   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1838   bool result;
1839
1840   arg1 = (Dali::Signal< void () > *)jarg1;
1841   {
1842     try {
1843       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
1844     } catch (std::out_of_range& e) {
1845       {
1846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1847       };
1848     } catch (std::exception& e) {
1849       {
1850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1851       };
1852     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1853   jresult = result;
1854   return jresult;
1855 }
1856
1857
1858 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignalType_GetConnectionCount(void * jarg1) {
1859   unsigned long jresult ;
1860   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1861   std::size_t result;
1862
1863   arg1 = (Dali::Signal< void () > *)jarg1;
1864   {
1865     try {
1866       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
1867     } catch (std::out_of_range& e) {
1868       {
1869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1870       };
1871     } catch (std::exception& e) {
1872       {
1873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1874       };
1875     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1876   jresult = (unsigned long)result;
1877   return jresult;
1878 }
1879
1880
1881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Connect__SWIG_0(void * jarg1, void * jarg2) {
1882   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1883   void (*arg2)() = (void (*)()) 0 ;
1884
1885   arg1 = (Dali::Signal< void () > *)jarg1;
1886   arg2 = (void (*)())jarg2;
1887   {
1888     try {
1889       (arg1)->Connect(arg2);
1890     } catch (std::out_of_range& e) {
1891       {
1892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1893       };
1894     } catch (std::exception& e) {
1895       {
1896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1897       };
1898     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1899 }
1900
1901
1902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Disconnect(void * jarg1, void * jarg2) {
1903   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1904   void (*arg2)() = (void (*)()) 0 ;
1905
1906   arg1 = (Dali::Signal< void () > *)jarg1;
1907   arg2 = (void (*)())jarg2;
1908   {
1909     try {
1910       (arg1)->Disconnect(arg2);
1911     } catch (std::out_of_range& e) {
1912       {
1913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1914       };
1915     } catch (std::exception& e) {
1916       {
1917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1918       };
1919     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1920 }
1921
1922
1923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
1924   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1925   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
1926   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
1927
1928   arg1 = (Dali::Signal< void () > *)jarg1;
1929   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
1930   arg3 = (Dali::FunctorDelegate *)jarg3;
1931   {
1932     try {
1933       (arg1)->Connect(arg2,arg3);
1934     } catch (std::out_of_range& e) {
1935       {
1936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1937       };
1938     } catch (std::exception& e) {
1939       {
1940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1941       };
1942     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1943 }
1944
1945
1946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Emit(void * jarg1) {
1947   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
1948
1949   arg1 = (Dali::Signal< void () > *)jarg1;
1950   {
1951     try {
1952       (arg1)->Emit();
1953     } catch (std::out_of_range& e) {
1954       {
1955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1956       };
1957     } catch (std::exception& e) {
1958       {
1959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1960       };
1961     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
1962 }
1963
1964 //StatusSignalType
1965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StatusSignalType_Empty(void * jarg1) {
1966   unsigned int jresult ;
1967   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1968   bool result;
1969
1970   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1971   {
1972     try {
1973       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
1974     } catch (std::out_of_range& e) {
1975       {
1976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1977       };
1978     } catch (std::exception& e) {
1979       {
1980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1981       };
1982     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
1983   jresult = result;
1984   return jresult;
1985 }
1986
1987
1988 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StatusSignalType_GetConnectionCount(void * jarg1) {
1989   unsigned long jresult ;
1990   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1991   std::size_t result;
1992
1993   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1994   {
1995     try {
1996       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
1997     } catch (std::out_of_range& e) {
1998       {
1999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2000       };
2001     } catch (std::exception& e) {
2002       {
2003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2004       };
2005     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
2006   jresult = (unsigned long)result;
2007   return jresult;
2008 }
2009
2010
2011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Connect(void * jarg1, void * jarg2) {
2012   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
2013   void (*arg2)(bool) = (void (*)(bool)) 0 ;
2014
2015   arg1 = (Dali::Signal< void (bool) > *)jarg1;
2016   arg2 = (void (*)(bool))jarg2;
2017   {
2018     try {
2019       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
2020     } catch (std::out_of_range& e) {
2021       {
2022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2023       };
2024     } catch (std::exception& e) {
2025       {
2026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2027       };
2028     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
2029 }
2030
2031
2032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Disconnect(void * jarg1, void * jarg2) {
2033   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
2034   void (*arg2)(bool) = (void (*)(bool)) 0 ;
2035
2036   arg1 = (Dali::Signal< void (bool) > *)jarg1;
2037   arg2 = (void (*)(bool))jarg2;
2038   {
2039     try {
2040       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
2041     } catch (std::out_of_range& e) {
2042       {
2043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2044       };
2045     } catch (std::exception& e) {
2046       {
2047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2048       };
2049     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
2050 }
2051
2052
2053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Emit(void * jarg1, unsigned int jarg2) {
2054   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
2055   bool arg2 ;
2056
2057   arg1 = (Dali::Signal< void (bool) > *)jarg1;
2058   arg2 = jarg2 ? true : false;
2059   {
2060     try {
2061       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
2062     } catch (std::out_of_range& e) {
2063       {
2064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2065       };
2066     } catch (std::exception& e) {
2067       {
2068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2069       };
2070     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
2071 }
2072
2073
2074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StatusSignalType() {
2075   void * jresult ;
2076   Dali::Signal< void (bool) > *result = 0 ;
2077
2078   {
2079     try {
2080       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
2081     } catch (std::out_of_range& e) {
2082       {
2083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2084       };
2085     } catch (std::exception& e) {
2086       {
2087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2088       };
2089     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
2090   jresult = (void *)result;
2091   return jresult;
2092 }
2093
2094
2095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StatusSignalType(void * jarg1) {
2096   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
2097
2098   arg1 = (Dali::Signal< void (bool) > *)jarg1;
2099   {
2100     try {
2101       delete arg1;
2102     } catch (std::out_of_range& e) {
2103       {
2104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2105       };
2106     } catch (std::exception& e) {
2107       {
2108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2109       };
2110     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
2111 }
2112
2113 //KeyboardTypeSignalType
2114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Empty(void * jarg1) {
2115   unsigned int jresult ;
2116   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
2117   bool result;
2118
2119   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
2120   {
2121     try {
2122       result = (bool)Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Empty((Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > const *)arg1);
2123     } catch (std::out_of_range& e) {
2124       {
2125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2126       };
2127     } catch (std::exception& e) {
2128       {
2129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2130       };
2131     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
2132   jresult = result;
2133   return jresult;
2134 }
2135
2136
2137 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_GetConnectionCount(void * jarg1) {
2138   unsigned long jresult ;
2139   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
2140   std::size_t result;
2141
2142   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
2143   {
2144     try {
2145       result = Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > const *)arg1);
2146     } catch (std::out_of_range& e) {
2147       {
2148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2149       };
2150     } catch (std::exception& e) {
2151       {
2152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2153       };
2154     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
2155   jresult = (unsigned long)result;
2156   return jresult;
2157 }
2158
2159
2160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Connect(void * jarg1, void * jarg2) {
2161   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
2162   void (*arg2)(Dali::InputMethodContext::KeyboardType) = (void (*)(Dali::InputMethodContext::KeyboardType)) 0 ;
2163
2164   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
2165   arg2 = (void (*)(Dali::InputMethodContext::KeyboardType))jarg2;
2166   {
2167     try {
2168       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Connect(arg1,arg2);
2169     } catch (std::out_of_range& e) {
2170       {
2171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2172       };
2173     } catch (std::exception& e) {
2174       {
2175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2176       };
2177     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
2178 }
2179
2180
2181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Disconnect(void * jarg1, void * jarg2) {
2182   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
2183   void (*arg2)(Dali::InputMethodContext::KeyboardType) = (void (*)(Dali::InputMethodContext::KeyboardType)) 0 ;
2184
2185   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
2186   arg2 = (void (*)(Dali::InputMethodContext::KeyboardType))jarg2;
2187   {
2188     try {
2189       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Disconnect(arg1,arg2);
2190     } catch (std::out_of_range& e) {
2191       {
2192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2193       };
2194     } catch (std::exception& e) {
2195       {
2196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2197       };
2198     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
2199 }
2200
2201
2202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Emit(void * jarg1, int jarg2) {
2203   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
2204   Dali::InputMethodContext::KeyboardType arg2 ;
2205
2206   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
2207   arg2 = (Dali::InputMethodContext::KeyboardType)jarg2;
2208   {
2209     try {
2210       Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Emit(arg1,arg2);
2211     } catch (std::out_of_range& e) {
2212       {
2213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2214       };
2215     } catch (std::exception& e) {
2216       {
2217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2218       };
2219     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
2220 }
2221
2222
2223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyboardTypeSignalType() {
2224   void * jresult ;
2225   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *result = 0 ;
2226
2227   {
2228     try {
2229       result = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)new Dali::Signal< void (Dali::InputMethodContext::KeyboardType) >();
2230     } catch (std::out_of_range& e) {
2231       {
2232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2233       };
2234     } catch (std::exception& e) {
2235       {
2236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2237       };
2238     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; }  }
2239   jresult = (void *)result;
2240   return jresult;
2241 }
2242
2243
2244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyboardTypeSignalType(void * jarg1) {
2245   Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ;
2246
2247   arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1;
2248   {
2249     try {
2250       delete arg1;
2251     } catch (std::out_of_range& e) {
2252       {
2253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2254       };
2255     } catch (std::exception& e) {
2256       {
2257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2258       };
2259     } catch (Dali::DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }  }
2260 }
2261
2262 //LanguageChangedSignalType
2263
2264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Empty(void * jarg1) {
2265   unsigned int jresult ;
2266   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2267   bool result;
2268
2269   arg1 = (Dali::Signal< void (int) > *)jarg1;
2270   {
2271     try {
2272       result = (bool)Dali_Signal_Sl_void_Sp_int_SP__Sg__Empty((Dali::Signal< void (int) > const *)arg1);
2273     } catch (std::out_of_range& e) {
2274       {
2275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2276       };
2277     } catch (std::exception& e) {
2278       {
2279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2280       };
2281     } catch (...) {
2282       {
2283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2284       };
2285     }
2286   }
2287   jresult = result;
2288   return jresult;
2289 }
2290
2291
2292 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_GetConnectionCount(void * jarg1) {
2293   unsigned long jresult ;
2294   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2295   std::size_t result;
2296
2297   arg1 = (Dali::Signal< void (int) > *)jarg1;
2298   {
2299     try {
2300       result = Dali_Signal_Sl_void_Sp_int_SP__Sg__GetConnectionCount((Dali::Signal< void (int) > const *)arg1);
2301     } catch (std::out_of_range& e) {
2302       {
2303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2304       };
2305     } catch (std::exception& e) {
2306       {
2307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2308       };
2309     } catch (...) {
2310       {
2311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2312       };
2313     }
2314   }
2315   jresult = (unsigned long)result;
2316   return jresult;
2317 }
2318
2319
2320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Connect(void * jarg1, void * jarg2) {
2321   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2322   void (*arg2)(int) = (void (*)(int)) 0 ;
2323
2324   arg1 = (Dali::Signal< void (int) > *)jarg1;
2325   arg2 = (void (*)(int))jarg2;
2326   {
2327     try {
2328       Dali_Signal_Sl_void_Sp_int_SP__Sg__Connect(arg1,arg2);
2329     } catch (std::out_of_range& e) {
2330       {
2331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2332       };
2333     } catch (std::exception& e) {
2334       {
2335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2336       };
2337     } catch (...) {
2338       {
2339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2340       };
2341     }
2342   }
2343 }
2344
2345
2346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Disconnect(void * jarg1, void * jarg2) {
2347   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2348   void (*arg2)(int) = (void (*)(int)) 0 ;
2349
2350   arg1 = (Dali::Signal< void (int) > *)jarg1;
2351   arg2 = (void (*)(int))jarg2;
2352   {
2353     try {
2354       Dali_Signal_Sl_void_Sp_int_SP__Sg__Disconnect(arg1,arg2);
2355     } catch (std::out_of_range& e) {
2356       {
2357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2358       };
2359     } catch (std::exception& e) {
2360       {
2361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2362       };
2363     } catch (...) {
2364       {
2365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2366       };
2367     }
2368   }
2369 }
2370
2371
2372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Emit(void * jarg1, int jarg2) {
2373   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2374   int arg2 ;
2375
2376   arg1 = (Dali::Signal< void (int) > *)jarg1;
2377   arg2 = (int)jarg2;
2378   {
2379     try {
2380       Dali_Signal_Sl_void_Sp_int_SP__Sg__Emit(arg1,arg2);
2381     } catch (std::out_of_range& e) {
2382       {
2383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2384       };
2385     } catch (std::exception& e) {
2386       {
2387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2388       };
2389     } catch (...) {
2390       {
2391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2392       };
2393     }
2394   }
2395 }
2396
2397
2398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LanguageChangedSignalType() {
2399   void * jresult ;
2400   Dali::Signal< void (int) > *result = 0 ;
2401
2402   {
2403     try {
2404       result = (Dali::Signal< void (int) > *)new Dali::Signal< void (int) >();
2405     } catch (std::out_of_range& e) {
2406       {
2407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2408       };
2409     } catch (std::exception& e) {
2410       {
2411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2412       };
2413     } catch (...) {
2414       {
2415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2416       };
2417     }
2418   }
2419   jresult = (void *)result;
2420   return jresult;
2421 }
2422
2423
2424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LanguageChangedSignalType(void * jarg1) {
2425   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2426
2427   arg1 = (Dali::Signal< void (int) > *)jarg1;
2428   {
2429     try {
2430       delete arg1;
2431     } catch (std::out_of_range& e) {
2432       {
2433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2434       };
2435     } catch (std::exception& e) {
2436       {
2437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2438       };
2439     } catch (...) {
2440       {
2441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2442       };
2443     }
2444   }
2445 }
2446
2447 //KeyboardTypeSignalType
2448
2449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Empty(void * jarg1) {
2450   unsigned int jresult ;
2451   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2452   bool result;
2453
2454   arg1 = (Dali::Signal< void (int) > *)jarg1;
2455   {
2456     try {
2457       result = (bool)Dali_Signal_Sl_void_Sp_int_SP__Sg__Empty((Dali::Signal< void (int) > const *)arg1);
2458     } catch (std::out_of_range& e) {
2459       {
2460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2461       };
2462     } catch (std::exception& e) {
2463       {
2464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2465       };
2466     } catch (...) {
2467       {
2468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2469       };
2470     }
2471   }
2472   jresult = result;
2473   return jresult;
2474 }
2475
2476
2477 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_GetConnectionCount(void * jarg1) {
2478   unsigned long jresult ;
2479   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2480   std::size_t result;
2481
2482   arg1 = (Dali::Signal< void (int) > *)jarg1;
2483   {
2484     try {
2485       result = Dali_Signal_Sl_void_Sp_int_SP__Sg__GetConnectionCount((Dali::Signal< void (int) > const *)arg1);
2486     } catch (std::out_of_range& e) {
2487       {
2488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2489       };
2490     } catch (std::exception& e) {
2491       {
2492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2493       };
2494     } catch (...) {
2495       {
2496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2497       };
2498     }
2499   }
2500   jresult = (unsigned long)result;
2501   return jresult;
2502 }
2503
2504
2505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Connect(void * jarg1, void * jarg2) {
2506   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2507   void (*arg2)(int) = (void (*)(int)) 0 ;
2508
2509   arg1 = (Dali::Signal< void (int) > *)jarg1;
2510   arg2 = (void (*)(int))jarg2;
2511   {
2512     try {
2513       Dali_Signal_Sl_void_Sp_int_SP__Sg__Connect(arg1,arg2);
2514     } catch (std::out_of_range& e) {
2515       {
2516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2517       };
2518     } catch (std::exception& e) {
2519       {
2520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2521       };
2522     } catch (...) {
2523       {
2524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2525       };
2526     }
2527   }
2528 }
2529
2530
2531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Disconnect(void * jarg1, void * jarg2) {
2532   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2533   void (*arg2)(int) = (void (*)(int)) 0 ;
2534
2535   arg1 = (Dali::Signal< void (int) > *)jarg1;
2536   arg2 = (void (*)(int))jarg2;
2537   {
2538     try {
2539       Dali_Signal_Sl_void_Sp_int_SP__Sg__Disconnect(arg1,arg2);
2540     } catch (std::out_of_range& e) {
2541       {
2542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2543       };
2544     } catch (std::exception& e) {
2545       {
2546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2547       };
2548     } catch (...) {
2549       {
2550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2551       };
2552     }
2553   }
2554 }
2555
2556
2557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Emit(void * jarg1, int jarg2) {
2558   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2559   int arg2 ;
2560
2561   arg1 = (Dali::Signal< void (int) > *)jarg1;
2562   arg2 = (int)jarg2;
2563   {
2564     try {
2565       Dali_Signal_Sl_void_Sp_int_SP__Sg__Emit(arg1,arg2);
2566     } catch (std::out_of_range& e) {
2567       {
2568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2569       };
2570     } catch (std::exception& e) {
2571       {
2572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2573       };
2574     } catch (...) {
2575       {
2576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2577       };
2578     }
2579   }
2580 }
2581
2582
2583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyboardResizedSignalType() {
2584   void * jresult ;
2585   Dali::Signal< void (int) > *result = 0 ;
2586
2587   {
2588     try {
2589       result = (Dali::Signal< void (int) > *)new Dali::Signal< void (int) >();
2590     } catch (std::out_of_range& e) {
2591       {
2592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2593       };
2594     } catch (std::exception& e) {
2595       {
2596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2597       };
2598     } catch (...) {
2599       {
2600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2601       };
2602     }
2603   }
2604   jresult = (void *)result;
2605   return jresult;
2606 }
2607
2608
2609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyboardResizedSignalType(void * jarg1) {
2610   Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ;
2611
2612   arg1 = (Dali::Signal< void (int) > *)jarg1;
2613   {
2614     try {
2615       delete arg1;
2616     } catch (std::out_of_range& e) {
2617       {
2618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2619       };
2620     } catch (std::exception& e) {
2621       {
2622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2623       };
2624     } catch (...) {
2625       {
2626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2627       };
2628     }
2629   }
2630 }
2631
2632 //ContentReceivedSignalType
2633
2634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ContentReceivedSignalType_Empty(void * jarg1) {
2635   unsigned int jresult ;
2636   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 ;
2637   bool result;
2638
2639   arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)jarg1;
2640   {
2641     try {
2642       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);
2643     } catch (std::out_of_range& e) {
2644       {
2645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2646       };
2647     } catch (std::exception& e) {
2648       {
2649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2650       };
2651     } catch (...) {
2652       {
2653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2654       };
2655     }
2656   }
2657   jresult = result;
2658   return jresult;
2659 }
2660
2661
2662 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ContentReceivedSignalType_GetConnectionCount(void * jarg1) {
2663   unsigned long jresult ;
2664   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 ;
2665   std::size_t result;
2666
2667   arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)jarg1;
2668   {
2669     try {
2670       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);
2671     } catch (std::out_of_range& e) {
2672       {
2673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2674       };
2675     } catch (std::exception& e) {
2676       {
2677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2678       };
2679     } catch (...) {
2680       {
2681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2682       };
2683     }
2684   }
2685   jresult = (unsigned long)result;
2686   return jresult;
2687 }
2688
2689
2690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ContentReceivedSignalType_Connect(void * jarg1, void * jarg2) {
2691   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 ;
2692   void (*arg2)(std::string const &, std::string const &, std::string const &) = (void (*)(std::string const &, std::string const &, std::string const &)) 0 ;
2693
2694   arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)jarg1;
2695   arg2 = (void (*)(std::string const &, std::string const &, std::string const &))jarg2;
2696   {
2697     try {
2698       Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Connect(arg1,arg2);
2699     } catch (std::out_of_range& e) {
2700       {
2701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2702       };
2703     } catch (std::exception& e) {
2704       {
2705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2706       };
2707     } catch (...) {
2708       {
2709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2710       };
2711     }
2712   }
2713 }
2714
2715
2716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ContentReceivedSignalType_Disconnect(void * jarg1, void * jarg2) {
2717   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 ;
2718   void (*arg2)(std::string const &, std::string const &, std::string const &) = (void (*)(std::string const &, std::string const &, std::string const &)) 0 ;
2719
2720   arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)jarg1;
2721   arg2 = (void (*)(std::string const &, std::string const &, std::string const &))jarg2;
2722   {
2723     try {
2724       Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Disconnect(arg1,arg2);
2725     } catch (std::out_of_range& e) {
2726       {
2727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2728       };
2729     } catch (std::exception& e) {
2730       {
2731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2732       };
2733     } catch (...) {
2734       {
2735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2736       };
2737     }
2738   }
2739 }
2740
2741
2742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ContentReceivedSignalType_Emit(void * jarg1, char * jarg2, char * jarg3, char * jarg4) {
2743   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 ;
2744   std::string *arg2 = 0 ;
2745   std::string *arg3 = 0 ;
2746   std::string *arg4 = 0 ;
2747
2748   arg1 = (Dali::Signal<  void (std::string const &, std::string const &, std::string const &) > *)jarg1;
2749   std::string arg2_str(jarg2);
2750   arg2 = &arg2_str;
2751   std::string arg3_str(jarg3);
2752   arg3 = &arg3_str;
2753   std::string arg4_str(jarg4);
2754   arg4 = &arg4_str;
2755   {
2756     try {
2757       Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Emit(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
2758     } catch (std::out_of_range& e) {
2759       {
2760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2761       };
2762     } catch (std::exception& e) {
2763       {
2764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2765       };
2766     } catch (...) {
2767       {
2768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2769       };
2770     }
2771   }
2772 }
2773
2774
2775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ContentReceivedSignalType() {
2776   void * jresult ;
2777   Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *result = 0 ;
2778
2779   {
2780     try {
2781       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 &) >();
2782     } catch (std::out_of_range& e) {
2783       {
2784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2785       };
2786     } catch (std::exception& e) {
2787       {
2788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2789       };
2790     } catch (...) {
2791       {
2792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2793       };
2794     }
2795   }
2796   jresult = (void *)result;
2797   return jresult;
2798 }
2799
2800
2801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ContentReceivedSignalType(void * jarg1) {
2802   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 ;
2803
2804   arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)jarg1;
2805   {
2806     try {
2807       delete arg1;
2808     } catch (std::out_of_range& e) {
2809       {
2810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2811       };
2812     } catch (std::exception& e) {
2813       {
2814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2815       };
2816     } catch (...) {
2817       {
2818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2819       };
2820     }
2821   }
2822 }
2823
2824 #ifdef __cplusplus
2825 }
2826 #endif
2827