dali-csharp-binder/src/window.cpp

   1 /** Copyright (c) 2018 Samsung Electronics Co., Ltd.
   2 *
   3 * Licensed under the Apache License, Version 2.0 (the "License");
   4 * you may not use this file except in compliance with the License.
   5 * You may obtain a copy of the License at
   6 *
   7 * http://www.apache.org/licenses/LICENSE-2.0
   8 *
   9 * Unless required by applicable law or agreed to in writing, software
  10 * distributed under the License is distributed on an "AS IS" BASIS,
  11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 * See the License for the specific language governing permissions and
  13 * limitations under the License.
  14 *
  15 */
  16
  17 #ifndef CSHARP_WINDOW
  18 #define CSHARP_WINDOW
  19 #endif
  20
  21 #include "common.h"
  22 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
  23 #include <dali/devel-api/adaptor-framework/window-devel.h>
  24 #include <dali/public-api/adaptor-framework/window.h>
  25 #include <dali/integration-api/adaptors/adaptor.h>
  26
  27 #include <dali-toolkit/devel-api/controls/control-devel.h>
  28 #include <dali-toolkit/devel-api/layouting/absolute-layout.h>
  29
  30 /* Callback for returning strings to C# without leaking memory */
  31 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
  32 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
  33
  34
  35
  36 SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (bool) > const *self){
  37   return self->Empty();
  38 }
  39 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (bool) > const *self){
  40 return self->GetConnectionCount();
  41 }
  42 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
  43   self->Connect( func );
  44 }
  45 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
  46   self->Disconnect( func );
  47 }
  48 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (bool) > *self,bool arg){
  49   self->Emit( arg );
  50 }
  51
  52 /*ResizedSignal*/
  53 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Empty(Dali::Signal< void (Dali::Window::WindowSize) > const *self){
  54   return self->Empty();
  55 }
  56 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Window::WindowSize) > const *self){
  57 return self->GetConnectionCount();
  58 }
  59 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Connect(Dali::Signal< void (Dali::Window::WindowSize) > *self,void (*func)(Dali::Window::WindowSize)){
  60   self->Connect( func );
  61 }
  62 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Disconnect(Dali::Signal< void (Dali::Window::WindowSize) > *self,void (*func)(Dali::Window::WindowSize)){
  63   self->Disconnect( func );
  64 }
  65 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Emit(Dali::Signal< void (Dali::Window::WindowSize) > *self,Dali::Window::WindowSize arg){
  66   self->Emit( arg );
  67 }
  68
  69 #ifdef __cplusplus
  70 extern "C" {
  71 #endif
  72
  73 /*Window binding*/
  74 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
  75   return (Dali::BaseHandle *)jarg1;
  76 }
  77
  78 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
  79   void * jresult ;
  80   Dali::PositionSize arg1 ;
  81   std::string *arg2 = 0 ;
  82   bool arg3 ;
  83   Dali::PositionSize *argp1 ;
  84   Dali::Window result;
  85
  86   argp1 = (Dali::PositionSize *)jarg1;
  87   if (!argp1) {
  88     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
  89     return 0;
  90   }
  91   arg1 = *argp1;
  92   if (!jarg2) {
  93     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
  94     return 0;
  95   }
  96   std::string arg2_str(jarg2);
  97   arg2 = &arg2_str;
  98   arg3 = jarg3 ? true : false;
  99   {
 100     try {
 101       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
 102     } catch (std::out_of_range& e) {
 103       {
 104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 105       };
 106     } catch (std::exception& e) {
 107       {
 108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 109       };
 110     } catch (Dali::DaliException e) {
 111       {
 112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 113       };
 114     } catch (...) {
 115       {
 116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 117       };
 118     }
 119   }
 120
 121   jresult = new Dali::Window((const Dali::Window &)result);
 122
 123   //argout typemap for const std::string&
 124
 125   return jresult;
 126 }
 127
 128
 129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
 130   void * jresult ;
 131   Dali::PositionSize arg1 ;
 132   std::string *arg2 = 0 ;
 133   Dali::PositionSize *argp1 ;
 134   Dali::Window result;
 135
 136   argp1 = (Dali::PositionSize *)jarg1;
 137   if (!argp1) {
 138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
 139     return 0;
 140   }
 141   arg1 = *argp1;
 142   if (!jarg2) {
 143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 144     return 0;
 145   }
 146   std::string arg2_str(jarg2);
 147   arg2 = &arg2_str;
 148   {
 149     try {
 150       result = Dali::Window::New(arg1,(std::string const &)*arg2);
 151     } catch (std::out_of_range& e) {
 152       {
 153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 154       };
 155     } catch (std::exception& e) {
 156       {
 157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 158       };
 159     } catch (Dali::DaliException e) {
 160       {
 161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 162       };
 163     } catch (...) {
 164       {
 165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 166       };
 167     }
 168   }
 169
 170   jresult = new Dali::Window((const Dali::Window &)result);
 171
 172   //argout typemap for const std::string&
 173
 174   return jresult;
 175 }
 176
 177
 178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
 179   void * jresult ;
 180   Dali::PositionSize arg1 ;
 181   std::string *arg2 = 0 ;
 182   std::string *arg3 = 0 ;
 183   bool arg4 ;
 184   Dali::PositionSize *argp1 ;
 185   Dali::Window result;
 186
 187   argp1 = (Dali::PositionSize *)jarg1;
 188   if (!argp1) {
 189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
 190     return 0;
 191   }
 192   arg1 = *argp1;
 193   if (!jarg2) {
 194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 195     return 0;
 196   }
 197   std::string arg2_str(jarg2);
 198   arg2 = &arg2_str;
 199   if (!jarg3) {
 200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 201     return 0;
 202   }
 203   std::string arg3_str(jarg3);
 204   arg3 = &arg3_str;
 205   arg4 = jarg4 ? true : false;
 206   {
 207     try {
 208       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
 209     } catch (std::out_of_range& e) {
 210       {
 211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 212       };
 213     } catch (std::exception& e) {
 214       {
 215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 216       };
 217     } catch (Dali::DaliException e) {
 218       {
 219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 220       };
 221     } catch (...) {
 222       {
 223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 224       };
 225     }
 226   }
 227
 228   jresult = new Dali::Window((const Dali::Window &)result);
 229
 230   return jresult;
 231 }
 232
 233
 234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
 235   void * jresult ;
 236   Dali::PositionSize arg1 ;
 237   std::string *arg2 = 0 ;
 238   std::string *arg3 = 0 ;
 239   Dali::PositionSize *argp1 ;
 240   Dali::Window result;
 241
 242   argp1 = (Dali::PositionSize *)jarg1;
 243   if (!argp1) {
 244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
 245     return 0;
 246   }
 247   arg1 = *argp1;
 248   if (!jarg2) {
 249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 250     return 0;
 251   }
 252   std::string arg2_str(jarg2);
 253   arg2 = &arg2_str;
 254   if (!jarg3) {
 255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 256     return 0;
 257   }
 258   std::string arg3_str(jarg3);
 259   arg3 = &arg3_str;
 260   {
 261     try {
 262       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
 263     } catch (std::out_of_range& e) {
 264       {
 265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 266       };
 267     } catch (std::exception& e) {
 268       {
 269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 270       };
 271     } catch (Dali::DaliException e) {
 272       {
 273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 274       };
 275     } catch (...) {
 276       {
 277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 278       };
 279     }
 280   }
 281
 282   jresult = new Dali::Window((const Dali::Window &)result);
 283
 284   return jresult;
 285 }
 286
 287
 288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
 289   void * jresult ;
 290   Dali::Window *result = 0 ;
 291
 292   {
 293     try {
 294       result = (Dali::Window *)new Dali::Window();
 295     } catch (std::out_of_range& e) {
 296       {
 297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 298       };
 299     } catch (std::exception& e) {
 300       {
 301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 302       };
 303     } catch (Dali::DaliException e) {
 304       {
 305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 306       };
 307     } catch (...) {
 308       {
 309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 310       };
 311     }
 312   }
 313
 314   jresult = (void *)result;
 315   return jresult;
 316 }
 317
 318
 319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
 320   Dali::Window *arg1 = (Dali::Window *) 0 ;
 321
 322   arg1 = (Dali::Window *)jarg1;
 323   {
 324     try {
 325       delete arg1;
 326     } catch (std::out_of_range& e) {
 327       {
 328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 329       };
 330     } catch (std::exception& e) {
 331       {
 332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 333       };
 334     } catch (Dali::DaliException e) {
 335       {
 336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 337       };
 338     } catch (...) {
 339       {
 340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 341       };
 342     }
 343   }
 344
 345 }
 346
 347
 348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
 349   void * jresult ;
 350   Dali::Window *arg1 = 0 ;
 351   Dali::Window *result = 0 ;
 352
 353   arg1 = (Dali::Window *)jarg1;
 354   if (!arg1) {
 355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
 356     return 0;
 357   }
 358   {
 359     try {
 360       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
 361     } catch (std::out_of_range& e) {
 362       {
 363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 364       };
 365     } catch (std::exception& e) {
 366       {
 367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 368       };
 369     } catch (Dali::DaliException e) {
 370       {
 371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 372       };
 373     } catch (...) {
 374       {
 375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 376       };
 377     }
 378   }
 379
 380   jresult = (void *)result;
 381   return jresult;
 382 }
 383
 384
 385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
 386   void * jresult ;
 387   Dali::Window *arg1 = (Dali::Window *) 0 ;
 388   Dali::Window *arg2 = 0 ;
 389   Dali::Window *result = 0 ;
 390
 391   arg1 = (Dali::Window *)jarg1;
 392   arg2 = (Dali::Window *)jarg2;
 393   if (!arg2) {
 394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
 395     return 0;
 396   }
 397   {
 398     try {
 399       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
 400     } catch (std::out_of_range& e) {
 401       {
 402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 403       };
 404     } catch (std::exception& e) {
 405       {
 406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 407       };
 408     } catch (Dali::DaliException e) {
 409       {
 410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 411       };
 412     } catch (...) {
 413       {
 414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 415       };
 416     }
 417   }
 418
 419   jresult = (void *)result;
 420   return jresult;
 421 }
 422
 423
 424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
 425   Dali::Window *arg1 = (Dali::Window *) 0 ;
 426   Dali::Window::IndicatorVisibleMode arg2 ;
 427
 428   arg1 = (Dali::Window *)jarg1;
 429   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
 430   {
 431     try {
 432       (arg1)->ShowIndicator(arg2);
 433     } catch (std::out_of_range& e) {
 434       {
 435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 436       };
 437     } catch (std::exception& e) {
 438       {
 439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 440       };
 441     } catch (Dali::DaliException e) {
 442       {
 443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 444       };
 445     } catch (...) {
 446       {
 447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 448       };
 449     }
 450   }
 451
 452 }
 453
 454
 455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
 456   Dali::Window *arg1 = (Dali::Window *) 0 ;
 457   Dali::Window::IndicatorBgOpacity arg2 ;
 458
 459   arg1 = (Dali::Window *)jarg1;
 460   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
 461   {
 462     try {
 463       (arg1)->SetIndicatorBgOpacity(arg2);
 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 (Dali::DaliException e) {
 473       {
 474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 475       };
 476     } catch (...) {
 477       {
 478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 479       };
 480     }
 481   }
 482
 483 }
 484
 485
 486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
 487   Dali::Window *arg1 = (Dali::Window *) 0 ;
 488   Dali::Window::WindowOrientation arg2 ;
 489
 490   arg1 = (Dali::Window *)jarg1;
 491   arg2 = (Dali::Window::WindowOrientation)jarg2;
 492   {
 493     try {
 494       (arg1)->RotateIndicator(arg2);
 495     } catch (std::out_of_range& e) {
 496       {
 497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 498       };
 499     } catch (std::exception& e) {
 500       {
 501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 502       };
 503     } catch (Dali::DaliException e) {
 504       {
 505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 506       };
 507     } catch (...) {
 508       {
 509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 510       };
 511     }
 512   }
 513
 514 }
 515
 516
 517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
 518   Dali::Window *arg1 = (Dali::Window *) 0 ;
 519   std::string arg2 ;
 520   std::string arg3 ;
 521
 522   arg1 = (Dali::Window *)jarg1;
 523   if (!jarg2) {
 524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 525     return ;
 526   }
 527   (&arg2)->assign(jarg2);
 528   if (!jarg3) {
 529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 530     return ;
 531   }
 532   (&arg3)->assign(jarg3);
 533   {
 534     try {
 535       (arg1)->SetClass(arg2,arg3);
 536     } catch (std::out_of_range& e) {
 537       {
 538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 539       };
 540     } catch (std::exception& e) {
 541       {
 542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 543       };
 544     } catch (Dali::DaliException e) {
 545       {
 546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 547       };
 548     } catch (...) {
 549       {
 550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 551       };
 552     }
 553   }
 554
 555 }
 556
 557
 558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
 559   Dali::Window *arg1 = (Dali::Window *) 0 ;
 560
 561   arg1 = (Dali::Window *)jarg1;
 562   {
 563     try {
 564       (arg1)->Raise();
 565     } catch (std::out_of_range& e) {
 566       {
 567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 568       };
 569     } catch (std::exception& e) {
 570       {
 571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 572       };
 573     } catch (Dali::DaliException e) {
 574       {
 575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 576       };
 577     } catch (...) {
 578       {
 579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 580       };
 581     }
 582   }
 583
 584 }
 585
 586
 587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
 588   Dali::Window *arg1 = (Dali::Window *) 0 ;
 589
 590   arg1 = (Dali::Window *)jarg1;
 591   {
 592     try {
 593       (arg1)->Lower();
 594     } catch (std::out_of_range& e) {
 595       {
 596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 597       };
 598     } catch (std::exception& e) {
 599       {
 600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 601       };
 602     } catch (Dali::DaliException e) {
 603       {
 604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 605       };
 606     } catch (...) {
 607       {
 608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 609       };
 610     }
 611   }
 612
 613 }
 614
 615
 616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
 617   Dali::Window *arg1 = (Dali::Window *) 0 ;
 618
 619   arg1 = (Dali::Window *)jarg1;
 620   {
 621     try {
 622       (arg1)->Activate();
 623     } catch (std::out_of_range& e) {
 624       {
 625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 626       };
 627     } catch (std::exception& e) {
 628       {
 629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 630       };
 631     } catch (Dali::DaliException e) {
 632       {
 633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 634       };
 635     } catch (...) {
 636       {
 637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 638       };
 639     }
 640   }
 641
 642 }
 643
 644
 645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
 646   Dali::Window *arg1 = (Dali::Window *) 0 ;
 647   Dali::Window::WindowOrientation arg2 ;
 648
 649   arg1 = (Dali::Window *)jarg1;
 650   arg2 = (Dali::Window::WindowOrientation)jarg2;
 651   {
 652     try {
 653       (arg1)->AddAvailableOrientation(arg2);
 654     } catch (std::out_of_range& e) {
 655       {
 656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 657       };
 658     } catch (std::exception& e) {
 659       {
 660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 661       };
 662     } catch (Dali::DaliException e) {
 663       {
 664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 665       };
 666     } catch (...) {
 667       {
 668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 669       };
 670     }
 671   }
 672
 673 }
 674
 675
 676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
 677   Dali::Window *arg1 = (Dali::Window *) 0 ;
 678   Dali::Window::WindowOrientation arg2 ;
 679
 680   arg1 = (Dali::Window *)jarg1;
 681   arg2 = (Dali::Window::WindowOrientation)jarg2;
 682   {
 683     try {
 684       (arg1)->RemoveAvailableOrientation(arg2);
 685     } catch (std::out_of_range& e) {
 686       {
 687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 688       };
 689     } catch (std::exception& e) {
 690       {
 691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 692       };
 693     } catch (Dali::DaliException e) {
 694       {
 695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 696       };
 697     } catch (...) {
 698       {
 699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 700       };
 701     }
 702   }
 703
 704 }
 705
 706
 707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
 708   Dali::Window *arg1 = (Dali::Window *) 0 ;
 709   Dali::Window::WindowOrientation arg2 ;
 710
 711   arg1 = (Dali::Window *)jarg1;
 712   arg2 = (Dali::Window::WindowOrientation)jarg2;
 713   {
 714     try {
 715       (arg1)->SetPreferredOrientation(arg2);
 716     } catch (std::out_of_range& e) {
 717       {
 718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 719       };
 720     } catch (std::exception& e) {
 721       {
 722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 723       };
 724     } catch (Dali::DaliException e) {
 725       {
 726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 727       };
 728     } catch (...) {
 729       {
 730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 731       };
 732     }
 733   }
 734
 735 }
 736
 737
 738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
 739   int jresult ;
 740   Dali::Window *arg1 = (Dali::Window *) 0 ;
 741   Dali::Window::WindowOrientation result;
 742
 743   arg1 = (Dali::Window *)jarg1;
 744   {
 745     try {
 746       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
 747     } catch (std::out_of_range& e) {
 748       {
 749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 750       };
 751     } catch (std::exception& e) {
 752       {
 753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 754       };
 755     } catch (Dali::DaliException e) {
 756       {
 757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 758       };
 759     } catch (...) {
 760       {
 761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 762       };
 763     }
 764   }
 765
 766   jresult = (int)result;
 767   return jresult;
 768 }
 769
 770
 771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
 772   void * jresult ;
 773   Dali::Window *arg1 = (Dali::Window *) 0 ;
 774   Dali::DragAndDropDetector result;
 775
 776   arg1 = (Dali::Window *)jarg1;
 777   {
 778     try {
 779       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
 780     } catch (std::out_of_range& e) {
 781       {
 782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 783       };
 784     } catch (std::exception& e) {
 785       {
 786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 787       };
 788     } catch (Dali::DaliException e) {
 789       {
 790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 791       };
 792     } catch (...) {
 793       {
 794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 795       };
 796     }
 797   }
 798
 799   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
 800   return jresult;
 801 }
 802
 803
 804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
 805   void * jresult ;
 806   Dali::Window *arg1 = (Dali::Window *) 0 ;
 807   Dali::Any result;
 808
 809   arg1 = (Dali::Window *)jarg1;
 810   {
 811     try {
 812       result = ((Dali::Window const *)arg1)->GetNativeHandle();
 813     } catch (std::out_of_range& e) {
 814       {
 815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 816       };
 817     } catch (std::exception& e) {
 818       {
 819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 820       };
 821     } catch (Dali::DaliException e) {
 822       {
 823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 824       };
 825     } catch (...) {
 826       {
 827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 828       };
 829     }
 830   }
 831
 832   jresult = new Dali::Any((const Dali::Any &)result);
 833   return jresult;
 834 }
 835
 836 /*window-devel binding*/
 837
 838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
 839   void * jresult ;
 840   Dali::Window arg1 ;
 841   Dali::Window *argp1 ;
 842   Dali::Window::FocusSignalType *result = 0 ;
 843
 844   argp1 = (Dali::Window *)jarg1;
 845   if (!argp1) {
 846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 847     return 0;
 848   }
 849   arg1 = *argp1;
 850   {
 851     try {
 852       result = (Dali::Window::FocusSignalType*)&arg1.FocusChangedSignal();
 853     } catch (std::out_of_range& e) {
 854       {
 855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 856       };
 857     } catch (std::exception& e) {
 858       {
 859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 860       };
 861     } catch (Dali::DaliException e) {
 862       {
 863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 864       };
 865     } catch (...) {
 866       {
 867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 868       };
 869     }
 870   }
 871
 872   jresult = (void *)result;
 873   return jresult;
 874 }
 875
 876
 877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
 878   Dali::Window arg1 ;
 879   bool arg2 ;
 880   Dali::Window *argp1 ;
 881
 882   argp1 = (Dali::Window *)jarg1;
 883   if (!argp1) {
 884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 885     return ;
 886   }
 887   arg1 = *argp1;
 888   arg2 = jarg2 ? true : false;
 889   {
 890     try {
 891       arg1.SetAcceptFocus(arg2);
 892     } catch (std::out_of_range& e) {
 893       {
 894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 895       };
 896     } catch (std::exception& e) {
 897       {
 898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 899       };
 900     } catch (Dali::DaliException e) {
 901       {
 902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 903       };
 904     } catch (...) {
 905       {
 906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 907       };
 908     }
 909   }
 910
 911 }
 912
 913
 914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
 915   unsigned int jresult ;
 916   Dali::Window arg1 ;
 917   Dali::Window *argp1 ;
 918   bool result;
 919
 920   argp1 = (Dali::Window *)jarg1;
 921   if (!argp1) {
 922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 923     return 0;
 924   }
 925   arg1 = *argp1;
 926   {
 927     try {
 928       result = (bool)arg1.IsFocusAcceptable();
 929     } catch (std::out_of_range& e) {
 930       {
 931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 932       };
 933     } catch (std::exception& e) {
 934       {
 935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 936       };
 937     } catch (Dali::DaliException e) {
 938       {
 939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 940       };
 941     } catch (...) {
 942       {
 943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 944       };
 945     }
 946   }
 947
 948   jresult = result;
 949   return jresult;
 950 }
 951
 952
 953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
 954   Dali::Window arg1 ;
 955   Dali::Window *argp1 ;
 956
 957   argp1 = (Dali::Window *)jarg1;
 958   if (!argp1) {
 959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 960     return ;
 961   }
 962   arg1 = *argp1;
 963   {
 964     try {
 965       arg1.Show();
 966     } catch (std::out_of_range& e) {
 967       {
 968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 969       };
 970     } catch (std::exception& e) {
 971       {
 972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 973       };
 974     } catch (Dali::DaliException e) {
 975       {
 976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 977       };
 978     } catch (...) {
 979       {
 980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 981       };
 982     }
 983   }
 984
 985 }
 986
 987
 988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
 989   Dali::Window arg1 ;
 990   Dali::Window *argp1 ;
 991
 992   argp1 = (Dali::Window *)jarg1;
 993   if (!argp1) {
 994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 995     return ;
 996   }
 997   arg1 = *argp1;
 998   {
 999     try {
1000       arg1.Hide();
1001     } catch (std::out_of_range& e) {
1002       {
1003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1004       };
1005     } catch (std::exception& e) {
1006       {
1007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1008       };
1009     } catch (Dali::DaliException e) {
1010       {
1011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1012       };
1013     } catch (...) {
1014       {
1015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1016       };
1017     }
1018   }
1019
1020 }
1021
1022
1023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
1024   unsigned int jresult ;
1025   Dali::Window arg1 ;
1026   Dali::Window *argp1 ;
1027   bool result;
1028
1029   argp1 = (Dali::Window *)jarg1;
1030   if (!argp1) {
1031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1032     return 0;
1033   }
1034   arg1 = *argp1;
1035   {
1036     try {
1037       result = (bool)arg1.IsVisible();
1038     } catch (std::out_of_range& e) {
1039       {
1040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1041       };
1042     } catch (std::exception& e) {
1043       {
1044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1045       };
1046     } catch (Dali::DaliException e) {
1047       {
1048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1049       };
1050     } catch (...) {
1051       {
1052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1053       };
1054     }
1055   }
1056
1057   jresult = result;
1058   return jresult;
1059 }
1060
1061
1062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHintCount(void * jarg1) {
1063   unsigned int jresult ;
1064   Dali::Window arg1 ;
1065   Dali::Window *argp1 ;
1066   unsigned int result;
1067
1068   argp1 = (Dali::Window *)jarg1;
1069   if (!argp1) {
1070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1071     return 0;
1072   }
1073   arg1 = *argp1;
1074   {
1075     try {
1076       result = (unsigned int)arg1.GetSupportedAuxiliaryHintCount();
1077     } catch (std::out_of_range& e) {
1078       {
1079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1080       };
1081     } catch (std::exception& e) {
1082       {
1083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1084       };
1085     } catch (Dali::DaliException e) {
1086       {
1087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1088       };
1089     } catch (...) {
1090       {
1091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1092       };
1093     }
1094   }
1095
1096   jresult = result;
1097   return jresult;
1098 }
1099
1100
1101 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHint(void * jarg1, unsigned int jarg2) {
1102   char * jresult ;
1103   Dali::Window arg1 ;
1104   unsigned int arg2 ;
1105   Dali::Window *argp1 ;
1106   std::string result;
1107
1108   argp1 = (Dali::Window *)jarg1;
1109   if (!argp1) {
1110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1111     return 0;
1112   }
1113   arg1 = *argp1;
1114   arg2 = (unsigned int)jarg2;
1115   {
1116     try {
1117       result = arg1.GetSupportedAuxiliaryHint(arg2);
1118     } catch (std::out_of_range& e) {
1119       {
1120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1121       };
1122     } catch (std::exception& e) {
1123       {
1124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1125       };
1126     } catch (Dali::DaliException e) {
1127       {
1128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1129       };
1130     } catch (...) {
1131       {
1132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1133       };
1134     }
1135   }
1136
1137   jresult = SWIG_csharp_string_callback((&result)->c_str());
1138   return jresult;
1139 }
1140
1141
1142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AddAuxiliaryHint(void * jarg1, char * jarg2, char * jarg3) {
1143   unsigned int jresult ;
1144   Dali::Window arg1 ;
1145   std::string *arg2 = 0 ;
1146   std::string *arg3 = 0 ;
1147   Dali::Window *argp1 ;
1148   unsigned int result;
1149
1150   argp1 = (Dali::Window *)jarg1;
1151   if (!argp1) {
1152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1153     return 0;
1154   }
1155   arg1 = *argp1;
1156   if (!jarg2) {
1157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1158     return 0;
1159   }
1160   std::string arg2_str(jarg2);
1161   arg2 = &arg2_str;
1162   if (!jarg3) {
1163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1164     return 0;
1165   }
1166   std::string arg3_str(jarg3);
1167   arg3 = &arg3_str;
1168   {
1169     try {
1170       result = (unsigned int)arg1.AddAuxiliaryHint((std::string const &)*arg2,(std::string const &)*arg3);
1171     } catch (std::out_of_range& e) {
1172       {
1173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1174       };
1175     } catch (std::exception& e) {
1176       {
1177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1178       };
1179     } catch (Dali::DaliException e) {
1180       {
1181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1182       };
1183     } catch (...) {
1184       {
1185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1186       };
1187     }
1188   }
1189
1190   jresult = result;
1191
1192   return jresult;
1193 }
1194
1195
1196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RemoveAuxiliaryHint(void * jarg1, unsigned int jarg2) {
1197   unsigned int jresult ;
1198   Dali::Window arg1 ;
1199   unsigned int arg2 ;
1200   Dali::Window *argp1 ;
1201   bool result;
1202
1203   argp1 = (Dali::Window *)jarg1;
1204   if (!argp1) {
1205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1206     return 0;
1207   }
1208   arg1 = *argp1;
1209   arg2 = (unsigned int)jarg2;
1210   {
1211     try {
1212       result = (bool)arg1.RemoveAuxiliaryHint(arg2);
1213     } catch (std::out_of_range& e) {
1214       {
1215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1216       };
1217     } catch (std::exception& e) {
1218       {
1219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1220       };
1221     } catch (Dali::DaliException e) {
1222       {
1223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1224       };
1225     } catch (...) {
1226       {
1227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1228       };
1229     }
1230   }
1231
1232   jresult = result;
1233   return jresult;
1234 }
1235
1236
1237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetAuxiliaryHintValue(void * jarg1, unsigned int jarg2, char * jarg3) {
1238   unsigned int jresult ;
1239   Dali::Window arg1 ;
1240   unsigned int arg2 ;
1241   std::string *arg3 = 0 ;
1242   Dali::Window *argp1 ;
1243   bool result;
1244
1245   argp1 = (Dali::Window *)jarg1;
1246   if (!argp1) {
1247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1248     return 0;
1249   }
1250   arg1 = *argp1;
1251   arg2 = (unsigned int)jarg2;
1252   if (!jarg3) {
1253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1254     return 0;
1255   }
1256   std::string arg3_str(jarg3);
1257   arg3 = &arg3_str;
1258   {
1259     try {
1260       result = (bool)arg1.SetAuxiliaryHintValue(arg2,(std::string const &)*arg3);
1261     } catch (std::out_of_range& e) {
1262       {
1263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1264       };
1265     } catch (std::exception& e) {
1266       {
1267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1268       };
1269     } catch (Dali::DaliException e) {
1270       {
1271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1272       };
1273     } catch (...) {
1274       {
1275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1276       };
1277     }
1278   }
1279
1280   jresult = result;
1281
1282   //argout typemap for const std::string&
1283
1284   return jresult;
1285 }
1286
1287
1288 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintValue(void * jarg1, unsigned int jarg2) {
1289   char * jresult ;
1290   Dali::Window arg1 ;
1291   unsigned int arg2 ;
1292   Dali::Window *argp1 ;
1293   std::string result;
1294
1295   argp1 = (Dali::Window *)jarg1;
1296   if (!argp1) {
1297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1298     return 0;
1299   }
1300   arg1 = *argp1;
1301   arg2 = (unsigned int)jarg2;
1302   {
1303     try {
1304       result = arg1.GetAuxiliaryHintValue(arg2);
1305     } catch (std::out_of_range& e) {
1306       {
1307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1308       };
1309     } catch (std::exception& e) {
1310       {
1311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1312       };
1313     } catch (Dali::DaliException e) {
1314       {
1315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1316       };
1317     } catch (...) {
1318       {
1319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1320       };
1321     }
1322   }
1323
1324   jresult = SWIG_csharp_string_callback((&result)->c_str());
1325   return jresult;
1326 }
1327
1328
1329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintId(void * jarg1, char * jarg2) {
1330   unsigned int jresult ;
1331   Dali::Window arg1 ;
1332   std::string *arg2 = 0 ;
1333   Dali::Window *argp1 ;
1334   unsigned int result;
1335
1336   argp1 = (Dali::Window *)jarg1;
1337   if (!argp1) {
1338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1339     return 0;
1340   }
1341   arg1 = *argp1;
1342   if (!jarg2) {
1343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1344     return 0;
1345   }
1346   std::string arg2_str(jarg2);
1347   arg2 = &arg2_str;
1348   {
1349     try {
1350       result = (unsigned int)arg1.GetAuxiliaryHintId((std::string const &)*arg2);
1351     } catch (std::out_of_range& e) {
1352       {
1353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1354       };
1355     } catch (std::exception& e) {
1356       {
1357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1358       };
1359     } catch (Dali::DaliException e) {
1360       {
1361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1362       };
1363     } catch (...) {
1364       {
1365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1366       };
1367     }
1368   }
1369
1370   jresult = result;
1371
1372   //argout typemap for const std::string&
1373
1374   return jresult;
1375 }
1376
1377
1378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetInputRegion(void * jarg1, void * jarg2) {
1379   Dali::Window arg1 ;
1380   Dali::Rect< int > *arg2 = 0 ;
1381   Dali::Window *argp1 ;
1382
1383   argp1 = (Dali::Window *)jarg1;
1384   if (!argp1) {
1385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1386     return ;
1387   }
1388   arg1 = *argp1;
1389   arg2 = (Dali::Rect< int > *)jarg2;
1390   if (!arg2) {
1391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
1392     return ;
1393   }
1394   {
1395     try {
1396       arg1.SetInputRegion((Dali::Rect< int > const &)*arg2);
1397     } catch (std::out_of_range& e) {
1398       {
1399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1400       };
1401     } catch (std::exception& e) {
1402       {
1403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1404       };
1405     } catch (Dali::DaliException e) {
1406       {
1407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1408       };
1409     } catch (...) {
1410       {
1411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1412       };
1413     }
1414   }
1415
1416 }
1417
1418
1419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetType(void * jarg1, int jarg2) {
1420   Dali::Window arg1 ;
1421   Dali::Window::Type arg2 ;
1422   Dali::Window *argp1 ;
1423
1424   argp1 = (Dali::Window *)jarg1;
1425   if (!argp1) {
1426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1427     return ;
1428   }
1429   arg1 = *argp1;
1430   arg2 = (Dali::Window::Type)jarg2;
1431   {
1432     try {
1433       arg1.SetType(arg2);
1434     } catch (std::out_of_range& e) {
1435       {
1436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1437       };
1438     } catch (std::exception& e) {
1439       {
1440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1441       };
1442     } catch (Dali::DaliException e) {
1443       {
1444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1445       };
1446     } catch (...) {
1447       {
1448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1449       };
1450     }
1451   }
1452
1453 }
1454
1455
1456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetType(void * jarg1) {
1457   int jresult ;
1458   Dali::Window arg1 ;
1459   Dali::Window *argp1 ;
1460   Dali::Window::Type result;
1461
1462   argp1 = (Dali::Window *)jarg1;
1463   if (!argp1) {
1464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1465     return 0;
1466   }
1467   arg1 = *argp1;
1468   {
1469     try {
1470       result = (Dali::Window::Type)arg1.GetType();
1471     } catch (std::out_of_range& e) {
1472       {
1473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1474       };
1475     } catch (std::exception& e) {
1476       {
1477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1478       };
1479     } catch (Dali::DaliException e) {
1480       {
1481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1482       };
1483     } catch (...) {
1484       {
1485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1486       };
1487     }
1488   }
1489
1490   jresult = (int)result;
1491   return jresult;
1492 }
1493
1494
1495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetNotificationLevel(void * jarg1, int jarg2) {
1496   unsigned int jresult ;
1497   Dali::Window arg1 ;
1498   Dali::Window::NotificationLevel::Type arg2 ;
1499   Dali::Window *argp1 ;
1500   bool result;
1501
1502   argp1 = (Dali::Window *)jarg1;
1503   if (!argp1) {
1504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1505     return 0;
1506   }
1507   arg1 = *argp1;
1508   arg2 = (Dali::Window::NotificationLevel::Type)jarg2;
1509   {
1510     try {
1511       result = (bool)arg1.SetNotificationLevel(arg2);
1512     } catch (std::out_of_range& e) {
1513       {
1514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1515       };
1516     } catch (std::exception& e) {
1517       {
1518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1519       };
1520     } catch (Dali::DaliException e) {
1521       {
1522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1523       };
1524     } catch (...) {
1525       {
1526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1527       };
1528     }
1529   }
1530
1531   jresult = result;
1532   return jresult;
1533 }
1534
1535
1536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetNotificationLevel(void * jarg1) {
1537   int jresult ;
1538   Dali::Window arg1 ;
1539   Dali::Window *argp1 ;
1540   Dali::Window::NotificationLevel::Type result;
1541
1542   argp1 = (Dali::Window *)jarg1;
1543   if (!argp1) {
1544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1545     return 0;
1546   }
1547   arg1 = *argp1;
1548   {
1549     try {
1550       result = (Dali::Window::NotificationLevel::Type)arg1.GetNotificationLevel();
1551     } catch (std::out_of_range& e) {
1552       {
1553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1554       };
1555     } catch (std::exception& e) {
1556       {
1557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1558       };
1559     } catch (Dali::DaliException e) {
1560       {
1561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1562       };
1563     } catch (...) {
1564       {
1565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1566       };
1567     }
1568   }
1569
1570   jresult = (int)result;
1571   return jresult;
1572 }
1573
1574
1575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetOpaqueState(void * jarg1, unsigned int jarg2) {
1576   Dali::Window arg1 ;
1577   bool arg2 ;
1578   Dali::Window *argp1 ;
1579
1580   argp1 = (Dali::Window *)jarg1;
1581   if (!argp1) {
1582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1583     return ;
1584   }
1585   arg1 = *argp1;
1586   arg2 = jarg2 ? true : false;
1587   {
1588     try {
1589       arg1.SetOpaqueState(arg2);
1590     } catch (std::out_of_range& e) {
1591       {
1592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1593       };
1594     } catch (std::exception& e) {
1595       {
1596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1597       };
1598     } catch (Dali::DaliException e) {
1599       {
1600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1601       };
1602     } catch (...) {
1603       {
1604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1605       };
1606     }
1607   }
1608
1609 }
1610
1611
1612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsOpaqueState(void * jarg1) {
1613   unsigned int jresult ;
1614   Dali::Window arg1 ;
1615   Dali::Window *argp1 ;
1616   bool result;
1617
1618   argp1 = (Dali::Window *)jarg1;
1619   if (!argp1) {
1620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1621     return 0;
1622   }
1623   arg1 = *argp1;
1624   {
1625     try {
1626       result = (bool)arg1.IsOpaqueState();
1627     } catch (std::out_of_range& e) {
1628       {
1629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1630       };
1631     } catch (std::exception& e) {
1632       {
1633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1634       };
1635     } catch (Dali::DaliException e) {
1636       {
1637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1638       };
1639     } catch (...) {
1640       {
1641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1642       };
1643     }
1644   }
1645
1646   jresult = result;
1647   return jresult;
1648 }
1649
1650
1651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetScreenOffMode(void * jarg1, int jarg2) {
1652   unsigned int jresult ;
1653   Dali::Window arg1 ;
1654   Dali::Window::ScreenOffMode::Type arg2 ;
1655   Dali::Window *argp1 ;
1656   bool result;
1657
1658   argp1 = (Dali::Window *)jarg1;
1659   if (!argp1) {
1660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1661     return 0;
1662   }
1663   arg1 = *argp1;
1664   arg2 = (Dali::Window::ScreenOffMode::Type)jarg2;
1665   {
1666     try {
1667       result = (bool)arg1.SetScreenOffMode(arg2);
1668     } catch (std::out_of_range& e) {
1669       {
1670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1671       };
1672     } catch (std::exception& e) {
1673       {
1674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1675       };
1676     } catch (Dali::DaliException e) {
1677       {
1678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1679       };
1680     } catch (...) {
1681       {
1682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1683       };
1684     }
1685   }
1686
1687   jresult = result;
1688   return jresult;
1689 }
1690
1691
1692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetScreenOffMode(void * jarg1) {
1693   int jresult ;
1694   Dali::Window arg1 ;
1695   Dali::Window *argp1 ;
1696   Dali::Window::ScreenOffMode::Type result;
1697
1698   argp1 = (Dali::Window *)jarg1;
1699   if (!argp1) {
1700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1701     return 0;
1702   }
1703   arg1 = *argp1;
1704   {
1705     try {
1706       result = (Dali::Window::ScreenOffMode::Type)arg1.GetScreenOffMode();
1707     } catch (std::out_of_range& e) {
1708       {
1709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1710       };
1711     } catch (std::exception& e) {
1712       {
1713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1714       };
1715     } catch (Dali::DaliException e) {
1716       {
1717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1718       };
1719     } catch (...) {
1720       {
1721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1722       };
1723     }
1724   }
1725
1726   jresult = (int)result;
1727   return jresult;
1728 }
1729
1730
1731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetBrightness(void * jarg1, int jarg2) {
1732   unsigned int jresult ;
1733   Dali::Window arg1 ;
1734   int arg2 ;
1735   Dali::Window *argp1 ;
1736   bool result;
1737
1738   argp1 = (Dali::Window *)jarg1;
1739   if (!argp1) {
1740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1741     return 0;
1742   }
1743   arg1 = *argp1;
1744   arg2 = (int)jarg2;
1745   {
1746     try {
1747       result = (bool)arg1.SetBrightness(arg2);
1748     } catch (std::out_of_range& e) {
1749       {
1750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1751       };
1752     } catch (std::exception& e) {
1753       {
1754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1755       };
1756     } catch (Dali::DaliException e) {
1757       {
1758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1759       };
1760     } catch (...) {
1761       {
1762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1763       };
1764     }
1765   }
1766
1767   jresult = result;
1768   return jresult;
1769 }
1770
1771
1772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetBrightness(void * jarg1) {
1773   int jresult ;
1774   Dali::Window arg1 ;
1775   Dali::Window *argp1 ;
1776   int result;
1777
1778   argp1 = (Dali::Window *)jarg1;
1779   if (!argp1) {
1780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1781     return 0;
1782   }
1783   arg1 = *argp1;
1784   {
1785     try {
1786       result = (int)arg1.GetBrightness();
1787     } catch (std::out_of_range& e) {
1788       {
1789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1790       };
1791     } catch (std::exception& e) {
1792       {
1793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1794       };
1795     } catch (Dali::DaliException e) {
1796       {
1797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1798       };
1799     } catch (...) {
1800       {
1801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1802       };
1803     }
1804   }
1805
1806   jresult = result;
1807   return jresult;
1808 }
1809
1810 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
1811   unsigned int jresult ;
1812   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1813   bool result;
1814
1815   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1816   {
1817     try {
1818       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
1819     } catch (std::out_of_range& e) {
1820       {
1821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1822       };
1823     } catch (std::exception& e) {
1824       {
1825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1826       };
1827     } catch (Dali::DaliException e) {
1828       {
1829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1830       };
1831     } catch (...) {
1832       {
1833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1834       };
1835     }
1836   }
1837
1838   jresult = result;
1839   return jresult;
1840 }
1841
1842
1843 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
1844   unsigned long jresult ;
1845   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1846   std::size_t result;
1847
1848   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1849   {
1850     try {
1851       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
1852     } catch (std::out_of_range& e) {
1853       {
1854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1855       };
1856     } catch (std::exception& e) {
1857       {
1858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1859       };
1860     } catch (Dali::DaliException e) {
1861       {
1862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1863       };
1864     } catch (...) {
1865       {
1866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1867       };
1868     }
1869   }
1870
1871   jresult = (unsigned long)result;
1872   return jresult;
1873 }
1874
1875
1876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
1877   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1878   void (*arg2)(bool) = (void (*)(bool)) 0 ;
1879
1880   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1881   arg2 = (void (*)(bool))jarg2;
1882   {
1883     try {
1884       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
1885     } catch (std::out_of_range& e) {
1886       {
1887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1888       };
1889     } catch (std::exception& e) {
1890       {
1891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1892       };
1893     } catch (Dali::DaliException e) {
1894       {
1895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1896       };
1897     } catch (...) {
1898       {
1899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1900       };
1901     }
1902   }
1903
1904 }
1905
1906
1907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
1908   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1909   void (*arg2)(bool) = (void (*)(bool)) 0 ;
1910
1911   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1912   arg2 = (void (*)(bool))jarg2;
1913   {
1914     try {
1915       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
1916     } catch (std::out_of_range& e) {
1917       {
1918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1919       };
1920     } catch (std::exception& e) {
1921       {
1922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1923       };
1924     } catch (Dali::DaliException e) {
1925       {
1926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1927       };
1928     } catch (...) {
1929       {
1930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1931       };
1932     }
1933   }
1934
1935 }
1936
1937
1938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
1939   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1940   bool arg2 ;
1941
1942   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1943   arg2 = jarg2 ? true : false;
1944   {
1945     try {
1946       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
1947     } catch (std::out_of_range& e) {
1948       {
1949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1950       };
1951     } catch (std::exception& e) {
1952       {
1953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1954       };
1955     } catch (Dali::DaliException e) {
1956       {
1957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1958       };
1959     } catch (...) {
1960       {
1961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1962       };
1963     }
1964   }
1965
1966 }
1967
1968
1969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
1970   void * jresult ;
1971   Dali::Signal< void (bool) > *result = 0 ;
1972
1973   {
1974     try {
1975       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
1976     } catch (std::out_of_range& e) {
1977       {
1978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1979       };
1980     } catch (std::exception& e) {
1981       {
1982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1983       };
1984     } catch (Dali::DaliException e) {
1985       {
1986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1987       };
1988     } catch (...) {
1989       {
1990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1991       };
1992     }
1993   }
1994
1995   jresult = (void *)result;
1996   return jresult;
1997 }
1998
1999
2000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
2001   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
2002
2003   arg1 = (Dali::Signal< void (bool) > *)jarg1;
2004   {
2005     try {
2006       delete arg1;
2007     } catch (std::out_of_range& e) {
2008       {
2009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2010       };
2011     } catch (std::exception& e) {
2012       {
2013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2014       };
2015     } catch (Dali::DaliException e) {
2016       {
2017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2018       };
2019     } catch (...) {
2020       {
2021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2022       };
2023     }
2024   }
2025
2026 }
2027
2028
2029
2030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_ResizedSignal(void * jarg1) {
2031   void * jresult ;
2032   Dali::Window arg1 ;
2033   Dali::Window *argp1 ;
2034   Dali::Window::ResizedSignalType *result = 0 ;
2035
2036   argp1 = (Dali::Window *)jarg1;
2037   if (!argp1) {
2038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2039     return 0;
2040   }
2041   arg1 = *argp1;
2042   {
2043     try {
2044       result = (Dali::Window::ResizedSignalType *) &arg1.ResizedSignal();
2045     } catch (std::out_of_range& e) {
2046       {
2047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2048       };
2049     } catch (std::exception& e) {
2050       {
2051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2052       };
2053     } catch (Dali::DaliException e) {
2054       {
2055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2056       };
2057     } catch (...) {
2058       {
2059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2060       };
2061     }
2062   }
2063
2064   jresult = (void *)result;
2065   return jresult;
2066 }
2067
2068 /*ResizedSignal binding*/
2069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResizedSignal_Empty(void * jarg1) {
2070   unsigned int jresult ;
2071   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2072   bool result;
2073
2074   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2075   {
2076     try {
2077       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Empty((Dali::Signal< void (Dali::Window::WindowSize) > const *)arg1);
2078     } catch (std::out_of_range& e) {
2079       {
2080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2081       };
2082     } catch (std::exception& e) {
2083       {
2084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2085       };
2086     } catch (Dali::DaliException e) {
2087       {
2088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2089       };
2090     } catch (...) {
2091       {
2092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2093       };
2094     }
2095   }
2096
2097   jresult = result;
2098   return jresult;
2099 }
2100
2101
2102 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResizedSignal_GetConnectionCount(void * jarg1) {
2103   unsigned long jresult ;
2104   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2105   std::size_t result;
2106
2107   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2108   {
2109     try {
2110       result = Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Window::WindowSize) > const *)arg1);
2111     } catch (std::out_of_range& e) {
2112       {
2113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2114       };
2115     } catch (std::exception& e) {
2116       {
2117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2118       };
2119     } catch (Dali::DaliException e) {
2120       {
2121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2122       };
2123     } catch (...) {
2124       {
2125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2126       };
2127     }
2128   }
2129
2130   jresult = (unsigned long)result;
2131   return jresult;
2132 }
2133
2134
2135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizedSignal_Connect(void * jarg1, void * jarg2) {
2136   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2137   void (*arg2)(Dali::Window::WindowSize) = (void (*)(Dali::Window::WindowSize)) 0 ;
2138
2139   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2140   arg2 = (void (*)(Dali::Window::WindowSize))jarg2;
2141   {
2142     try {
2143       Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Connect(arg1,arg2);
2144     } catch (std::out_of_range& e) {
2145       {
2146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2147       };
2148     } catch (std::exception& e) {
2149       {
2150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2151       };
2152     } catch (Dali::DaliException e) {
2153       {
2154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2155       };
2156     } catch (...) {
2157       {
2158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2159       };
2160     }
2161   }
2162
2163 }
2164
2165
2166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizedSignal_Disconnect(void * jarg1, void * jarg2) {
2167   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2168   void (*arg2)(Dali::Window::WindowSize) = (void (*)(Dali::Window::WindowSize)) 0 ;
2169
2170   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2171   arg2 = (void (*)(Dali::Window::WindowSize))jarg2;
2172   {
2173     try {
2174       Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Disconnect(arg1,arg2);
2175     } catch (std::out_of_range& e) {
2176       {
2177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2178       };
2179     } catch (std::exception& e) {
2180       {
2181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2182       };
2183     } catch (Dali::DaliException e) {
2184       {
2185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2186       };
2187     } catch (...) {
2188       {
2189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2190       };
2191     }
2192   }
2193
2194 }
2195
2196
2197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizedSignal_Emit(void * jarg1, void * jarg2) {
2198   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2199   Dali::Window::WindowSize arg2 ;
2200   Dali::Window::WindowSize *argp2 ;
2201
2202   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2203   argp2 = (Dali::Window::WindowSize *)jarg2;
2204   if (!argp2) {
2205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0);
2206     return ;
2207   }
2208   arg2 = *argp2;
2209   {
2210     try {
2211       Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Emit(arg1,arg2);
2212     } catch (std::out_of_range& e) {
2213       {
2214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2215       };
2216     } catch (std::exception& e) {
2217       {
2218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2219       };
2220     } catch (Dali::DaliException e) {
2221       {
2222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2223       };
2224     } catch (...) {
2225       {
2226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2227       };
2228     }
2229   }
2230
2231 }
2232
2233
2234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResizedSignal() {
2235   void * jresult ;
2236   Dali::Signal< void (Dali::Window::WindowSize) > *result = 0 ;
2237
2238   {
2239     try {
2240       result = (Dali::Signal< void (Dali::Window::WindowSize) > *)new Dali::Signal< void (Dali::Window::WindowSize) >();
2241     } catch (std::out_of_range& e) {
2242       {
2243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2244       };
2245     } catch (std::exception& e) {
2246       {
2247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2248       };
2249     } catch (Dali::DaliException e) {
2250       {
2251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2252       };
2253     } catch (...) {
2254       {
2255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2256       };
2257     }
2258   }
2259
2260   jresult = (void *)result;
2261   return jresult;
2262 }
2263
2264
2265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResizedSignal(void * jarg1) {
2266   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2267
2268   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2269   {
2270     try {
2271       delete arg1;
2272     } catch (std::out_of_range& e) {
2273       {
2274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2275       };
2276     } catch (std::exception& e) {
2277       {
2278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2279       };
2280     } catch (Dali::DaliException e) {
2281       {
2282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2283       };
2284     } catch (...) {
2285       {
2286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2287       };
2288     }
2289   }
2290
2291 }
2292
2293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetSize(void * jarg1, void * jarg2) {
2294   Dali::Window arg1 ;
2295   Dali::Window::WindowSize arg2 ;
2296   Dali::Window *argp1 ;
2297   Dali::Window::WindowSize *argp2 ;
2298
2299   argp1 = (Dali::Window *)jarg1;
2300   if (!argp1) {
2301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2302     return ;
2303   }
2304   arg1 = *argp1;
2305   argp2 = (Dali::Window::WindowSize *)jarg2;
2306   if (!argp2) {
2307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0);
2308     return ;
2309   }
2310   arg2 = *argp2;
2311   {
2312     try {
2313       arg1.SetSize(arg2);
2314     } catch (std::out_of_range& e) {
2315       {
2316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2317       };
2318     } catch (std::exception& e) {
2319       {
2320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2321       };
2322     } catch (Dali::DaliException e) {
2323       {
2324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2325       };
2326     } catch (...) {
2327       {
2328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2329       };
2330     }
2331   }
2332
2333 }
2334
2335
2336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetSize(void * jarg1) {
2337   void * jresult ;
2338   Dali::Window arg1 ;
2339   Dali::Window *argp1 ;
2340   Dali::Window::WindowSize result;
2341
2342   argp1 = (Dali::Window *)jarg1;
2343   if (!argp1) {
2344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2345     return 0;
2346   }
2347   arg1 = *argp1;
2348   {
2349     try {
2350       result = arg1.GetSize();
2351     } catch (std::out_of_range& e) {
2352       {
2353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2354       };
2355     } catch (std::exception& e) {
2356       {
2357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2358       };
2359     } catch (Dali::DaliException e) {
2360       {
2361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2362       };
2363     } catch (...) {
2364       {
2365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2366       };
2367     }
2368   }
2369
2370   jresult = new Dali::Window::WindowSize((const Dali::Window::WindowSize &)result);
2371   return jresult;
2372 }
2373
2374
2375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPosition(void * jarg1, void * jarg2) {
2376   Dali::Window arg1 ;
2377   Dali::Window::WindowPosition arg2 ;
2378   Dali::Window *argp1 ;
2379   Dali::Window::WindowPosition *argp2 ;
2380
2381   argp1 = (Dali::Window *)jarg1;
2382   if (!argp1) {
2383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2384     return ;
2385   }
2386   arg1 = *argp1;
2387   argp2 = (Dali::Window::WindowPosition *)jarg2;
2388   if (!argp2) {
2389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowPosition", 0);
2390     return ;
2391   }
2392   arg2 = *argp2;
2393   {
2394     try {
2395       arg1.SetPosition(arg2);
2396     } catch (std::out_of_range& e) {
2397       {
2398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2399       };
2400     } catch (std::exception& e) {
2401       {
2402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2403       };
2404     } catch (Dali::DaliException e) {
2405       {
2406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2407       };
2408     } catch (...) {
2409       {
2410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2411       };
2412     }
2413   }
2414
2415 }
2416
2417
2418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetPosition(void * jarg1) {
2419   void * jresult ;
2420   Dali::Window arg1 ;
2421   Dali::Window *argp1 ;
2422   Dali::Window::WindowPosition result;
2423
2424   argp1 = (Dali::Window *)jarg1;
2425   if (!argp1) {
2426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2427     return 0;
2428   }
2429   arg1 = *argp1;
2430   {
2431     try {
2432       result = arg1.GetPosition();
2433     } catch (std::out_of_range& e) {
2434       {
2435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2436       };
2437     } catch (std::exception& e) {
2438       {
2439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2440       };
2441     } catch (Dali::DaliException e) {
2442       {
2443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2444       };
2445     } catch (...) {
2446       {
2447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2448       };
2449     }
2450   }
2451
2452   jresult = new Dali::Window::WindowPosition((const Dali::Window::WindowPosition &)result);
2453   return jresult;
2454 }
2455
2456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPositionSize(void* jarg1, void* jarg2)
2457 {
2458   Dali::Window* window = (Dali::Window*)jarg1;
2459   if (!window) {
2460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2461     return ;
2462   }
2463
2464   Dali::Rect<int>* positionSize = (Dali::Rect<int>*)jarg2;
2465   if (!positionSize) {
2466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
2467     return ;
2468   }
2469   {
2470     try {
2471       Dali::DevelWindow::SetPositionSize(*window, *positionSize);
2472     } catch (std::out_of_range& e) {
2473       {
2474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2475       };
2476     } catch (std::exception& e) {
2477       {
2478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2479       };
2480     } catch (Dali::DaliException e) {
2481       {
2482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2483       };
2484     } catch (...) {
2485       {
2486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2487       };
2488     }
2489   }
2490
2491 }
2492
2493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetTransparency(void * jarg1, unsigned int jarg2) {
2494   Dali::Window arg1 ;
2495   bool arg2 ;
2496   Dali::Window *argp1 ;
2497
2498   argp1 = (Dali::Window *)jarg1;
2499   if (!argp1) {
2500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2501     return ;
2502   }
2503   arg1 = *argp1;
2504   arg2 = jarg2 ? true : false;
2505   {
2506     try {
2507       arg1.SetTransparency(arg2);
2508     } catch (std::out_of_range& e) {
2509       {
2510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2511       };
2512     } catch (std::exception& e) {
2513       {
2514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2515       };
2516     } catch (Dali::DaliException e) {
2517       {
2518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2519       };
2520     } catch (...) {
2521       {
2522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2523       };
2524     }
2525   }
2526
2527 }
2528
2529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_FeedKeyEvent(void * jarg1) {
2530   Dali::KeyEvent *arg1 = 0 ;
2531
2532   arg1 = (Dali::KeyEvent *)jarg1;
2533   if (!arg1) {
2534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0);
2535     return ;
2536   }
2537   {
2538     try {
2539       Dali::Adaptor::Get().FeedKeyEvent(*arg1);
2540     } catch (std::out_of_range& e) {
2541       {
2542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2543       };
2544     } catch (std::exception& e) {
2545       {
2546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2547       };
2548     } catch (...) {
2549       {
2550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2551       };
2552     }
2553   }
2554 }
2555
2556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_RenderOnce(void * /* jarg1 */) {
2557   try {
2558     Dali::Adaptor::Get().RenderOnce();
2559   } catch (std::out_of_range& e) {
2560     {
2561       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2562     };
2563   } catch (std::exception& e) {
2564     {
2565       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2566     };
2567   } catch (...) {
2568     {
2569       SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2570     };
2571   }
2572 }
2573
2574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New_Root_Layout() {
2575   void * jresult ;
2576   Dali::Toolkit::Control result;
2577   {
2578     try {
2579       Dali::Toolkit::AbsoluteLayout absoluteLayout = Dali::Toolkit::AbsoluteLayout::New();
2580       result = Dali::Toolkit::Control::New();
2581       Dali::Toolkit::DevelControl::SetLayout( result, absoluteLayout );
2582       result.SetName("rootAbsoluteLayout");
2583       result.SetAnchorPoint( Dali::AnchorPoint::CENTER );
2584       result.SetParentOrigin( Dali::ParentOrigin::CENTER );
2585     } catch (...) {
2586       {
2587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2588       };
2589     }
2590   }
2591
2592   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
2593
2594   return jresult;
2595 }
2596
2597 #ifdef __cplusplus
2598 }
2599 #endif
2600