dali-csharp-binder/src/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 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_MoveFocusBackward(void * jarg1) {
 458   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 459
 460   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 461   {
 462     try {
 463       (arg1)->MoveFocusBackward();
 464     } catch (std::out_of_range& e) {
 465       {
 466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
 467       };
 468     } catch (std::exception& e) {
 469       {
 470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
 471       };
 472     } catch (...) {
 473       {
 474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
 475       };
 476     }
 477   }
 478 }
 479
 480 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_PreFocusChangeSignal(void * jarg1) {
 481   void * jresult ;
 482   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 483   Dali::Toolkit::KeyboardFocusManager::PreFocusChangeSignalType *result = 0 ;
 484
 485   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 486   {
 487     try {
 488       result = (Dali::Toolkit::KeyboardFocusManager::PreFocusChangeSignalType *) &(arg1)->PreFocusChangeSignal();
 489     } catch (std::out_of_range& e) {
 490       {
 491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 492       };
 493     } catch (std::exception& e) {
 494       {
 495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 496       };
 497     } catch (...) {
 498       {
 499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 500       };
 501     }
 502   }
 503   jresult = (void *)result;
 504   return jresult;
 505 }
 506
 507
 508 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_FocusChangedSignal(void * jarg1) {
 509   void * jresult ;
 510   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 511   Dali::Toolkit::KeyboardFocusManager::FocusChangedSignalType *result = 0 ;
 512
 513   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 514   {
 515     try {
 516       result = (Dali::Toolkit::KeyboardFocusManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
 517     } catch (std::out_of_range& e) {
 518       {
 519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 520       };
 521     } catch (std::exception& e) {
 522       {
 523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 524       };
 525     } catch (...) {
 526       {
 527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 528       };
 529     }
 530   }
 531   jresult = (void *)result;
 532   return jresult;
 533 }
 534
 535
 536 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_FocusGroupChangedSignal(void * jarg1) {
 537   void * jresult ;
 538   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 539   Dali::Toolkit::KeyboardFocusManager::FocusGroupChangedSignalType *result = 0 ;
 540
 541   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 542   {
 543     try {
 544       result = (Dali::Toolkit::KeyboardFocusManager::FocusGroupChangedSignalType *) &(arg1)->FocusGroupChangedSignal();
 545     } catch (std::out_of_range& e) {
 546       {
 547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 548       };
 549     } catch (std::exception& e) {
 550       {
 551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 552       };
 553     } catch (...) {
 554       {
 555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 556       };
 557     }
 558   }
 559   jresult = (void *)result;
 560   return jresult;
 561 }
 562
 563
 564 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_FocusedActorEnterKeySignal(void * jarg1) {
 565   void * jresult ;
 566   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 567   Dali::Toolkit::KeyboardFocusManager::FocusedActorEnterKeySignalType *result = 0 ;
 568
 569   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 570   {
 571     try {
 572       result = (Dali::Toolkit::KeyboardFocusManager::FocusedActorEnterKeySignalType *) &(arg1)->FocusedActorEnterKeySignal();
 573     } catch (std::out_of_range& e) {
 574       {
 575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 576       };
 577     } catch (std::exception& e) {
 578       {
 579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 580       };
 581     } catch (...) {
 582       {
 583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 584       };
 585     }
 586   }
 587   jresult = (void *)result;
 588   return jresult;
 589 }
 590
 591
 592
 593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Empty(void * jarg1) {
 594   unsigned int jresult ;
 595   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 ;
 596   bool result;
 597
 598   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 599   {
 600     try {
 601       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);
 602     } catch (std::out_of_range& e) {
 603       {
 604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 605       };
 606     } catch (std::exception& e) {
 607       {
 608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 609       };
 610     } catch (...) {
 611       {
 612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 613       };
 614     }
 615   }
 616   jresult = result;
 617   return jresult;
 618 }
 619
 620
 621 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_GetConnectionCount(void * jarg1) {
 622   unsigned long jresult ;
 623   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 ;
 624   std::size_t result;
 625
 626   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 627   {
 628     try {
 629       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);
 630     } catch (std::out_of_range& e) {
 631       {
 632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 633       };
 634     } catch (std::exception& e) {
 635       {
 636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 637       };
 638     } catch (...) {
 639       {
 640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 641       };
 642     }
 643   }
 644   jresult = (unsigned long)result;
 645   return jresult;
 646 }
 647
 648 typedef Dali::Actor* (SWIGSTDCALL* SWIG_CallbackKbPreFocusChange)(Dali::Actor *, Dali::Actor *, int);
 649 SWIG_CallbackKbPreFocusChange swig_callbackOnKbPreFocusChange;
 650
 651 Dali::Actor OnKbPreFocusChangeCallback(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction)
 652 {
 653     Dali::Actor *actorp;
 654     Dali::Actor actor;
 655     Dali::Actor *CurrentP = NULL;
 656     Dali::Actor *ProposedP = NULL;
 657
 658     if (current)
 659     {
 660       CurrentP = (Dali::Actor *)&current;
 661     }
 662
 663     if (proposed)
 664     {
 665       ProposedP = (Dali::Actor *)&proposed;
 666     }
 667
 668     actorp = (Dali::Actor *)swig_callbackOnKbPreFocusChange(CurrentP, ProposedP, direction);
 669     if (actorp)
 670     {
 671       actor = *actorp;
 672     }
 673
 674     return actor;
 675 }
 676
 677 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Connect(void * jarg1, SWIG_CallbackKbPreFocusChange callbackOnKbPreFocusChange) {
 678
 679   swig_callbackOnKbPreFocusChange = callbackOnKbPreFocusChange;
 680
 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)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)) 0 ;
 683
 684   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 685   arg2 = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction))OnKbPreFocusChangeCallback;
 686
 687   {
 688     try {
 689       Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Connect(arg1,arg2);
 690     } catch (std::out_of_range& e) {
 691       {
 692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 693       };
 694     } catch (std::exception& e) {
 695       {
 696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 697       };
 698     } catch (...) {
 699       {
 700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 701       };
 702     }
 703   }
 704 }
 705
 706
 707 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Disconnect(void * jarg1, SWIG_CallbackKbPreFocusChange callbackOnKbPreFocusChange) {
 708
 709   swig_callbackOnKbPreFocusChange = callbackOnKbPreFocusChange;
 710
 711   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 ;
 712   Dali::Actor (*arg2)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)) 0 ;
 713
 714   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 715   arg2 = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction))OnKbPreFocusChangeCallback;
 716   {
 717     try {
 718       Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Disconnect(arg1,arg2);
 719     } catch (std::out_of_range& e) {
 720       {
 721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 722       };
 723     } catch (std::exception& e) {
 724       {
 725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 726       };
 727     } catch (...) {
 728       {
 729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 730       };
 731     }
 732   }
 733 }
 734
 735 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Emit(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
 736   void * jresult ;
 737   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 ;
 738   Dali::Actor arg2 ;
 739   Dali::Actor arg3 ;
 740   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
 741   Dali::Actor *argp2 ;
 742   Dali::Actor *argp3 ;
 743   Dali::Actor result;
 744
 745   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 746   argp2 = (Dali::Actor *)jarg2;
 747   if (!argp2) {
 748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 749     return 0;
 750   }
 751   arg2 = *argp2;
 752   argp3 = (Dali::Actor *)jarg3;
 753   if (!argp3) {
 754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 755     return 0;
 756   }
 757   arg3 = *argp3;
 758   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
 759   {
 760     try {
 761       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);
 762     } catch (std::out_of_range& e) {
 763       {
 764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 765       };
 766     } catch (std::exception& e) {
 767       {
 768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 769       };
 770     } catch (...) {
 771       {
 772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 773       };
 774     }
 775   }
 776   jresult = new Dali::Actor((const Dali::Actor &)result);
 777   return jresult;
 778 }
 779
 780
 781 SWIGEXPORT void * SWIGSTDCALL CSharp_new_KeyboardPreFocusChangeSignal() {
 782   void * jresult ;
 783   Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *result = 0 ;
 784
 785   {
 786     try {
 787       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) >();
 788     } catch (std::out_of_range& e) {
 789       {
 790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 791       };
 792     } catch (std::exception& e) {
 793       {
 794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 795       };
 796     } catch (...) {
 797       {
 798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 799       };
 800     }
 801   }
 802   jresult = (void *)result;
 803   return jresult;
 804 }
 805
 806
 807 SWIGEXPORT void SWIGSTDCALL CSharp_delete_KeyboardPreFocusChangeSignal(void * jarg1) {
 808   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 ;
 809
 810   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 811   {
 812     try {
 813       delete arg1;
 814     } catch (std::out_of_range& e) {
 815       {
 816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 817       };
 818     } catch (std::exception& e) {
 819       {
 820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 821       };
 822     } catch (...) {
 823       {
 824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 825       };
 826     }
 827   }
 828 }
 829
 830 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_KeyboardFocusManager_SWIGUpcast(Dali::Toolkit::KeyboardFocusManager *jarg1) {
 831     return (Dali::BaseHandle *)jarg1;
 832 }
 833
 834 #ifdef __cplusplus
 835 }
 836 #endif
 837