plugins/dali-sharp/dali-bindings/keyboard_focus_manager_wrap.cpp

   1 /*
   2  * Copyright (c) 2017 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 Dali::Actor * (SWIGSTDCALL* SWIG_CallbackKbPreFocusChange)(Dali::Actor *, Dali::Actor *, 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     Dali::Actor *CurrentP = NULL;
 634     Dali::Actor *ProposedP = NULL;
 635
 636     if (current)
 637     {
 638       CurrentP = (Dali::Actor *)&current;
 639     }
 640
 641     if (proposed)
 642     {
 643       ProposedP = (Dali::Actor *)&proposed;
 644     }
 645
 646     actorp = (Dali::Actor *)swig_callbackOnKbPreFocusChange(CurrentP, ProposedP, direction);
 647
 648     if (actorp)
 649     {
 650       actor = *actorp;
 651     }
 652
 653     return actor;
 654 }
 655
 656 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Connect(void * jarg1, SWIG_CallbackKbPreFocusChange callbackOnKbPreFocusChange) {
 657
 658   swig_callbackOnKbPreFocusChange = callbackOnKbPreFocusChange;
 659
 660   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 ;
 661   Dali::Actor (*arg2)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)) 0 ;
 662
 663   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 664   arg2 = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction))OnKbPreFocusChangeCallback;
 665
 666   {
 667     try {
 668       Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Connect(arg1,arg2);
 669     } catch (std::out_of_range& e) {
 670       {
 671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 672       };
 673     } catch (std::exception& e) {
 674       {
 675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 676       };
 677     } catch (...) {
 678       {
 679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 680       };
 681     }
 682   }
 683 }
 684
 685
 686 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Disconnect(void * jarg1, void * jarg2) {
 687   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 ;
 688   Dali::Actor (*arg2)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)) 0 ;
 689
 690   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 691   arg2 = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction))jarg2;
 692   {
 693     try {
 694       Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Disconnect(arg1,arg2);
 695     } catch (std::out_of_range& e) {
 696       {
 697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 698       };
 699     } catch (std::exception& e) {
 700       {
 701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 702       };
 703     } catch (...) {
 704       {
 705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 706       };
 707     }
 708   }
 709 }
 710
 711
 712 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Emit(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
 713   void * jresult ;
 714   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 ;
 715   Dali::Actor arg2 ;
 716   Dali::Actor arg3 ;
 717   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
 718   Dali::Actor *argp2 ;
 719   Dali::Actor *argp3 ;
 720   Dali::Actor result;
 721
 722   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 723   argp2 = (Dali::Actor *)jarg2;
 724   if (!argp2) {
 725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 726     return 0;
 727   }
 728   arg2 = *argp2;
 729   argp3 = (Dali::Actor *)jarg3;
 730   if (!argp3) {
 731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 732     return 0;
 733   }
 734   arg3 = *argp3;
 735   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
 736   {
 737     try {
 738       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);
 739     } catch (std::out_of_range& e) {
 740       {
 741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 742       };
 743     } catch (std::exception& e) {
 744       {
 745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 746       };
 747     } catch (...) {
 748       {
 749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 750       };
 751     }
 752   }
 753   jresult = new Dali::Actor((const Dali::Actor &)result);
 754   return jresult;
 755 }
 756
 757
 758 SWIGEXPORT void * SWIGSTDCALL CSharp_new_KeyboardPreFocusChangeSignal() {
 759   void * jresult ;
 760   Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *result = 0 ;
 761
 762   {
 763     try {
 764       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) >();
 765     } catch (std::out_of_range& e) {
 766       {
 767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 768       };
 769     } catch (std::exception& e) {
 770       {
 771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 772       };
 773     } catch (...) {
 774       {
 775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 776       };
 777     }
 778   }
 779   jresult = (void *)result;
 780   return jresult;
 781 }
 782
 783
 784 SWIGEXPORT void SWIGSTDCALL CSharp_delete_KeyboardPreFocusChangeSignal(void * jarg1) {
 785   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 ;
 786
 787   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 788   {
 789     try {
 790       delete arg1;
 791     } catch (std::out_of_range& e) {
 792       {
 793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 794       };
 795     } catch (std::exception& e) {
 796       {
 797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 798       };
 799     } catch (...) {
 800       {
 801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 802       };
 803     }
 804   }
 805 }
 806
 807 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_KeyboardFocusManager_SWIGUpcast(Dali::Toolkit::KeyboardFocusManager *jarg1) {
 808     return (Dali::BaseHandle *)jarg1;
 809 }
 810
 811 #ifdef __cplusplus
 812 }
 813 #endif
 814