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