plugins/dali-swig/manual/cpp/keyboard_focus_manager_wrap.cpp

   1 #ifndef CSHARP_KEYBOARD_FOCUS_MANAGER
   2 #define CSHARP_KEYBOARD_FOCUS_MANAGER
   3 #endif
   4
   5 #include "common.h"
   6
   7 SWIGINTERN bool Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Empty(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > const *self){
   8          return self->Empty();
   9       }
  10 SWIGINTERN std::size_t Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__GetConnectionCount(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > const *self){
  11         return self->GetConnectionCount();
  12       }
  13 SWIGINTERN void Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Connect(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *self,Dali::Actor (*func)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)){
  14           return self->Connect( func );
  15       }
  16 SWIGINTERN void Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Disconnect(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *self,Dali::Actor (*func)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)){
  17           self->Disconnect( func );
  18       }
  19 SWIGINTERN Dali::Actor Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Emit(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *self,Dali::Actor arg1,Dali::Actor arg2,Dali::Toolkit::Control::KeyboardFocus::Direction arg3){
  20           return self->Emit( arg1, arg2, arg3 );
  21       }
  22
  23 #ifdef __cplusplus
  24 extern "C" {
  25 #endif
  26
  27 SWIGEXPORT void * SWIGSTDCALL CSharp_new_KeyboardFocusManager() {
  28   void * jresult;
  29   Dali::Toolkit::KeyboardFocusManager *result = 0 ;
  30
  31   {
  32     try {
  33       result = (Dali::Toolkit::KeyboardFocusManager *)new Dali::Toolkit::KeyboardFocusManager();
  34     } catch (std::out_of_range& e) {
  35       {
  36         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
  37       };
  38     } catch (std::exception& e) {
  39       {
  40         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
  41       };
  42     } catch (...) {
  43       {
  44         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
  45       };
  46     }
  47   }
  48   jresult = (void *)result;
  49   return jresult;
  50 }
  51
  52
  53 SWIGEXPORT void SWIGSTDCALL CSharp_delete_KeyboardFocusManager(void * jarg1) {
  54   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
  55
  56   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
  57   {
  58     try {
  59       delete arg1;
  60     } catch (std::out_of_range& e) {
  61       {
  62         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
  63       };
  64     } catch (std::exception& e) {
  65       {
  66         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
  67       };
  68     } catch (...) {
  69       {
  70         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
  71       };
  72     }
  73   }
  74 }
  75
  76
  77 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_Get() {
  78   void * jresult;
  79   Dali::Toolkit::KeyboardFocusManager result;
  80
  81   {
  82     try {
  83       result = Dali::Toolkit::KeyboardFocusManager::Get();
  84     } catch (std::out_of_range& e) {
  85       {
  86         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
  87       };
  88     } catch (std::exception& e) {
  89       {
  90         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
  91       };
  92     } catch (...) {
  93       {
  94         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
  95       };
  96     }
  97   }
  98   jresult = new Dali::Toolkit::KeyboardFocusManager((const Dali::Toolkit::KeyboardFocusManager &)result);
  99   return jresult;
 100 }
 101
 102
 103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
 104   unsigned int jresult ;
 105   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 106   Dali::Actor arg2;
 107   Dali::Actor *argp2 ;
 108   bool result;
 109
 110   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 111   argp2 = (Dali::Actor *)jarg2;
 112   if (!argp2) {
 113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 114     return 0;
 115   }
 116   arg2 = *argp2;
 117   {
 118     try {
 119       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
 120     } catch (std::out_of_range& e) {
 121       {
 122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 123       };
 124     } catch (std::exception& e) {
 125       {
 126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 127       };
 128     } catch (...) {
 129       {
 130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 131       };
 132     }
 133   }
 134   jresult = result;
 135   return jresult;
 136 }
 137
 138
 139 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_GetCurrentFocusActor(void * jarg1) {
 140   void * jresult ;
 141   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 142   Dali::Actor result;
 143
 144   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 145   {
 146     try {
 147       result = (arg1)->GetCurrentFocusActor();
 148     } catch (std::out_of_range& e) {
 149       {
 150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 151       };
 152     } catch (std::exception& e) {
 153       {
 154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 155       };
 156     } catch (...) {
 157       {
 158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 159       };
 160     }
 161   }
 162   jresult = new Dali::Actor((const Dali::Actor &)result);
 163   return jresult;
 164 }
 165
 166
 167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_MoveFocus(void * jarg1, int jarg2) {
 168   unsigned int jresult ;
 169   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 170   Dali::Toolkit::Control::KeyboardFocus::Direction arg2;
 171   bool result;
 172
 173   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 174   arg2 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg2;
 175   {
 176     try {
 177       result = (bool)(arg1)->MoveFocus(arg2);
 178     } catch (std::out_of_range& e) {
 179       {
 180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 181       };
 182     } catch (std::exception& e) {
 183       {
 184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 185       };
 186     } catch (...) {
 187       {
 188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 189       };
 190     }
 191   }
 192   jresult = result;
 193   return jresult;
 194 }
 195
 196
 197 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_ClearFocus(void * jarg1) {
 198   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 199
 200   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 201   {
 202     try {
 203       (arg1)->ClearFocus();
 204     } catch (std::out_of_range& e) {
 205       {
 206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
 207       };
 208     } catch (std::exception& e) {
 209       {
 210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
 211       };
 212     } catch (...) {
 213       {
 214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
 215       };
 216     }
 217   }
 218 }
 219
 220
 221 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_SetFocusGroupLoop(void * jarg1, unsigned int jarg2) {
 222   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0;
 223   bool arg2;
 224
 225   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 226   arg2 = jarg2 ? true : false;
 227   {
 228     try {
 229       (arg1)->SetFocusGroupLoop(arg2);
 230     } catch (std::out_of_range& e) {
 231       {
 232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
 233       };
 234     } catch (std::exception& e) {
 235       {
 236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
 237       };
 238     } catch (...) {
 239       {
 240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 241       };
 242     }
 243   }
 244 }
 245
 246
 247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_GetFocusGroupLoop(void * jarg1) {
 248   unsigned int jresult ;
 249   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 250   bool result;
 251
 252   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 253   {
 254     try {
 255       result = (bool)((Dali::Toolkit::KeyboardFocusManager const *)arg1)->GetFocusGroupLoop();
 256     } catch (std::out_of_range& e) {
 257       {
 258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 259       };
 260     } catch (std::exception& e) {
 261       {
 262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 263       };
 264     } catch (...) {
 265       {
 266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 267       };
 268     }
 269   }
 270   jresult = result;
 271   return jresult;
 272 }
 273
 274
 275 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_SetAsFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
 276   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 277   Dali::Actor arg2 ;
 278   bool arg3 ;
 279   Dali::Actor *argp2 ;
 280
 281   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 282   argp2 = (Dali::Actor *)jarg2;
 283   if (!argp2) {
 284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 285     return ;
 286   }
 287   arg2 = *argp2;
 288   arg3 = jarg3 ? true : false;
 289   {
 290     try {
 291       (arg1)->SetAsFocusGroup(arg2,arg3);
 292     } catch (std::out_of_range& e) {
 293       {
 294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 295       };
 296     } catch (std::exception& e) {
 297       {
 298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 299       };
 300     } catch (...) {
 301       {
 302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 303       };
 304     }
 305   }
 306 }
 307
 308
 309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_IsFocusGroup(void * jarg1, void * jarg2) {
 310   unsigned int jresult ;
 311   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 312   Dali::Actor arg2 ;
 313   Dali::Actor *argp2 ;
 314   bool result;
 315
 316   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 317   argp2 = (Dali::Actor *)jarg2;
 318   if (!argp2) {
 319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 320     return 0;
 321   }
 322   arg2 = *argp2;
 323   {
 324     try {
 325       result = (bool)((Dali::Toolkit::KeyboardFocusManager const *)arg1)->IsFocusGroup(arg2);
 326     } catch (std::out_of_range& e) {
 327       {
 328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 329       };
 330     } catch (std::exception& e) {
 331       {
 332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 333       };
 334     } catch (...) {
 335       {
 336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 337       };
 338     }
 339   }
 340   jresult = result;
 341   return jresult;
 342 }
 343
 344
 345 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_GetFocusGroup(void * jarg1, void * jarg2) {
 346   void * jresult ;
 347   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 348   Dali::Actor arg2 ;
 349   Dali::Actor *argp2 ;
 350   Dali::Actor result;
 351
 352   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 353   argp2 = (Dali::Actor *)jarg2;
 354   if (!argp2) {
 355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 356     return 0;
 357   }
 358   arg2 = *argp2;
 359   {
 360     try {
 361       result = (arg1)->GetFocusGroup(arg2);
 362     } catch (std::out_of_range& e) {
 363       {
 364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 365       };
 366     } catch (std::exception& e) {
 367       {
 368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 369       };
 370     } catch (...) {
 371       {
 372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 373       };
 374     }
 375   }
 376   jresult = new Dali::Actor((const Dali::Actor &)result);
 377   return jresult;
 378 }
 379
 380
 381 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
 382   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 383   Dali::Actor arg2 ;
 384   Dali::Actor *argp2 ;
 385
 386   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 387   argp2 = (Dali::Actor *)jarg2;
 388   if (!argp2) {
 389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 390     return ;
 391   }
 392   arg2 = *argp2;
 393   {
 394     try {
 395       (arg1)->SetFocusIndicatorActor(arg2);
 396     } catch (std::out_of_range& e) {
 397       {
 398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 399       };
 400     } catch (std::exception& e) {
 401       {
 402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 403       };
 404     } catch (...) {
 405       {
 406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 407       };
 408     }
 409   }
 410 }
 411
 412
 413 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_GetFocusIndicatorActor(void * jarg1) {
 414   void * jresult ;
 415   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 416   Dali::Actor result;
 417
 418   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 419   {
 420     try {
 421       result = (arg1)->GetFocusIndicatorActor();
 422     } catch (std::out_of_range& e) {
 423       {
 424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 425       };
 426     } catch (std::exception& e) {
 427       {
 428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 429       };
 430     } catch (...) {
 431       {
 432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 433       };
 434     }
 435   }
 436   jresult = new Dali::Actor((const Dali::Actor &)result);
 437   return jresult;
 438 }
 439
 440
 441 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_PreFocusChangeSignal(void * jarg1) {
 442   void * jresult ;
 443   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 444   Dali::Toolkit::KeyboardFocusManager::PreFocusChangeSignalType *result = 0 ;
 445
 446   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 447   {
 448     try {
 449       result = (Dali::Toolkit::KeyboardFocusManager::PreFocusChangeSignalType *) &(arg1)->PreFocusChangeSignal();
 450     } catch (std::out_of_range& e) {
 451       {
 452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 453       };
 454     } catch (std::exception& e) {
 455       {
 456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 457       };
 458     } catch (...) {
 459       {
 460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 461       };
 462     }
 463   }
 464   jresult = (void *)result;
 465   return jresult;
 466 }
 467
 468
 469 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_FocusChangedSignal(void * jarg1) {
 470   void * jresult ;
 471   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 472   Dali::Toolkit::KeyboardFocusManager::FocusChangedSignalType *result = 0 ;
 473
 474   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 475   {
 476     try {
 477       result = (Dali::Toolkit::KeyboardFocusManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
 478     } catch (std::out_of_range& e) {
 479       {
 480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 481       };
 482     } catch (std::exception& e) {
 483       {
 484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 485       };
 486     } catch (...) {
 487       {
 488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 489       };
 490     }
 491   }
 492   jresult = (void *)result;
 493   return jresult;
 494 }
 495
 496
 497 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_FocusGroupChangedSignal(void * jarg1) {
 498   void * jresult ;
 499   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 500   Dali::Toolkit::KeyboardFocusManager::FocusGroupChangedSignalType *result = 0 ;
 501
 502   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 503   {
 504     try {
 505       result = (Dali::Toolkit::KeyboardFocusManager::FocusGroupChangedSignalType *) &(arg1)->FocusGroupChangedSignal();
 506     } catch (std::out_of_range& e) {
 507       {
 508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 509       };
 510     } catch (std::exception& e) {
 511       {
 512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 513       };
 514     } catch (...) {
 515       {
 516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 517       };
 518     }
 519   }
 520   jresult = (void *)result;
 521   return jresult;
 522 }
 523
 524
 525 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_FocusedActorEnterKeySignal(void * jarg1) {
 526   void * jresult ;
 527   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 528   Dali::Toolkit::KeyboardFocusManager::FocusedActorEnterKeySignalType *result = 0 ;
 529
 530   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 531   {
 532     try {
 533       result = (Dali::Toolkit::KeyboardFocusManager::FocusedActorEnterKeySignalType *) &(arg1)->FocusedActorEnterKeySignal();
 534     } catch (std::out_of_range& e) {
 535       {
 536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 537       };
 538     } catch (std::exception& e) {
 539       {
 540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 541       };
 542     } catch (...) {
 543       {
 544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 545       };
 546     }
 547   }
 548   jresult = (void *)result;
 549   return jresult;
 550 }
 551
 552
 553
 554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Empty(void * jarg1) {
 555   unsigned int jresult ;
 556   Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ;
 557   bool result;
 558
 559   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 560   {
 561     try {
 562       result = (bool)Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Empty((Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > const *)arg1);
 563     } catch (std::out_of_range& e) {
 564       {
 565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 566       };
 567     } catch (std::exception& e) {
 568       {
 569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 570       };
 571     } catch (...) {
 572       {
 573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 574       };
 575     }
 576   }
 577   jresult = result;
 578   return jresult;
 579 }
 580
 581
 582 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_GetConnectionCount(void * jarg1) {
 583   unsigned long jresult ;
 584   Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ;
 585   std::size_t result;
 586
 587   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 588   {
 589     try {
 590       result = Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__GetConnectionCount((Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > const *)arg1);
 591     } catch (std::out_of_range& e) {
 592       {
 593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 594       };
 595     } catch (std::exception& e) {
 596       {
 597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 598       };
 599     } catch (...) {
 600       {
 601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 602       };
 603     }
 604   }
 605   jresult = (unsigned long)result;
 606   return jresult;
 607 }
 608
 609 typedef void* (SWIGSTDCALL* SWIG_CallbackKbPreFocusChange)(void *, void *, int);
 610 SWIG_CallbackKbPreFocusChange swig_callbackOnKbPreFocusChange;
 611
 612 Dali::Actor OnKbPreFocusChangeCallback(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction)
 613 {
 614     Dali::Actor *actorp;
 615     Dali::Actor actor;
 616
 617     actorp = (Dali::Actor *)swig_callbackOnKbPreFocusChange((void *)&current, (void *)&proposed, direction);
 618     actor = *actorp;
 619
 620     return actor;
 621 }
 622
 623 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Connect(void * jarg1, SWIG_CallbackKbPreFocusChange callbackOnKbPreFocusChange) {
 624
 625   swig_callbackOnKbPreFocusChange = callbackOnKbPreFocusChange;
 626
 627   Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ;
 628   Dali::Actor (*arg2)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)) 0 ;
 629
 630   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 631   arg2 = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction))OnKbPreFocusChangeCallback;
 632
 633   {
 634     try {
 635       Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Connect(arg1,arg2);
 636     } catch (std::out_of_range& e) {
 637       {
 638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 639       };
 640     } catch (std::exception& e) {
 641       {
 642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 643       };
 644     } catch (...) {
 645       {
 646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 647       };
 648     }
 649   }
 650 }
 651
 652
 653 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Disconnect(void * jarg1, void * jarg2) {
 654   Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ;
 655   Dali::Actor (*arg2)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)) 0 ;
 656
 657   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 658   arg2 = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction))jarg2;
 659   {
 660     try {
 661       Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Disconnect(arg1,arg2);
 662     } catch (std::out_of_range& e) {
 663       {
 664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 665       };
 666     } catch (std::exception& e) {
 667       {
 668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 669       };
 670     } catch (...) {
 671       {
 672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 673       };
 674     }
 675   }
 676 }
 677
 678
 679 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Emit(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
 680   void * jresult ;
 681   Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ;
 682   Dali::Actor arg2 ;
 683   Dali::Actor arg3 ;
 684   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
 685   Dali::Actor *argp2 ;
 686   Dali::Actor *argp3 ;
 687   Dali::Actor result;
 688
 689   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 690   argp2 = (Dali::Actor *)jarg2;
 691   if (!argp2) {
 692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 693     return 0;
 694   }
 695   arg2 = *argp2;
 696   argp3 = (Dali::Actor *)jarg3;
 697   if (!argp3) {
 698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 699     return 0;
 700   }
 701   arg3 = *argp3;
 702   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
 703   {
 704     try {
 705       result = Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Emit(arg1,arg2,arg3,arg4);
 706     } catch (std::out_of_range& e) {
 707       {
 708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 709       };
 710     } catch (std::exception& e) {
 711       {
 712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 713       };
 714     } catch (...) {
 715       {
 716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 717       };
 718     }
 719   }
 720   jresult = new Dali::Actor((const Dali::Actor &)result);
 721   return jresult;
 722 }
 723
 724
 725 SWIGEXPORT void * SWIGSTDCALL CSharp_new_KeyboardPreFocusChangeSignal() {
 726   void * jresult ;
 727   Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *result = 0 ;
 728
 729   {
 730     try {
 731       result = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)new Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) >();
 732     } catch (std::out_of_range& e) {
 733       {
 734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 735       };
 736     } catch (std::exception& e) {
 737       {
 738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 739       };
 740     } catch (...) {
 741       {
 742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 743       };
 744     }
 745   }
 746   jresult = (void *)result;
 747   return jresult;
 748 }
 749
 750
 751 SWIGEXPORT void SWIGSTDCALL CSharp_delete_KeyboardPreFocusChangeSignal(void * jarg1) {
 752   Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ;
 753
 754   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 755   {
 756     try {
 757       delete arg1;
 758     } catch (std::out_of_range& e) {
 759       {
 760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 761       };
 762     } catch (std::exception& e) {
 763       {
 764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 765       };
 766     } catch (...) {
 767       {
 768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 769       };
 770     }
 771   }
 772 }
 773
 774 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_KeyboardFocusManager_SWIGUpcast(Dali::Toolkit::KeyboardFocusManager *jarg1) {
 775     return (Dali::BaseHandle *)jarg1;
 776 }
 777
 778 #ifdef __cplusplus
 779 }
 780 #endif
 781