dali-csharp-binder/src/window.cpp

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