dali-csharp-binder/src/window.cpp

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