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

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