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 (Dali::DaliException e) {
  60       {
  61         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
  62       };
  63     } catch (...) {
  64       {
  65         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
  66       };
  67     }
  68   }
  69
  70   jresult = (void *)result;
  71   return jresult;
  72 }
  73
  74
  75 SWIGEXPORT void SWIGSTDCALL CSharp_delete_KeyboardFocusManager(void * jarg1) {
  76   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
  77
  78   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
  79   {
  80     try {
  81       delete arg1;
  82     } catch (std::out_of_range& e) {
  83       {
  84         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
  85       };
  86     } catch (std::exception& e) {
  87       {
  88         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
  89       };
  90     } catch (Dali::DaliException e) {
  91       {
  92         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
  93       };
  94     } catch (...) {
  95       {
  96         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
  97       };
  98     }
  99   }
 100
 101 }
 102
 103
 104 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_Get() {
 105   void * jresult;
 106   Dali::Toolkit::KeyboardFocusManager result;
 107
 108   {
 109     try {
 110       result = Dali::Toolkit::KeyboardFocusManager::Get();
 111     } catch (std::out_of_range& e) {
 112       {
 113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 114       };
 115     } catch (std::exception& e) {
 116       {
 117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 118       };
 119     } catch (Dali::DaliException e) {
 120       {
 121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 122       };
 123     } catch (...) {
 124       {
 125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 126       };
 127     }
 128   }
 129
 130   jresult = new Dali::Toolkit::KeyboardFocusManager((const Dali::Toolkit::KeyboardFocusManager &)result);
 131   return jresult;
 132 }
 133
 134
 135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
 136   unsigned int jresult ;
 137   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 138   Dali::Actor arg2;
 139   Dali::Actor *argp2 ;
 140   bool result;
 141
 142   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 143   argp2 = (Dali::Actor *)jarg2;
 144   if (!argp2) {
 145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 146     return 0;
 147   }
 148   arg2 = *argp2;
 149   {
 150     try {
 151       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
 152     } catch (std::out_of_range& e) {
 153       {
 154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 155       };
 156     } catch (std::exception& e) {
 157       {
 158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 159       };
 160     } catch (Dali::DaliException e) {
 161       {
 162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 163       };
 164     } catch (...) {
 165       {
 166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 167       };
 168     }
 169   }
 170
 171   jresult = result;
 172   return jresult;
 173 }
 174
 175
 176 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_GetCurrentFocusActor(void * jarg1) {
 177   void * jresult ;
 178   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 179   Dali::Actor result;
 180
 181   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 182   {
 183     try {
 184       result = (arg1)->GetCurrentFocusActor();
 185     } catch (std::out_of_range& e) {
 186       {
 187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 188       };
 189     } catch (std::exception& e) {
 190       {
 191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 192       };
 193     } catch (Dali::DaliException e) {
 194       {
 195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 196       };
 197     } catch (...) {
 198       {
 199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 200       };
 201     }
 202   }
 203
 204   jresult = new Dali::Actor((const Dali::Actor &)result);
 205   return jresult;
 206 }
 207
 208
 209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_MoveFocus(void * jarg1, int jarg2) {
 210   unsigned int jresult ;
 211   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 212   Dali::Toolkit::Control::KeyboardFocus::Direction arg2;
 213   bool result;
 214
 215   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 216   arg2 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg2;
 217   {
 218     try {
 219       result = (bool)(arg1)->MoveFocus(arg2);
 220     } catch (std::out_of_range& e) {
 221       {
 222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 223       };
 224     } catch (std::exception& e) {
 225       {
 226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 227       };
 228     } catch (Dali::DaliException e) {
 229       {
 230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 231       };
 232     } catch (...) {
 233       {
 234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 235       };
 236     }
 237   }
 238
 239   jresult = result;
 240   return jresult;
 241 }
 242
 243
 244 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_ClearFocus(void * jarg1) {
 245   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 246
 247   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 248   {
 249     try {
 250       (arg1)->ClearFocus();
 251     } catch (std::out_of_range& e) {
 252       {
 253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
 254       };
 255     } catch (std::exception& e) {
 256       {
 257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
 258       };
 259     } catch (...) {
 260       {
 261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
 262       };
 263     }
 264   }
 265 }
 266
 267
 268 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_SetFocusGroupLoop(void * jarg1, unsigned int jarg2) {
 269   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0;
 270   bool arg2;
 271
 272   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 273   arg2 = jarg2 ? true : false;
 274   {
 275     try {
 276       (arg1)->SetFocusGroupLoop(arg2);
 277     } catch (std::out_of_range& e) {
 278       {
 279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
 280       };
 281     } catch (std::exception& e) {
 282       {
 283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
 284       };
 285     } catch (Dali::DaliException e) {
 286       {
 287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 288       };
 289     } catch (...) {
 290       {
 291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 292       };
 293     }
 294   }
 295
 296 }
 297
 298
 299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_GetFocusGroupLoop(void * jarg1) {
 300   unsigned int jresult ;
 301   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 302   bool result;
 303
 304   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 305   {
 306     try {
 307       result = (bool)((Dali::Toolkit::KeyboardFocusManager const *)arg1)->GetFocusGroupLoop();
 308     } catch (std::out_of_range& e) {
 309       {
 310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 311       };
 312     } catch (std::exception& e) {
 313       {
 314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 315       };
 316     } catch (Dali::DaliException e) {
 317       {
 318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 319       };
 320     } catch (...) {
 321       {
 322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 323       };
 324     }
 325   }
 326
 327   jresult = result;
 328   return jresult;
 329 }
 330
 331
 332 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_SetAsFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
 333   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 334   Dali::Actor arg2 ;
 335   bool arg3 ;
 336   Dali::Actor *argp2 ;
 337
 338   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 339   argp2 = (Dali::Actor *)jarg2;
 340   if (!argp2) {
 341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 342     return ;
 343   }
 344   arg2 = *argp2;
 345   arg3 = jarg3 ? true : false;
 346   {
 347     try {
 348       (arg1)->SetAsFocusGroup(arg2,arg3);
 349     } catch (std::out_of_range& e) {
 350       {
 351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 352       };
 353     } catch (std::exception& e) {
 354       {
 355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 356       };
 357     } catch (Dali::DaliException e) {
 358       {
 359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 360       };
 361     } catch (...) {
 362       {
 363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 364       };
 365     }
 366   }
 367
 368 }
 369
 370
 371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_IsFocusGroup(void * jarg1, void * jarg2) {
 372   unsigned int jresult ;
 373   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 374   Dali::Actor arg2 ;
 375   Dali::Actor *argp2 ;
 376   bool result;
 377
 378   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 379   argp2 = (Dali::Actor *)jarg2;
 380   if (!argp2) {
 381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 382     return 0;
 383   }
 384   arg2 = *argp2;
 385   {
 386     try {
 387       result = (bool)((Dali::Toolkit::KeyboardFocusManager const *)arg1)->IsFocusGroup(arg2);
 388     } catch (std::out_of_range& e) {
 389       {
 390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 391       };
 392     } catch (std::exception& e) {
 393       {
 394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 395       };
 396     } catch (Dali::DaliException e) {
 397       {
 398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 399       };
 400     } catch (...) {
 401       {
 402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 403       };
 404     }
 405   }
 406
 407   jresult = result;
 408   return jresult;
 409 }
 410
 411
 412 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_GetFocusGroup(void * jarg1, void * jarg2) {
 413   void * jresult ;
 414   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 415   Dali::Actor arg2 ;
 416   Dali::Actor *argp2 ;
 417   Dali::Actor result;
 418
 419   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 420   argp2 = (Dali::Actor *)jarg2;
 421   if (!argp2) {
 422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 423     return 0;
 424   }
 425   arg2 = *argp2;
 426   {
 427     try {
 428       result = (arg1)->GetFocusGroup(arg2);
 429     } catch (std::out_of_range& e) {
 430       {
 431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 432       };
 433     } catch (std::exception& e) {
 434       {
 435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 436       };
 437     } catch (Dali::DaliException e) {
 438       {
 439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 440       };
 441     } catch (...) {
 442       {
 443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 444       };
 445     }
 446   }
 447
 448   jresult = new Dali::Actor((const Dali::Actor &)result);
 449   return jresult;
 450 }
 451
 452
 453 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
 454   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 455   Dali::Actor arg2 ;
 456   Dali::Actor *argp2 ;
 457
 458   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 459   argp2 = (Dali::Actor *)jarg2;
 460   if (!argp2) {
 461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 462     return ;
 463   }
 464   arg2 = *argp2;
 465   {
 466     try {
 467       (arg1)->SetFocusIndicatorActor(arg2);
 468     } catch (std::out_of_range& e) {
 469       {
 470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 471       };
 472     } catch (std::exception& e) {
 473       {
 474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 475       };
 476     } catch (Dali::DaliException e) {
 477       {
 478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 479       };
 480     } catch (...) {
 481       {
 482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 483       };
 484     }
 485   }
 486
 487 }
 488
 489
 490 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_GetFocusIndicatorActor(void * jarg1) {
 491   void * jresult ;
 492   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 493   Dali::Actor result;
 494
 495   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 496   {
 497     try {
 498       result = (arg1)->GetFocusIndicatorActor();
 499     } catch (std::out_of_range& e) {
 500       {
 501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 502       };
 503     } catch (std::exception& e) {
 504       {
 505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 506       };
 507     } catch (Dali::DaliException e) {
 508       {
 509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 510       };
 511     } catch (...) {
 512       {
 513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 514       };
 515     }
 516   }
 517
 518   jresult = new Dali::Actor((const Dali::Actor &)result);
 519   return jresult;
 520 }
 521
 522 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_MoveFocusBackward(void * jarg1) {
 523   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 524
 525   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 526   {
 527     try {
 528       (arg1)->MoveFocusBackward();
 529     } catch (std::out_of_range& e) {
 530       {
 531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
 532       };
 533     } catch (std::exception& e) {
 534       {
 535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
 536       };
 537     } catch (...) {
 538       {
 539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
 540       };
 541     }
 542   }
 543 }
 544
 545 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_PreFocusChangeSignal(void * jarg1) {
 546   void * jresult ;
 547   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 548   Dali::Toolkit::KeyboardFocusManager::PreFocusChangeSignalType *result = 0 ;
 549
 550   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 551   {
 552     try {
 553       result = (Dali::Toolkit::KeyboardFocusManager::PreFocusChangeSignalType *) &(arg1)->PreFocusChangeSignal();
 554     } catch (std::out_of_range& e) {
 555       {
 556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 557       };
 558     } catch (std::exception& e) {
 559       {
 560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 561       };
 562     } catch (Dali::DaliException e) {
 563       {
 564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 565       };
 566     } catch (...) {
 567       {
 568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 569       };
 570     }
 571   }
 572
 573   jresult = (void *)result;
 574   return jresult;
 575 }
 576
 577
 578 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_FocusChangedSignal(void * jarg1) {
 579   void * jresult ;
 580   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 581   Dali::Toolkit::KeyboardFocusManager::FocusChangedSignalType *result = 0 ;
 582
 583   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 584   {
 585     try {
 586       result = (Dali::Toolkit::KeyboardFocusManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
 587     } catch (std::out_of_range& e) {
 588       {
 589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 590       };
 591     } catch (std::exception& e) {
 592       {
 593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 594       };
 595     } catch (Dali::DaliException e) {
 596       {
 597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 598       };
 599     } catch (...) {
 600       {
 601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 602       };
 603     }
 604   }
 605
 606   jresult = (void *)result;
 607   return jresult;
 608 }
 609
 610
 611 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_FocusGroupChangedSignal(void * jarg1) {
 612   void * jresult ;
 613   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 614   Dali::Toolkit::KeyboardFocusManager::FocusGroupChangedSignalType *result = 0 ;
 615
 616   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 617   {
 618     try {
 619       result = (Dali::Toolkit::KeyboardFocusManager::FocusGroupChangedSignalType *) &(arg1)->FocusGroupChangedSignal();
 620     } catch (std::out_of_range& e) {
 621       {
 622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 623       };
 624     } catch (std::exception& e) {
 625       {
 626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 627       };
 628     } catch (Dali::DaliException e) {
 629       {
 630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 631       };
 632     } catch (...) {
 633       {
 634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 635       };
 636     }
 637   }
 638
 639   jresult = (void *)result;
 640   return jresult;
 641 }
 642
 643
 644 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_FocusedActorEnterKeySignal(void * jarg1) {
 645   void * jresult ;
 646   Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ;
 647   Dali::Toolkit::KeyboardFocusManager::FocusedActorEnterKeySignalType *result = 0 ;
 648
 649   arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1;
 650   {
 651     try {
 652       result = (Dali::Toolkit::KeyboardFocusManager::FocusedActorEnterKeySignalType *) &(arg1)->FocusedActorEnterKeySignal();
 653     } catch (std::out_of_range& e) {
 654       {
 655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 656       };
 657     } catch (std::exception& e) {
 658       {
 659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 660       };
 661     } catch (Dali::DaliException e) {
 662       {
 663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 664       };
 665     } catch (...) {
 666       {
 667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 668       };
 669     }
 670   }
 671
 672   jresult = (void *)result;
 673   return jresult;
 674 }
 675
 676
 677
 678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Empty(void * jarg1) {
 679   unsigned int jresult ;
 680   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 ;
 681   bool result;
 682
 683   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 684   {
 685     try {
 686       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);
 687     } catch (std::out_of_range& e) {
 688       {
 689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 690       };
 691     } catch (std::exception& e) {
 692       {
 693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 694       };
 695     } catch (Dali::DaliException e) {
 696       {
 697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 698       };
 699     } catch (...) {
 700       {
 701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 702       };
 703     }
 704   }
 705
 706   jresult = result;
 707   return jresult;
 708 }
 709
 710
 711 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_GetConnectionCount(void * jarg1) {
 712   unsigned long jresult ;
 713   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 ;
 714   std::size_t result;
 715
 716   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 717   {
 718     try {
 719       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);
 720     } catch (std::out_of_range& e) {
 721       {
 722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 723       };
 724     } catch (std::exception& e) {
 725       {
 726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 727       };
 728     } catch (Dali::DaliException e) {
 729       {
 730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 731       };
 732     } catch (...) {
 733       {
 734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 735       };
 736     }
 737   }
 738
 739   jresult = (unsigned long)result;
 740   return jresult;
 741 }
 742
 743 typedef Dali::Actor* (SWIGSTDCALL* SWIG_CallbackKbPreFocusChange)(Dali::Actor *, Dali::Actor *, int);
 744 SWIG_CallbackKbPreFocusChange swig_callbackOnKbPreFocusChange;
 745
 746 Dali::Actor OnKbPreFocusChangeCallback(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction)
 747 {
 748     Dali::Actor *actorp;
 749     Dali::Actor actor;
 750     Dali::Actor *CurrentP = NULL;
 751     Dali::Actor *ProposedP = NULL;
 752
 753     if (current)
 754     {
 755       CurrentP = (Dali::Actor *)&current;
 756     }
 757
 758     if (proposed)
 759     {
 760       ProposedP = (Dali::Actor *)&proposed;
 761     }
 762
 763     actorp = (Dali::Actor *)swig_callbackOnKbPreFocusChange(CurrentP, ProposedP, direction);
 764     if (actorp)
 765     {
 766       actor = *actorp;
 767     }
 768
 769     return actor;
 770 }
 771
 772 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Connect(void * jarg1, SWIG_CallbackKbPreFocusChange callbackOnKbPreFocusChange) {
 773
 774   swig_callbackOnKbPreFocusChange = callbackOnKbPreFocusChange;
 775
 776   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 ;
 777   Dali::Actor (*arg2)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)) 0 ;
 778
 779   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 780   arg2 = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction))OnKbPreFocusChangeCallback;
 781
 782   {
 783     try {
 784       Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Connect(arg1,arg2);
 785     } catch (std::out_of_range& e) {
 786       {
 787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 788       };
 789     } catch (std::exception& e) {
 790       {
 791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 792       };
 793     } catch (Dali::DaliException e) {
 794       {
 795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 796       };
 797     } catch (...) {
 798       {
 799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 800       };
 801     }
 802   }
 803
 804 }
 805
 806
 807 SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Disconnect(void * jarg1, SWIG_CallbackKbPreFocusChange callbackOnKbPreFocusChange) {
 808
 809   swig_callbackOnKbPreFocusChange = callbackOnKbPreFocusChange;
 810
 811   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 ;
 812   Dali::Actor (*arg2)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)) 0 ;
 813
 814   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 815   arg2 = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction))OnKbPreFocusChangeCallback;
 816   {
 817     try {
 818       Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Disconnect(arg1,arg2);
 819     } catch (std::out_of_range& e) {
 820       {
 821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 822       };
 823     } catch (std::exception& e) {
 824       {
 825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 826       };
 827     } catch (Dali::DaliException e) {
 828       {
 829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 830       };
 831     } catch (...) {
 832       {
 833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 834       };
 835     }
 836   }
 837
 838 }
 839
 840 SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Emit(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
 841   void * jresult ;
 842   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 ;
 843   Dali::Actor arg2 ;
 844   Dali::Actor arg3 ;
 845   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
 846   Dali::Actor *argp2 ;
 847   Dali::Actor *argp3 ;
 848   Dali::Actor result;
 849
 850   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 851   argp2 = (Dali::Actor *)jarg2;
 852   if (!argp2) {
 853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 854     return 0;
 855   }
 856   arg2 = *argp2;
 857   argp3 = (Dali::Actor *)jarg3;
 858   if (!argp3) {
 859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
 860     return 0;
 861   }
 862   arg3 = *argp3;
 863   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
 864   {
 865     try {
 866       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);
 867     } catch (std::out_of_range& e) {
 868       {
 869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 870       };
 871     } catch (std::exception& e) {
 872       {
 873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 874       };
 875     } catch (Dali::DaliException e) {
 876       {
 877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 878       };
 879     } catch (...) {
 880       {
 881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 882       };
 883     }
 884   }
 885
 886   jresult = new Dali::Actor((const Dali::Actor &)result);
 887   return jresult;
 888 }
 889
 890
 891 SWIGEXPORT void * SWIGSTDCALL CSharp_new_KeyboardPreFocusChangeSignal() {
 892   void * jresult ;
 893   Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *result = 0 ;
 894
 895   {
 896     try {
 897       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) >();
 898     } catch (std::out_of_range& e) {
 899       {
 900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 901       };
 902     } catch (std::exception& e) {
 903       {
 904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 905       };
 906     } catch (Dali::DaliException e) {
 907       {
 908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 909       };
 910     } catch (...) {
 911       {
 912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 913       };
 914     }
 915   }
 916
 917   jresult = (void *)result;
 918   return jresult;
 919 }
 920
 921
 922 SWIGEXPORT void SWIGSTDCALL CSharp_delete_KeyboardPreFocusChangeSignal(void * jarg1) {
 923   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 ;
 924
 925   arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1;
 926   {
 927     try {
 928       delete arg1;
 929     } catch (std::out_of_range& e) {
 930       {
 931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 932       };
 933     } catch (std::exception& e) {
 934       {
 935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 936       };
 937     } catch (Dali::DaliException e) {
 938       {
 939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 940       };
 941     } catch (...) {
 942       {
 943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 944       };
 945     }
 946   }
 947
 948 }
 949
 950 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_KeyboardFocusManager_SWIGUpcast(Dali::Toolkit::KeyboardFocusManager *jarg1) {
 951     return (Dali::BaseHandle *)jarg1;
 952 }
 953
 954 #ifdef __cplusplus
 955 }
 956 #endif
 957