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