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/adaptor-framework/adaptor.h>
  25 #include <dali-toolkit/devel-api/controls/control-devel.h>
  26 #include <dali/integration-api/debug.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 //Transition effect
  68 SWIGINTERN bool Dali_Signal_Window_Transition_Effect_Event_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > const *self){
  69   return self->Empty();
  70 }
  71 SWIGINTERN std::size_t Dali_Signal_Window_Transition_Effect_Event_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > const *self){
  72 return self->GetConnectionCount();
  73 }
  74 SWIGINTERN void Dali_Signal_Window_Transition_Effect_Event_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *self, void (*func)(Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType)){
  75   self->Connect( func );
  76 }
  77 SWIGINTERN void Dali_Signal_Window_Transition_Effect_Event_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *self,void (*func)(Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType)){
  78   self->Disconnect( func );
  79 }
  80 SWIGINTERN void Dali_Signal_Window_Transition_Effect_Event_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *self,Dali::Window arg, Dali::DevelWindow::EffectState state, Dali::DevelWindow::EffectType type){
  81   self->Emit( arg, state, type );
  82 }
  83
  84
  85 #ifdef __cplusplus
  86 extern "C" {
  87 #endif
  88
  89 /*Window binding*/
  90 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
  91   return (Dali::BaseHandle *)jarg1;
  92 }
  93
  94 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
  95   void * jresult ;
  96   Dali::PositionSize arg1 ;
  97   std::string *arg2 = 0 ;
  98   bool arg3 ;
  99   Dali::PositionSize *argp1 ;
 100   Dali::Window result;
 101
 102   argp1 = (Dali::PositionSize *)jarg1;
 103   if (!argp1)
 104   {
 105     arg1 = Dali::PositionSize(0, 0, 0, 0);
 106   }
 107   else
 108   {
 109     arg1 = *argp1;
 110   }
 111   if (!jarg2) {
 112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 113     return 0;
 114   }
 115   std::string arg2_str(jarg2);
 116   arg2 = &arg2_str;
 117   arg3 = jarg3 ? true : false;
 118   {
 119     try {
 120       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
 121     } catch (std::out_of_range& e) {
 122       {
 123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 124       };
 125     } catch (std::exception& e) {
 126       {
 127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 128       };
 129     } catch (Dali::DaliException e) {
 130       {
 131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 132       };
 133     } catch (...) {
 134       {
 135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 136       };
 137     }
 138   }
 139
 140   jresult = new Dali::Window((const Dali::Window &)result);
 141
 142   //argout typemap for const std::string&
 143
 144   return jresult;
 145 }
 146
 147
 148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
 149   void * jresult ;
 150   Dali::PositionSize arg1 ;
 151   std::string *arg2 = 0 ;
 152   Dali::PositionSize *argp1 ;
 153   Dali::Window result;
 154
 155   argp1 = (Dali::PositionSize *)jarg1;
 156   if (!argp1) {
 157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
 158     return 0;
 159   }
 160   arg1 = *argp1;
 161   if (!jarg2) {
 162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 163     return 0;
 164   }
 165   std::string arg2_str(jarg2);
 166   arg2 = &arg2_str;
 167   {
 168     try {
 169       result = Dali::Window::New(arg1,(std::string const &)*arg2);
 170     } catch (std::out_of_range& e) {
 171       {
 172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 173       };
 174     } catch (std::exception& e) {
 175       {
 176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 177       };
 178     } catch (Dali::DaliException e) {
 179       {
 180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 181       };
 182     } catch (...) {
 183       {
 184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 185       };
 186     }
 187   }
 188
 189   jresult = new Dali::Window((const Dali::Window &)result);
 190
 191   //argout typemap for const std::string&
 192
 193   return jresult;
 194 }
 195
 196
 197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
 198   void * jresult ;
 199   Dali::PositionSize arg1 ;
 200   std::string *arg2 = 0 ;
 201   std::string *arg3 = 0 ;
 202   bool arg4 ;
 203   Dali::PositionSize *argp1 ;
 204   Dali::Window result;
 205
 206   argp1 = (Dali::PositionSize *)jarg1;
 207   if (!argp1) {
 208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
 209     return 0;
 210   }
 211   arg1 = *argp1;
 212   if (!jarg2) {
 213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 214     return 0;
 215   }
 216   std::string arg2_str(jarg2);
 217   arg2 = &arg2_str;
 218   if (!jarg3) {
 219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 220     return 0;
 221   }
 222   std::string arg3_str(jarg3);
 223   arg3 = &arg3_str;
 224   arg4 = jarg4 ? true : false;
 225   {
 226     try {
 227       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
 228     } catch (std::out_of_range& e) {
 229       {
 230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 231       };
 232     } catch (std::exception& e) {
 233       {
 234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 235       };
 236     } catch (Dali::DaliException e) {
 237       {
 238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 239       };
 240     } catch (...) {
 241       {
 242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 243       };
 244     }
 245   }
 246
 247   jresult = new Dali::Window((const Dali::Window &)result);
 248
 249   return jresult;
 250 }
 251
 252
 253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
 254   void * jresult ;
 255   Dali::PositionSize arg1 ;
 256   std::string *arg2 = 0 ;
 257   std::string *arg3 = 0 ;
 258   Dali::PositionSize *argp1 ;
 259   Dali::Window result;
 260
 261   argp1 = (Dali::PositionSize *)jarg1;
 262   if (!argp1) {
 263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
 264     return 0;
 265   }
 266   arg1 = *argp1;
 267   if (!jarg2) {
 268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 269     return 0;
 270   }
 271   std::string arg2_str(jarg2);
 272   arg2 = &arg2_str;
 273   if (!jarg3) {
 274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 275     return 0;
 276   }
 277   std::string arg3_str(jarg3);
 278   arg3 = &arg3_str;
 279   {
 280     try {
 281       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
 282     } catch (std::out_of_range& e) {
 283       {
 284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 285       };
 286     } catch (std::exception& e) {
 287       {
 288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 289       };
 290     } catch (Dali::DaliException e) {
 291       {
 292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 293       };
 294     } catch (...) {
 295       {
 296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 297       };
 298     }
 299   }
 300
 301   jresult = new Dali::Window((const Dali::Window &)result);
 302
 303   return jresult;
 304 }
 305
 306
 307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
 308   void * jresult ;
 309   Dali::Window *result = 0 ;
 310
 311   {
 312     try {
 313       result = (Dali::Window *)new Dali::Window();
 314     } catch (std::out_of_range& e) {
 315       {
 316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 317       };
 318     } catch (std::exception& e) {
 319       {
 320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 321       };
 322     } catch (Dali::DaliException e) {
 323       {
 324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 325       };
 326     } catch (...) {
 327       {
 328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 329       };
 330     }
 331   }
 332
 333   jresult = (void *)result;
 334   return jresult;
 335 }
 336
 337
 338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
 339   Dali::Window *arg1 = (Dali::Window *) 0 ;
 340
 341   arg1 = (Dali::Window *)jarg1;
 342   {
 343     try {
 344       delete arg1;
 345     } catch (std::out_of_range& e) {
 346       {
 347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 348       };
 349     } catch (std::exception& e) {
 350       {
 351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 352       };
 353     } catch (Dali::DaliException e) {
 354       {
 355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 356       };
 357     } catch (...) {
 358       {
 359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 360       };
 361     }
 362   }
 363
 364 }
 365
 366
 367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
 368   void * jresult ;
 369   Dali::Window *arg1 = 0 ;
 370   Dali::Window *result = 0 ;
 371
 372   arg1 = (Dali::Window *)jarg1;
 373   if (!arg1) {
 374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
 375     return 0;
 376   }
 377   {
 378     try {
 379       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
 380     } catch (std::out_of_range& e) {
 381       {
 382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 383       };
 384     } catch (std::exception& e) {
 385       {
 386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 387       };
 388     } catch (Dali::DaliException e) {
 389       {
 390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 391       };
 392     } catch (...) {
 393       {
 394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 395       };
 396     }
 397   }
 398
 399   jresult = (void *)result;
 400   return jresult;
 401 }
 402
 403
 404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
 405   void * jresult ;
 406   Dali::Window *arg1 = (Dali::Window *) 0 ;
 407   Dali::Window *arg2 = 0 ;
 408   Dali::Window *result = 0 ;
 409
 410   arg1 = (Dali::Window *)jarg1;
 411   arg2 = (Dali::Window *)jarg2;
 412   if (!arg2) {
 413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
 414     return 0;
 415   }
 416   {
 417     try {
 418       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
 419     } catch (std::out_of_range& e) {
 420       {
 421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 422       };
 423     } catch (std::exception& e) {
 424       {
 425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 426       };
 427     } catch (Dali::DaliException e) {
 428       {
 429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 430       };
 431     } catch (...) {
 432       {
 433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 434       };
 435     }
 436   }
 437
 438   jresult = (void *)result;
 439   return jresult;
 440 }
 441
 442
 443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
 444   Dali::Window *arg1 = (Dali::Window *) 0 ;
 445   Dali::Window::IndicatorVisibleMode arg2 ;
 446
 447   arg1 = (Dali::Window *)jarg1;
 448   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
 449   {
 450     try {
 451       (arg1)->ShowIndicator(arg2);
 452     } catch (std::out_of_range& e) {
 453       {
 454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 455       };
 456     } catch (std::exception& e) {
 457       {
 458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 459       };
 460     } catch (Dali::DaliException e) {
 461       {
 462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 463       };
 464     } catch (...) {
 465       {
 466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 467       };
 468     }
 469   }
 470
 471 }
 472
 473
 474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
 475   Dali::Window *arg1 = (Dali::Window *) 0 ;
 476   Dali::Window::IndicatorBgOpacity arg2 ;
 477
 478   arg1 = (Dali::Window *)jarg1;
 479   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
 480   {
 481     try {
 482       (arg1)->SetIndicatorBgOpacity(arg2);
 483     } catch (std::out_of_range& e) {
 484       {
 485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 486       };
 487     } catch (std::exception& e) {
 488       {
 489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 490       };
 491     } catch (Dali::DaliException e) {
 492       {
 493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 494       };
 495     } catch (...) {
 496       {
 497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 498       };
 499     }
 500   }
 501
 502 }
 503
 504
 505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
 506   Dali::Window *arg1 = (Dali::Window *) 0 ;
 507   Dali::Window::WindowOrientation arg2 ;
 508
 509   arg1 = (Dali::Window *)jarg1;
 510   arg2 = (Dali::Window::WindowOrientation)jarg2;
 511   {
 512     try {
 513       (arg1)->RotateIndicator(arg2);
 514     } catch (std::out_of_range& e) {
 515       {
 516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 517       };
 518     } catch (std::exception& e) {
 519       {
 520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 521       };
 522     } catch (Dali::DaliException e) {
 523       {
 524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 525       };
 526     } catch (...) {
 527       {
 528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 529       };
 530     }
 531   }
 532
 533 }
 534
 535
 536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
 537   Dali::Window *arg1 = (Dali::Window *) 0 ;
 538   std::string arg2 ;
 539   std::string arg3 ;
 540
 541   arg1 = (Dali::Window *)jarg1;
 542   if (!jarg2) {
 543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 544     return ;
 545   }
 546   (&arg2)->assign(jarg2);
 547   if (!jarg3) {
 548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 549     return ;
 550   }
 551   (&arg3)->assign(jarg3);
 552   {
 553     try {
 554       (arg1)->SetClass(arg2,arg3);
 555     } catch (std::out_of_range& e) {
 556       {
 557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 558       };
 559     } catch (std::exception& e) {
 560       {
 561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 562       };
 563     } catch (Dali::DaliException e) {
 564       {
 565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 566       };
 567     } catch (...) {
 568       {
 569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 570       };
 571     }
 572   }
 573
 574 }
 575
 576
 577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
 578   Dali::Window *arg1 = (Dali::Window *) 0 ;
 579
 580   arg1 = (Dali::Window *)jarg1;
 581   {
 582     try {
 583       (arg1)->Raise();
 584     } catch (std::out_of_range& e) {
 585       {
 586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 587       };
 588     } catch (std::exception& e) {
 589       {
 590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 591       };
 592     } catch (Dali::DaliException e) {
 593       {
 594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 595       };
 596     } catch (...) {
 597       {
 598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 599       };
 600     }
 601   }
 602
 603 }
 604
 605
 606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
 607   Dali::Window *arg1 = (Dali::Window *) 0 ;
 608
 609   arg1 = (Dali::Window *)jarg1;
 610   {
 611     try {
 612       (arg1)->Lower();
 613     } catch (std::out_of_range& e) {
 614       {
 615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 616       };
 617     } catch (std::exception& e) {
 618       {
 619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 620       };
 621     } catch (Dali::DaliException e) {
 622       {
 623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 624       };
 625     } catch (...) {
 626       {
 627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 628       };
 629     }
 630   }
 631
 632 }
 633
 634
 635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
 636   Dali::Window *arg1 = (Dali::Window *) 0 ;
 637
 638   arg1 = (Dali::Window *)jarg1;
 639   {
 640     try {
 641       (arg1)->Activate();
 642     } catch (std::out_of_range& e) {
 643       {
 644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 645       };
 646     } catch (std::exception& e) {
 647       {
 648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 649       };
 650     } catch (Dali::DaliException e) {
 651       {
 652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 653       };
 654     } catch (...) {
 655       {
 656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 657       };
 658     }
 659   }
 660
 661 }
 662
 663
 664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
 665   Dali::Window *arg1 = (Dali::Window *) 0 ;
 666   Dali::Window::WindowOrientation arg2 ;
 667
 668   arg1 = (Dali::Window *)jarg1;
 669   arg2 = (Dali::Window::WindowOrientation)jarg2;
 670   {
 671     try {
 672       (arg1)->AddAvailableOrientation(arg2);
 673     } catch (std::out_of_range& e) {
 674       {
 675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 676       };
 677     } catch (std::exception& e) {
 678       {
 679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 680       };
 681     } catch (Dali::DaliException e) {
 682       {
 683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 684       };
 685     } catch (...) {
 686       {
 687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 688       };
 689     }
 690   }
 691
 692 }
 693
 694
 695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
 696   Dali::Window *arg1 = (Dali::Window *) 0 ;
 697   Dali::Window::WindowOrientation arg2 ;
 698
 699   arg1 = (Dali::Window *)jarg1;
 700   arg2 = (Dali::Window::WindowOrientation)jarg2;
 701   {
 702     try {
 703       (arg1)->RemoveAvailableOrientation(arg2);
 704     } catch (std::out_of_range& e) {
 705       {
 706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 707       };
 708     } catch (std::exception& e) {
 709       {
 710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 711       };
 712     } catch (Dali::DaliException e) {
 713       {
 714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 715       };
 716     } catch (...) {
 717       {
 718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 719       };
 720     }
 721   }
 722
 723 }
 724
 725
 726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
 727   Dali::Window *arg1 = (Dali::Window *) 0 ;
 728   Dali::Window::WindowOrientation arg2 ;
 729
 730   arg1 = (Dali::Window *)jarg1;
 731   arg2 = (Dali::Window::WindowOrientation)jarg2;
 732   {
 733     try {
 734       (arg1)->SetPreferredOrientation(arg2);
 735     } catch (std::out_of_range& e) {
 736       {
 737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 738       };
 739     } catch (std::exception& e) {
 740       {
 741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 742       };
 743     } catch (Dali::DaliException e) {
 744       {
 745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 746       };
 747     } catch (...) {
 748       {
 749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 750       };
 751     }
 752   }
 753
 754 }
 755
 756
 757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
 758   int jresult ;
 759   Dali::Window *arg1 = (Dali::Window *) 0 ;
 760   Dali::Window::WindowOrientation result;
 761
 762   arg1 = (Dali::Window *)jarg1;
 763   {
 764     try {
 765       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
 766     } catch (std::out_of_range& e) {
 767       {
 768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 769       };
 770     } catch (std::exception& e) {
 771       {
 772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 773       };
 774     } catch (Dali::DaliException e) {
 775       {
 776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 777       };
 778     } catch (...) {
 779       {
 780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 781       };
 782     }
 783   }
 784
 785   jresult = (int)result;
 786   return jresult;
 787 }
 788
 789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetCurrentOrientation(void * jarg1) {
 790   int jresult ;
 791   Dali::Window::WindowOrientation result;
 792   Dali::Window* window = (Dali::Window*)jarg1;
 793   if (!window) {
 794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 795     return 0;
 796   }
 797   {
 798     try {
 799       result = Dali::DevelWindow::GetCurrentOrientation(*window);
 800     } catch (std::out_of_range& e) {
 801       {
 802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 803       };
 804     } catch (std::exception& e) {
 805       {
 806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 807       };
 808     } catch (Dali::DaliException e) {
 809       {
 810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 811       };
 812     } catch (...) {
 813       {
 814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 815       };
 816     }
 817   }
 818
 819   jresult = (int)result;
 820   return jresult;
 821 }
 822
 823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetAvailableOrientations(void * jarg1, int* jarg2, int jarg3) {
 824   Dali::Window* window = (Dali::Window*)jarg1;
 825   if (!window) {
 826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 827     return;
 828   }
 829   int *arg2 = (int *) 0 ;
 830   int count = jarg3;
 831
 832   arg2 = jarg2;
 833   Dali::Vector< Dali::Window::WindowOrientation> orientations;
 834   orientations.Resize( count );
 835   for( int i = 0; i<count; ++i)
 836   {
 837     orientations[i] = static_cast< Dali::Window::WindowOrientation >(arg2[i]);
 838   }
 839   {
 840     try {
 841       Dali::DevelWindow::SetAvailableOrientations(*window, orientations);
 842     } catch (std::out_of_range& e) {
 843       {
 844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
 845       };
 846     } catch (std::exception& e) {
 847       {
 848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
 849       };
 850     } catch (Dali::DaliException e) {
 851       {
 852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
 853       };
 854     } catch (...) {
 855       {
 856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
 857       };
 858     }
 859   }
 860
 861 }
 862
 863
 864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
 865   void * jresult ;
 866   Dali::Window *arg1 = (Dali::Window *) 0 ;
 867   Dali::Any result;
 868
 869   arg1 = (Dali::Window *)jarg1;
 870   {
 871     try {
 872       result = ((Dali::Window const *)arg1)->GetNativeHandle();
 873     } catch (std::out_of_range& e) {
 874       {
 875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 876       };
 877     } catch (std::exception& e) {
 878       {
 879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 880       };
 881     } catch (Dali::DaliException e) {
 882       {
 883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 884       };
 885     } catch (...) {
 886       {
 887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 888       };
 889     }
 890   }
 891
 892   jresult = new Dali::Any((const Dali::Any &)result);
 893   return jresult;
 894 }
 895
 896 /*window-devel binding*/
 897
 898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
 899   void * jresult ;
 900   Dali::Window arg1 ;
 901   Dali::Window *argp1 ;
 902   Dali::Window::FocusSignalType *result = 0 ;
 903
 904   argp1 = (Dali::Window *)jarg1;
 905   if (!argp1) {
 906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 907     return 0;
 908   }
 909   arg1 = *argp1;
 910   {
 911     try {
 912       result = (Dali::Window::FocusSignalType*)&arg1.FocusChangedSignal();
 913     } catch (std::out_of_range& e) {
 914       {
 915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 916       };
 917     } catch (std::exception& e) {
 918       {
 919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 920       };
 921     } catch (Dali::DaliException e) {
 922       {
 923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 924       };
 925     } catch (...) {
 926       {
 927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 928       };
 929     }
 930   }
 931
 932   jresult = (void *)result;
 933   return jresult;
 934 }
 935
 936
 937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
 938   Dali::Window arg1 ;
 939   bool arg2 ;
 940   Dali::Window *argp1 ;
 941
 942   argp1 = (Dali::Window *)jarg1;
 943   if (!argp1) {
 944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 945     return ;
 946   }
 947   arg1 = *argp1;
 948   arg2 = jarg2 ? true : false;
 949   {
 950     try {
 951       arg1.SetAcceptFocus(arg2);
 952     } catch (std::out_of_range& e) {
 953       {
 954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 955       };
 956     } catch (std::exception& e) {
 957       {
 958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 959       };
 960     } catch (Dali::DaliException e) {
 961       {
 962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 963       };
 964     } catch (...) {
 965       {
 966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 967       };
 968     }
 969   }
 970
 971 }
 972
 973
 974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
 975   unsigned int jresult ;
 976   Dali::Window arg1 ;
 977   Dali::Window *argp1 ;
 978   bool result;
 979
 980   argp1 = (Dali::Window *)jarg1;
 981   if (!argp1) {
 982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 983     return 0;
 984   }
 985   arg1 = *argp1;
 986   {
 987     try {
 988       result = (bool)arg1.IsFocusAcceptable();
 989     } catch (std::out_of_range& e) {
 990       {
 991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 992       };
 993     } catch (std::exception& e) {
 994       {
 995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 996       };
 997     } catch (Dali::DaliException e) {
 998       {
 999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1000       };
1001     } catch (...) {
1002       {
1003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1004       };
1005     }
1006   }
1007
1008   jresult = result;
1009   return jresult;
1010 }
1011
1012
1013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
1014   Dali::Window arg1 ;
1015   Dali::Window *argp1 ;
1016
1017   argp1 = (Dali::Window *)jarg1;
1018   if (!argp1) {
1019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1020     return ;
1021   }
1022   arg1 = *argp1;
1023   {
1024     try {
1025       arg1.Show();
1026     } catch (std::out_of_range& e) {
1027       {
1028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1029       };
1030     } catch (std::exception& e) {
1031       {
1032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1033       };
1034     } catch (Dali::DaliException e) {
1035       {
1036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1037       };
1038     } catch (...) {
1039       {
1040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1041       };
1042     }
1043   }
1044
1045 }
1046
1047
1048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
1049   Dali::Window arg1 ;
1050   Dali::Window *argp1 ;
1051
1052   argp1 = (Dali::Window *)jarg1;
1053   if (!argp1) {
1054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1055     return ;
1056   }
1057   arg1 = *argp1;
1058   {
1059     try {
1060       arg1.Hide();
1061     } catch (std::out_of_range& e) {
1062       {
1063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1064       };
1065     } catch (std::exception& e) {
1066       {
1067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1068       };
1069     } catch (Dali::DaliException e) {
1070       {
1071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1072       };
1073     } catch (...) {
1074       {
1075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1076       };
1077     }
1078   }
1079
1080 }
1081
1082
1083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
1084   unsigned int jresult ;
1085   Dali::Window arg1 ;
1086   Dali::Window *argp1 ;
1087   bool result;
1088
1089   argp1 = (Dali::Window *)jarg1;
1090   if (!argp1) {
1091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1092     return 0;
1093   }
1094   arg1 = *argp1;
1095   {
1096     try {
1097       result = (bool)arg1.IsVisible();
1098     } catch (std::out_of_range& e) {
1099       {
1100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1101       };
1102     } catch (std::exception& e) {
1103       {
1104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1105       };
1106     } catch (Dali::DaliException e) {
1107       {
1108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1109       };
1110     } catch (...) {
1111       {
1112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1113       };
1114     }
1115   }
1116
1117   jresult = result;
1118   return jresult;
1119 }
1120
1121
1122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHintCount(void * jarg1) {
1123   unsigned int jresult ;
1124   Dali::Window arg1 ;
1125   Dali::Window *argp1 ;
1126   unsigned int result;
1127
1128   argp1 = (Dali::Window *)jarg1;
1129   if (!argp1) {
1130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1131     return 0;
1132   }
1133   arg1 = *argp1;
1134   {
1135     try {
1136       result = (unsigned int)arg1.GetSupportedAuxiliaryHintCount();
1137     } catch (std::out_of_range& e) {
1138       {
1139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1140       };
1141     } catch (std::exception& e) {
1142       {
1143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1144       };
1145     } catch (Dali::DaliException e) {
1146       {
1147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1148       };
1149     } catch (...) {
1150       {
1151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1152       };
1153     }
1154   }
1155
1156   jresult = result;
1157   return jresult;
1158 }
1159
1160
1161 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHint(void * jarg1, unsigned int jarg2) {
1162   char * jresult ;
1163   Dali::Window arg1 ;
1164   unsigned int arg2 ;
1165   Dali::Window *argp1 ;
1166   std::string result;
1167
1168   argp1 = (Dali::Window *)jarg1;
1169   if (!argp1) {
1170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1171     return 0;
1172   }
1173   arg1 = *argp1;
1174   arg2 = (unsigned int)jarg2;
1175   {
1176     try {
1177       result = arg1.GetSupportedAuxiliaryHint(arg2);
1178     } catch (std::out_of_range& e) {
1179       {
1180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1181       };
1182     } catch (std::exception& e) {
1183       {
1184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1185       };
1186     } catch (Dali::DaliException e) {
1187       {
1188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1189       };
1190     } catch (...) {
1191       {
1192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1193       };
1194     }
1195   }
1196
1197   jresult = SWIG_csharp_string_callback((&result)->c_str());
1198   return jresult;
1199 }
1200
1201
1202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AddAuxiliaryHint(void * jarg1, char * jarg2, char * jarg3) {
1203   unsigned int jresult ;
1204   Dali::Window arg1 ;
1205   std::string *arg2 = 0 ;
1206   std::string *arg3 = 0 ;
1207   Dali::Window *argp1 ;
1208   unsigned int result;
1209
1210   argp1 = (Dali::Window *)jarg1;
1211   if (!argp1) {
1212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1213     return 0;
1214   }
1215   arg1 = *argp1;
1216   if (!jarg2) {
1217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1218     return 0;
1219   }
1220   std::string arg2_str(jarg2);
1221   arg2 = &arg2_str;
1222   if (!jarg3) {
1223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1224     return 0;
1225   }
1226   std::string arg3_str(jarg3);
1227   arg3 = &arg3_str;
1228   {
1229     try {
1230       result = (unsigned int)arg1.AddAuxiliaryHint((std::string const &)*arg2,(std::string const &)*arg3);
1231     } catch (std::out_of_range& e) {
1232       {
1233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1234       };
1235     } catch (std::exception& e) {
1236       {
1237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1238       };
1239     } catch (Dali::DaliException e) {
1240       {
1241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1242       };
1243     } catch (...) {
1244       {
1245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1246       };
1247     }
1248   }
1249
1250   jresult = result;
1251
1252   return jresult;
1253 }
1254
1255
1256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RemoveAuxiliaryHint(void * jarg1, unsigned int jarg2) {
1257   unsigned int jresult ;
1258   Dali::Window arg1 ;
1259   unsigned int arg2 ;
1260   Dali::Window *argp1 ;
1261   bool 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 = (bool)arg1.RemoveAuxiliaryHint(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 = result;
1293   return jresult;
1294 }
1295
1296
1297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetAuxiliaryHintValue(void * jarg1, unsigned int jarg2, char * jarg3) {
1298   unsigned int jresult ;
1299   Dali::Window arg1 ;
1300   unsigned int arg2 ;
1301   std::string *arg3 = 0 ;
1302   Dali::Window *argp1 ;
1303   bool result;
1304
1305   argp1 = (Dali::Window *)jarg1;
1306   if (!argp1) {
1307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1308     return 0;
1309   }
1310   arg1 = *argp1;
1311   arg2 = (unsigned int)jarg2;
1312   if (!jarg3) {
1313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1314     return 0;
1315   }
1316   std::string arg3_str(jarg3);
1317   arg3 = &arg3_str;
1318   {
1319     try {
1320       result = (bool)arg1.SetAuxiliaryHintValue(arg2,(std::string const &)*arg3);
1321     } catch (std::out_of_range& e) {
1322       {
1323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1324       };
1325     } catch (std::exception& e) {
1326       {
1327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1328       };
1329     } catch (Dali::DaliException e) {
1330       {
1331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1332       };
1333     } catch (...) {
1334       {
1335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1336       };
1337     }
1338   }
1339
1340   jresult = result;
1341
1342   //argout typemap for const std::string&
1343
1344   return jresult;
1345 }
1346
1347
1348 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintValue(void * jarg1, unsigned int jarg2) {
1349   char * jresult ;
1350   Dali::Window arg1 ;
1351   unsigned int arg2 ;
1352   Dali::Window *argp1 ;
1353   std::string result;
1354
1355   argp1 = (Dali::Window *)jarg1;
1356   if (!argp1) {
1357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1358     return 0;
1359   }
1360   arg1 = *argp1;
1361   arg2 = (unsigned int)jarg2;
1362   {
1363     try {
1364       result = arg1.GetAuxiliaryHintValue(arg2);
1365     } catch (std::out_of_range& e) {
1366       {
1367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1368       };
1369     } catch (std::exception& e) {
1370       {
1371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1372       };
1373     } catch (Dali::DaliException e) {
1374       {
1375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1376       };
1377     } catch (...) {
1378       {
1379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1380       };
1381     }
1382   }
1383
1384   jresult = SWIG_csharp_string_callback((&result)->c_str());
1385   return jresult;
1386 }
1387
1388
1389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintId(void * jarg1, char * jarg2) {
1390   unsigned int jresult ;
1391   Dali::Window arg1 ;
1392   std::string *arg2 = 0 ;
1393   Dali::Window *argp1 ;
1394   unsigned int result;
1395
1396   argp1 = (Dali::Window *)jarg1;
1397   if (!argp1) {
1398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1399     return 0;
1400   }
1401   arg1 = *argp1;
1402   if (!jarg2) {
1403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1404     return 0;
1405   }
1406   std::string arg2_str(jarg2);
1407   arg2 = &arg2_str;
1408   {
1409     try {
1410       result = (unsigned int)arg1.GetAuxiliaryHintId((std::string const &)*arg2);
1411     } catch (std::out_of_range& e) {
1412       {
1413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1414       };
1415     } catch (std::exception& e) {
1416       {
1417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1418       };
1419     } catch (Dali::DaliException e) {
1420       {
1421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1422       };
1423     } catch (...) {
1424       {
1425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1426       };
1427     }
1428   }
1429
1430   jresult = result;
1431
1432   //argout typemap for const std::string&
1433
1434   return jresult;
1435 }
1436
1437
1438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetInputRegion(void * jarg1, void * jarg2) {
1439   Dali::Window arg1 ;
1440   Dali::Rect< int > *arg2 = 0 ;
1441   Dali::Window *argp1 ;
1442
1443   argp1 = (Dali::Window *)jarg1;
1444   if (!argp1) {
1445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1446     return ;
1447   }
1448   arg1 = *argp1;
1449   arg2 = (Dali::Rect< int > *)jarg2;
1450   if (!arg2) {
1451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
1452     return ;
1453   }
1454   {
1455     try {
1456       arg1.SetInputRegion((Dali::Rect< int > const &)*arg2);
1457     } catch (std::out_of_range& e) {
1458       {
1459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1460       };
1461     } catch (std::exception& e) {
1462       {
1463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1464       };
1465     } catch (Dali::DaliException e) {
1466       {
1467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1468       };
1469     } catch (...) {
1470       {
1471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1472       };
1473     }
1474   }
1475
1476 }
1477
1478
1479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetType(void * jarg1, int jarg2) {
1480   Dali::Window arg1 ;
1481   Dali::Window::Type arg2 ;
1482   Dali::Window *argp1 ;
1483
1484   argp1 = (Dali::Window *)jarg1;
1485   if (!argp1) {
1486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1487     return ;
1488   }
1489   arg1 = *argp1;
1490   arg2 = (Dali::Window::Type)jarg2;
1491   {
1492     try {
1493       arg1.SetType(arg2);
1494     } catch (std::out_of_range& e) {
1495       {
1496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1497       };
1498     } catch (std::exception& e) {
1499       {
1500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1501       };
1502     } catch (Dali::DaliException e) {
1503       {
1504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1505       };
1506     } catch (...) {
1507       {
1508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1509       };
1510     }
1511   }
1512
1513 }
1514
1515
1516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetType(void * jarg1) {
1517   int jresult ;
1518   Dali::Window arg1 ;
1519   Dali::Window *argp1 ;
1520   Dali::Window::Type result;
1521
1522   argp1 = (Dali::Window *)jarg1;
1523   if (!argp1) {
1524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1525     return 0;
1526   }
1527   arg1 = *argp1;
1528   {
1529     try {
1530       result = (Dali::Window::Type)arg1.GetType();
1531     } catch (std::out_of_range& e) {
1532       {
1533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1534       };
1535     } catch (std::exception& e) {
1536       {
1537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1538       };
1539     } catch (Dali::DaliException e) {
1540       {
1541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1542       };
1543     } catch (...) {
1544       {
1545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1546       };
1547     }
1548   }
1549
1550   jresult = (int)result;
1551   return jresult;
1552 }
1553
1554
1555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetNotificationLevel(void * jarg1, int jarg2) {
1556   unsigned int jresult ;
1557   Dali::Window arg1 ;
1558   Dali::Window::NotificationLevel::Type arg2 ;
1559   Dali::Window *argp1 ;
1560   bool result;
1561
1562   argp1 = (Dali::Window *)jarg1;
1563   if (!argp1) {
1564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1565     return 0;
1566   }
1567   arg1 = *argp1;
1568   arg2 = (Dali::Window::NotificationLevel::Type)jarg2;
1569   {
1570     try {
1571       result = (bool)arg1.SetNotificationLevel(arg2);
1572     } catch (std::out_of_range& e) {
1573       {
1574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1575       };
1576     } catch (std::exception& e) {
1577       {
1578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1579       };
1580     } catch (Dali::DaliException e) {
1581       {
1582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1583       };
1584     } catch (...) {
1585       {
1586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1587       };
1588     }
1589   }
1590
1591   jresult = result;
1592   return jresult;
1593 }
1594
1595
1596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetNotificationLevel(void * jarg1) {
1597   int jresult ;
1598   Dali::Window arg1 ;
1599   Dali::Window *argp1 ;
1600   Dali::Window::NotificationLevel::Type result;
1601
1602   argp1 = (Dali::Window *)jarg1;
1603   if (!argp1) {
1604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1605     return 0;
1606   }
1607   arg1 = *argp1;
1608   {
1609     try {
1610       result = (Dali::Window::NotificationLevel::Type)arg1.GetNotificationLevel();
1611     } catch (std::out_of_range& e) {
1612       {
1613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1614       };
1615     } catch (std::exception& e) {
1616       {
1617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1618       };
1619     } catch (Dali::DaliException e) {
1620       {
1621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1622       };
1623     } catch (...) {
1624       {
1625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1626       };
1627     }
1628   }
1629
1630   jresult = (int)result;
1631   return jresult;
1632 }
1633
1634
1635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetOpaqueState(void * jarg1, unsigned int jarg2) {
1636   Dali::Window arg1 ;
1637   bool arg2 ;
1638   Dali::Window *argp1 ;
1639
1640   argp1 = (Dali::Window *)jarg1;
1641   if (!argp1) {
1642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1643     return ;
1644   }
1645   arg1 = *argp1;
1646   arg2 = jarg2 ? true : false;
1647   {
1648     try {
1649       arg1.SetOpaqueState(arg2);
1650     } catch (std::out_of_range& e) {
1651       {
1652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1653       };
1654     } catch (std::exception& e) {
1655       {
1656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1657       };
1658     } catch (Dali::DaliException e) {
1659       {
1660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1661       };
1662     } catch (...) {
1663       {
1664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1665       };
1666     }
1667   }
1668
1669 }
1670
1671
1672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsOpaqueState(void * jarg1) {
1673   unsigned int jresult ;
1674   Dali::Window arg1 ;
1675   Dali::Window *argp1 ;
1676   bool result;
1677
1678   argp1 = (Dali::Window *)jarg1;
1679   if (!argp1) {
1680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1681     return 0;
1682   }
1683   arg1 = *argp1;
1684   {
1685     try {
1686       result = (bool)arg1.IsOpaqueState();
1687     } catch (std::out_of_range& e) {
1688       {
1689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1690       };
1691     } catch (std::exception& e) {
1692       {
1693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1694       };
1695     } catch (Dali::DaliException e) {
1696       {
1697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1698       };
1699     } catch (...) {
1700       {
1701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1702       };
1703     }
1704   }
1705
1706   jresult = result;
1707   return jresult;
1708 }
1709
1710
1711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetScreenOffMode(void * jarg1, int jarg2) {
1712   unsigned int jresult ;
1713   Dali::Window arg1 ;
1714   Dali::Window::ScreenOffMode::Type arg2 ;
1715   Dali::Window *argp1 ;
1716   bool result;
1717
1718   argp1 = (Dali::Window *)jarg1;
1719   if (!argp1) {
1720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1721     return 0;
1722   }
1723   arg1 = *argp1;
1724   arg2 = (Dali::Window::ScreenOffMode::Type)jarg2;
1725   {
1726     try {
1727       result = (bool)arg1.SetScreenOffMode(arg2);
1728     } catch (std::out_of_range& e) {
1729       {
1730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1731       };
1732     } catch (std::exception& e) {
1733       {
1734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1735       };
1736     } catch (Dali::DaliException e) {
1737       {
1738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1739       };
1740     } catch (...) {
1741       {
1742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1743       };
1744     }
1745   }
1746
1747   jresult = result;
1748   return jresult;
1749 }
1750
1751
1752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetScreenOffMode(void * jarg1) {
1753   int jresult ;
1754   Dali::Window arg1 ;
1755   Dali::Window *argp1 ;
1756   Dali::Window::ScreenOffMode::Type result;
1757
1758   argp1 = (Dali::Window *)jarg1;
1759   if (!argp1) {
1760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1761     return 0;
1762   }
1763   arg1 = *argp1;
1764   {
1765     try {
1766       result = (Dali::Window::ScreenOffMode::Type)arg1.GetScreenOffMode();
1767     } catch (std::out_of_range& e) {
1768       {
1769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1770       };
1771     } catch (std::exception& e) {
1772       {
1773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1774       };
1775     } catch (Dali::DaliException e) {
1776       {
1777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1778       };
1779     } catch (...) {
1780       {
1781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1782       };
1783     }
1784   }
1785
1786   jresult = (int)result;
1787   return jresult;
1788 }
1789
1790
1791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetBrightness(void * jarg1, int jarg2) {
1792   unsigned int jresult ;
1793   Dali::Window arg1 ;
1794   int arg2 ;
1795   Dali::Window *argp1 ;
1796   bool result;
1797
1798   argp1 = (Dali::Window *)jarg1;
1799   if (!argp1) {
1800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1801     return 0;
1802   }
1803   arg1 = *argp1;
1804   arg2 = (int)jarg2;
1805   {
1806     try {
1807       result = (bool)arg1.SetBrightness(arg2);
1808     } catch (std::out_of_range& e) {
1809       {
1810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1811       };
1812     } catch (std::exception& e) {
1813       {
1814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1815       };
1816     } catch (Dali::DaliException e) {
1817       {
1818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1819       };
1820     } catch (...) {
1821       {
1822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1823       };
1824     }
1825   }
1826
1827   jresult = result;
1828   return jresult;
1829 }
1830
1831
1832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetBrightness(void * jarg1) {
1833   int jresult ;
1834   Dali::Window arg1 ;
1835   Dali::Window *argp1 ;
1836   int result;
1837
1838   argp1 = (Dali::Window *)jarg1;
1839   if (!argp1) {
1840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1841     return 0;
1842   }
1843   arg1 = *argp1;
1844   {
1845     try {
1846       result = (int)arg1.GetBrightness();
1847     } catch (std::out_of_range& e) {
1848       {
1849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1850       };
1851     } catch (std::exception& e) {
1852       {
1853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1854       };
1855     } catch (Dali::DaliException e) {
1856       {
1857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1858       };
1859     } catch (...) {
1860       {
1861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1862       };
1863     }
1864   }
1865
1866   jresult = result;
1867   return jresult;
1868 }
1869
1870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
1871   unsigned int jresult ;
1872   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1873   bool result;
1874
1875   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1876   {
1877     try {
1878       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
1879     } catch (std::out_of_range& e) {
1880       {
1881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1882       };
1883     } catch (std::exception& e) {
1884       {
1885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1886       };
1887     } catch (Dali::DaliException e) {
1888       {
1889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1890       };
1891     } catch (...) {
1892       {
1893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1894       };
1895     }
1896   }
1897
1898   jresult = result;
1899   return jresult;
1900 }
1901
1902
1903 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
1904   unsigned long jresult ;
1905   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1906   std::size_t result;
1907
1908   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1909   {
1910     try {
1911       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
1912     } catch (std::out_of_range& e) {
1913       {
1914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1915       };
1916     } catch (std::exception& e) {
1917       {
1918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1919       };
1920     } catch (Dali::DaliException e) {
1921       {
1922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1923       };
1924     } catch (...) {
1925       {
1926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1927       };
1928     }
1929   }
1930
1931   jresult = (unsigned long)result;
1932   return jresult;
1933 }
1934
1935
1936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
1937   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1938   void (*arg2)(bool) = (void (*)(bool)) 0 ;
1939
1940   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1941   arg2 = (void (*)(bool))jarg2;
1942   {
1943     try {
1944       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
1945     } catch (std::out_of_range& e) {
1946       {
1947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1948       };
1949     } catch (std::exception& e) {
1950       {
1951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1952       };
1953     } catch (Dali::DaliException e) {
1954       {
1955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1956       };
1957     } catch (...) {
1958       {
1959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1960       };
1961     }
1962   }
1963
1964 }
1965
1966
1967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
1968   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1969   void (*arg2)(bool) = (void (*)(bool)) 0 ;
1970
1971   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1972   arg2 = (void (*)(bool))jarg2;
1973   {
1974     try {
1975       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
1976     } catch (std::out_of_range& e) {
1977       {
1978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1979       };
1980     } catch (std::exception& e) {
1981       {
1982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1983       };
1984     } catch (Dali::DaliException e) {
1985       {
1986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1987       };
1988     } catch (...) {
1989       {
1990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1991       };
1992     }
1993   }
1994
1995 }
1996
1997
1998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
1999   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
2000   bool arg2 ;
2001
2002   arg1 = (Dali::Signal< void (bool) > *)jarg1;
2003   arg2 = jarg2 ? true : false;
2004   {
2005     try {
2006       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
2007     } catch (std::out_of_range& e) {
2008       {
2009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2010       };
2011     } catch (std::exception& e) {
2012       {
2013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2014       };
2015     } catch (Dali::DaliException e) {
2016       {
2017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2018       };
2019     } catch (...) {
2020       {
2021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2022       };
2023     }
2024   }
2025
2026 }
2027
2028
2029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
2030   void * jresult ;
2031   Dali::Signal< void (bool) > *result = 0 ;
2032
2033   {
2034     try {
2035       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
2036     } catch (std::out_of_range& e) {
2037       {
2038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2039       };
2040     } catch (std::exception& e) {
2041       {
2042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2043       };
2044     } catch (Dali::DaliException e) {
2045       {
2046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2047       };
2048     } catch (...) {
2049       {
2050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2051       };
2052     }
2053   }
2054
2055   jresult = (void *)result;
2056   return jresult;
2057 }
2058
2059
2060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
2061   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
2062
2063   arg1 = (Dali::Signal< void (bool) > *)jarg1;
2064   {
2065     try {
2066       delete arg1;
2067     } catch (std::out_of_range& e) {
2068       {
2069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2070       };
2071     } catch (std::exception& e) {
2072       {
2073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2074       };
2075     } catch (Dali::DaliException e) {
2076       {
2077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2078       };
2079     } catch (...) {
2080       {
2081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2082       };
2083     }
2084   }
2085
2086 }
2087
2088
2089
2090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_ResizedSignal(void * jarg1) {
2091   void * jresult ;
2092   Dali::Window arg1 ;
2093   Dali::Window *argp1 ;
2094   Dali::Window::ResizedSignalType *result = 0 ;
2095
2096   argp1 = (Dali::Window *)jarg1;
2097   if (!argp1) {
2098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2099     return 0;
2100   }
2101   arg1 = *argp1;
2102   {
2103     try {
2104       result = (Dali::Window::ResizedSignalType *) &arg1.ResizedSignal();
2105     } catch (std::out_of_range& e) {
2106       {
2107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2108       };
2109     } catch (std::exception& e) {
2110       {
2111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2112       };
2113     } catch (Dali::DaliException e) {
2114       {
2115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2116       };
2117     } catch (...) {
2118       {
2119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2120       };
2121     }
2122   }
2123
2124   jresult = (void *)result;
2125   return jresult;
2126 }
2127
2128 /*ResizedSignal binding*/
2129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResizedSignal_Empty(void * jarg1) {
2130   unsigned int jresult ;
2131   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2132   bool result;
2133
2134   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2135   {
2136     try {
2137       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Empty((Dali::Signal< void (Dali::Window::WindowSize) > const *)arg1);
2138     } catch (std::out_of_range& e) {
2139       {
2140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2141       };
2142     } catch (std::exception& e) {
2143       {
2144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2145       };
2146     } catch (Dali::DaliException e) {
2147       {
2148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2149       };
2150     } catch (...) {
2151       {
2152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2153       };
2154     }
2155   }
2156
2157   jresult = result;
2158   return jresult;
2159 }
2160
2161
2162 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResizedSignal_GetConnectionCount(void * jarg1) {
2163   unsigned long jresult ;
2164   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2165   std::size_t result;
2166
2167   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2168   {
2169     try {
2170       result = Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Window::WindowSize) > const *)arg1);
2171     } catch (std::out_of_range& e) {
2172       {
2173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2174       };
2175     } catch (std::exception& e) {
2176       {
2177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2178       };
2179     } catch (Dali::DaliException e) {
2180       {
2181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2182       };
2183     } catch (...) {
2184       {
2185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2186       };
2187     }
2188   }
2189
2190   jresult = (unsigned long)result;
2191   return jresult;
2192 }
2193
2194
2195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizedSignal_Connect(void * jarg1, void * jarg2) {
2196   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2197   void (*arg2)(Dali::Window::WindowSize) = (void (*)(Dali::Window::WindowSize)) 0 ;
2198
2199   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2200   arg2 = (void (*)(Dali::Window::WindowSize))jarg2;
2201   {
2202     try {
2203       Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Connect(arg1,arg2);
2204     } catch (std::out_of_range& e) {
2205       {
2206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2207       };
2208     } catch (std::exception& e) {
2209       {
2210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2211       };
2212     } catch (Dali::DaliException e) {
2213       {
2214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2215       };
2216     } catch (...) {
2217       {
2218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2219       };
2220     }
2221   }
2222
2223 }
2224
2225
2226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizedSignal_Disconnect(void * jarg1, void * jarg2) {
2227   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2228   void (*arg2)(Dali::Window::WindowSize) = (void (*)(Dali::Window::WindowSize)) 0 ;
2229
2230   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2231   arg2 = (void (*)(Dali::Window::WindowSize))jarg2;
2232   {
2233     try {
2234       Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Disconnect(arg1,arg2);
2235     } catch (std::out_of_range& e) {
2236       {
2237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2238       };
2239     } catch (std::exception& e) {
2240       {
2241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2242       };
2243     } catch (Dali::DaliException e) {
2244       {
2245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2246       };
2247     } catch (...) {
2248       {
2249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2250       };
2251     }
2252   }
2253
2254 }
2255
2256
2257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizedSignal_Emit(void * jarg1, void * jarg2) {
2258   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2259   Dali::Window::WindowSize arg2 ;
2260   Dali::Window::WindowSize *argp2 ;
2261
2262   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2263   argp2 = (Dali::Window::WindowSize *)jarg2;
2264   if (!argp2) {
2265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0);
2266     return ;
2267   }
2268   arg2 = *argp2;
2269   {
2270     try {
2271       Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Emit(arg1,arg2);
2272     } catch (std::out_of_range& e) {
2273       {
2274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2275       };
2276     } catch (std::exception& e) {
2277       {
2278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2279       };
2280     } catch (Dali::DaliException e) {
2281       {
2282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2283       };
2284     } catch (...) {
2285       {
2286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2287       };
2288     }
2289   }
2290
2291 }
2292
2293
2294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResizedSignal() {
2295   void * jresult ;
2296   Dali::Signal< void (Dali::Window::WindowSize) > *result = 0 ;
2297
2298   {
2299     try {
2300       result = (Dali::Signal< void (Dali::Window::WindowSize) > *)new Dali::Signal< void (Dali::Window::WindowSize) >();
2301     } catch (std::out_of_range& e) {
2302       {
2303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2304       };
2305     } catch (std::exception& e) {
2306       {
2307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2308       };
2309     } catch (Dali::DaliException e) {
2310       {
2311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2312       };
2313     } catch (...) {
2314       {
2315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2316       };
2317     }
2318   }
2319
2320   jresult = (void *)result;
2321   return jresult;
2322 }
2323
2324
2325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResizedSignal(void * jarg1) {
2326   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2327
2328   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2329   {
2330     try {
2331       delete arg1;
2332     } catch (std::out_of_range& e) {
2333       {
2334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2335       };
2336     } catch (std::exception& e) {
2337       {
2338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2339       };
2340     } catch (Dali::DaliException e) {
2341       {
2342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2343       };
2344     } catch (...) {
2345       {
2346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2347       };
2348     }
2349   }
2350
2351 }
2352
2353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetSize(void * jarg1, void * jarg2) {
2354   Dali::Window arg1 ;
2355   Dali::Window::WindowSize arg2 ;
2356   Dali::Window *argp1 ;
2357   Dali::Window::WindowSize *argp2 ;
2358
2359   argp1 = (Dali::Window *)jarg1;
2360   if (!argp1) {
2361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2362     return ;
2363   }
2364   arg1 = *argp1;
2365   argp2 = (Dali::Window::WindowSize *)jarg2;
2366   if (!argp2) {
2367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0);
2368     return ;
2369   }
2370   arg2 = *argp2;
2371   {
2372     try {
2373       arg1.SetSize(arg2);
2374     } catch (std::out_of_range& e) {
2375       {
2376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2377       };
2378     } catch (std::exception& e) {
2379       {
2380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2381       };
2382     } catch (Dali::DaliException e) {
2383       {
2384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2385       };
2386     } catch (...) {
2387       {
2388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2389       };
2390     }
2391   }
2392
2393 }
2394
2395
2396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetSize(void * jarg1) {
2397   void * jresult ;
2398   Dali::Window arg1 ;
2399   Dali::Window *argp1 ;
2400   Dali::Window::WindowSize result;
2401
2402   argp1 = (Dali::Window *)jarg1;
2403   if (!argp1) {
2404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2405     return 0;
2406   }
2407   arg1 = *argp1;
2408   {
2409     try {
2410       result = arg1.GetSize();
2411     } catch (std::out_of_range& e) {
2412       {
2413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2414       };
2415     } catch (std::exception& e) {
2416       {
2417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2418       };
2419     } catch (Dali::DaliException e) {
2420       {
2421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2422       };
2423     } catch (...) {
2424       {
2425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2426       };
2427     }
2428   }
2429
2430   jresult = new Dali::Window::WindowSize((const Dali::Window::WindowSize &)result);
2431   return jresult;
2432 }
2433
2434
2435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPosition(void * jarg1, void * jarg2) {
2436   Dali::Window arg1 ;
2437   Dali::Window::WindowPosition arg2 ;
2438   Dali::Window *argp1 ;
2439   Dali::Window::WindowPosition *argp2 ;
2440
2441   argp1 = (Dali::Window *)jarg1;
2442   if (!argp1) {
2443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2444     return ;
2445   }
2446   arg1 = *argp1;
2447   argp2 = (Dali::Window::WindowPosition *)jarg2;
2448   if (!argp2) {
2449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowPosition", 0);
2450     return ;
2451   }
2452   arg2 = *argp2;
2453   {
2454     try {
2455       arg1.SetPosition(arg2);
2456     } catch (std::out_of_range& e) {
2457       {
2458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2459       };
2460     } catch (std::exception& e) {
2461       {
2462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2463       };
2464     } catch (Dali::DaliException e) {
2465       {
2466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2467       };
2468     } catch (...) {
2469       {
2470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2471       };
2472     }
2473   }
2474
2475 }
2476
2477
2478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetPosition(void * jarg1) {
2479   void * jresult ;
2480   Dali::Window arg1 ;
2481   Dali::Window *argp1 ;
2482   Dali::Window::WindowPosition result;
2483
2484   argp1 = (Dali::Window *)jarg1;
2485   if (!argp1) {
2486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2487     return 0;
2488   }
2489   arg1 = *argp1;
2490   {
2491     try {
2492       result = arg1.GetPosition();
2493     } catch (std::out_of_range& e) {
2494       {
2495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2496       };
2497     } catch (std::exception& e) {
2498       {
2499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2500       };
2501     } catch (Dali::DaliException e) {
2502       {
2503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2504       };
2505     } catch (...) {
2506       {
2507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2508       };
2509     }
2510   }
2511
2512   jresult = new Dali::Window::WindowPosition((const Dali::Window::WindowPosition &)result);
2513   return jresult;
2514 }
2515
2516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPositionSize(void* jarg1, void* jarg2)
2517 {
2518   Dali::Window* window = (Dali::Window*)jarg1;
2519   if (!window) {
2520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2521     return ;
2522   }
2523
2524   Dali::Rect<int>* positionSize = (Dali::Rect<int>*)jarg2;
2525   if (!positionSize) {
2526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
2527     return ;
2528   }
2529   {
2530     try {
2531       Dali::DevelWindow::SetPositionSize(*window, *positionSize);
2532     } catch (std::out_of_range& e) {
2533       {
2534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2535       };
2536     } catch (std::exception& e) {
2537       {
2538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2539       };
2540     } catch (Dali::DaliException e) {
2541       {
2542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2543       };
2544     } catch (...) {
2545       {
2546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2547       };
2548     }
2549   }
2550
2551 }
2552
2553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetTransparency(void * jarg1, unsigned int jarg2) {
2554   Dali::Window arg1 ;
2555   bool arg2 ;
2556   Dali::Window *argp1 ;
2557
2558   argp1 = (Dali::Window *)jarg1;
2559   if (!argp1) {
2560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2561     return ;
2562   }
2563   arg1 = *argp1;
2564   arg2 = jarg2 ? true : false;
2565   {
2566     try {
2567       arg1.SetTransparency(arg2);
2568     } catch (std::out_of_range& e) {
2569       {
2570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2571       };
2572     } catch (std::exception& e) {
2573       {
2574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2575       };
2576     } catch (Dali::DaliException e) {
2577       {
2578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2579       };
2580     } catch (...) {
2581       {
2582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2583       };
2584     }
2585   }
2586
2587 }
2588
2589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_FeedKeyEvent(void * jarg1) {
2590   Dali::KeyEvent *arg1 = 0 ;
2591
2592   arg1 = (Dali::KeyEvent *)jarg1;
2593   if (!arg1) {
2594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0);
2595     return ;
2596   }
2597   {
2598     try {
2599       Dali::Adaptor::Get().FeedKeyEvent(*arg1);
2600     } catch (std::out_of_range& e) {
2601       {
2602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2603       };
2604     } catch (std::exception& e) {
2605       {
2606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2607       };
2608     } catch (...) {
2609       {
2610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2611       };
2612     }
2613   }
2614 }
2615
2616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_RenderOnce(void * /* jarg1 */) {
2617   try {
2618     Dali::Adaptor::Get().RenderOnce();
2619   } catch (std::out_of_range& e) {
2620     {
2621       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2622     };
2623   } catch (std::exception& e) {
2624     {
2625       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2626     };
2627   } catch (...) {
2628     {
2629       SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2630     };
2631   }
2632 }
2633
2634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Add(void * jarg1, void * jarg2) {
2635   Dali::Window *arg1 = (Dali::Window *) 0 ;
2636   Dali::Actor arg2 ;
2637   Dali::Actor *argp2 ;
2638
2639   arg1 = (Dali::Window *)jarg1;
2640   argp2 = (Dali::Actor *)jarg2;
2641   if (!argp2) {
2642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2643     return ;
2644   }
2645   arg2 = *argp2;
2646   {
2647     try {
2648       (arg1)->Add(arg2);
2649     } catch (std::out_of_range& e) {
2650       {
2651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2652       };
2653     } catch (std::exception& e) {
2654       {
2655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2656       };
2657     } catch (Dali::DaliException e) {
2658       {
2659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2660       };
2661     } catch (...) {
2662       {
2663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2664       };
2665     }
2666   }
2667 }
2668
2669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Remove(void * jarg1, void * jarg2) {
2670   Dali::Window *arg1 = (Dali::Window *) 0 ;
2671   Dali::Actor *arg2 = 0 ;
2672
2673   arg1 = (Dali::Window *)jarg1;
2674   arg2 = (Dali::Actor *)jarg2;
2675   if (!arg2) {
2676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
2677     return ;
2678   }
2679   {
2680     try {
2681       (arg1)->Remove(*arg2);
2682     } catch (std::out_of_range& e) {
2683       {
2684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2685       };
2686     } catch (std::exception& e) {
2687       {
2688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2689       };
2690     } catch (Dali::DaliException e) {
2691       {
2692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2693       };
2694     } catch (...) {
2695       {
2696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2697       };
2698     }
2699   }
2700 }
2701
2702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetBackgroundColor(void * jarg1, void * jarg2) {
2703   Dali::Window *arg1 = (Dali::Window *) 0 ;
2704   Dali::Vector4 arg2 ;
2705   Dali::Vector4 *argp2 ;
2706
2707   arg1 = (Dali::Window *)jarg1;
2708   argp2 = (Dali::Vector4 *)jarg2;
2709   if (!argp2) {
2710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
2711     return ;
2712   }
2713   arg2 = *argp2;
2714   {
2715     try {
2716       (arg1)->SetBackgroundColor(arg2);
2717     } catch (std::out_of_range& e) {
2718       {
2719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2720       };
2721     } catch (std::exception& e) {
2722       {
2723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2724       };
2725     } catch (Dali::DaliException e) {
2726       {
2727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2728       };
2729     } catch (...) {
2730       {
2731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2732       };
2733     }
2734   }
2735 }
2736
2737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetBackgroundColor(void * jarg1) {
2738   void * jresult ;
2739   Dali::Window *arg1 = (Dali::Window *) 0 ;
2740   Dali::Vector4 result;
2741
2742   arg1 = (Dali::Window *)jarg1;
2743   {
2744     try {
2745       result = ((Dali::Window const *)arg1)->GetBackgroundColor();
2746     } catch (std::out_of_range& e) {
2747       {
2748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2749       };
2750     } catch (std::exception& e) {
2751       {
2752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2753       };
2754     } catch (Dali::DaliException e) {
2755       {
2756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2757       };
2758     } catch (...) {
2759       {
2760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2761       };
2762     }
2763   }
2764
2765   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
2766   return jresult;
2767 }
2768
2769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetRootLayer(void * jarg1) {
2770   void * jresult ;
2771   Dali::Window *arg1 = (Dali::Window *) 0 ;
2772   Dali::Layer result;
2773
2774   arg1 = (Dali::Window *)jarg1;
2775   {
2776     try {
2777       result = ((Dali::Window const *)arg1)->GetRootLayer();
2778     } catch (std::out_of_range& e) {
2779       {
2780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2781       };
2782     } catch (std::exception& e) {
2783       {
2784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2785       };
2786     } catch (Dali::DaliException e) {
2787       {
2788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2789       };
2790     } catch (...) {
2791       {
2792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2793       };
2794     }
2795   }
2796
2797   jresult = new Dali::Layer((const Dali::Layer &)result);
2798   return jresult;
2799 }
2800
2801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_KeyEventSignal(void * jarg1) {
2802   void * jresult ;
2803   Dali::Window *arg1 = (Dali::Window *) 0 ;
2804   Dali::DevelWindow::KeyEventSignalType *result = 0 ;
2805
2806   arg1 = (Dali::Window *)jarg1;
2807   {
2808     try {
2809       result = (Dali::DevelWindow::KeyEventSignalType *) &(Dali::DevelWindow::KeyEventSignal(*arg1));
2810     } catch (std::out_of_range& e) {
2811       {
2812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2813       };
2814     } catch (std::exception& e) {
2815       {
2816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2817       };
2818     } catch (Dali::DaliException e) {
2819       {
2820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2821       };
2822     } catch (...) {
2823       {
2824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2825       };
2826     }
2827   }
2828
2829   jresult = (void *)result;
2830   return jresult;
2831 }
2832
2833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_TouchSignal(void * jarg1) {
2834   void * jresult ;
2835   Dali::Window *arg1 = (Dali::Window *) 0 ;
2836   Dali::DevelWindow::TouchSignalType *result = 0 ;
2837
2838   arg1 = (Dali::Window *)jarg1;
2839   {
2840     try {
2841       result = (Dali::DevelWindow::TouchSignalType *) &(Dali::DevelWindow::TouchSignal(*arg1));
2842     } catch (std::out_of_range& e) {
2843       {
2844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2845       };
2846     } catch (std::exception& e) {
2847       {
2848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2849       };
2850     } catch (Dali::DaliException e) {
2851       {
2852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2853       };
2854     } catch (...) {
2855       {
2856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2857       };
2858     }
2859   }
2860
2861   jresult = (void *)result;
2862   return jresult;
2863 }
2864
2865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetParent(void* jarg1, void* jarg2)
2866 {
2867   Dali::Window* window = (Dali::Window*)jarg1;
2868   if (!window) {
2869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2870     return ;
2871   }
2872
2873   Dali::Window* parent = (Dali::Window*)jarg2;
2874   if (!parent) {
2875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2876     return ;
2877   }
2878   {
2879     try {
2880       Dali::DevelWindow::SetParent(*window, *parent);
2881     } catch (std::out_of_range& e) {
2882       {
2883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2884       };
2885     } catch (std::exception& e) {
2886       {
2887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2888       };
2889     } catch (Dali::DaliException e) {
2890       {
2891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2892       };
2893     } catch (...) {
2894       {
2895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2896       };
2897     }
2898   }
2899
2900 }
2901
2902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Unparent(void* jarg1)
2903 {
2904   Dali::Window* window = (Dali::Window*)jarg1;
2905   if (!window) {
2906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2907     return ;
2908   }
2909   {
2910     try {
2911       Dali::DevelWindow::Unparent(*window);
2912     } catch (std::out_of_range& e) {
2913       {
2914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2915       };
2916     } catch (std::exception& e) {
2917       {
2918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2919       };
2920     } catch (Dali::DaliException e) {
2921       {
2922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2923       };
2924     } catch (...) {
2925       {
2926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2927       };
2928     }
2929   }
2930
2931 }
2932
2933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetParent(void* jarg1)
2934 {
2935   void * jresult ;
2936   Dali::Window* window = (Dali::Window*)jarg1;
2937   Dali::Window result;
2938   if (!window) {
2939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2940     return 0;
2941   }
2942   {
2943     try {
2944       result = Dali::DevelWindow::GetParent(*window);
2945     } catch (std::out_of_range& e) {
2946       {
2947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2948       };
2949     } catch (std::exception& e) {
2950       {
2951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2952       };
2953     } catch (Dali::DaliException e) {
2954       {
2955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2956       };
2957     } catch (...) {
2958       {
2959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2960       };
2961     }
2962   }
2963   jresult = new Dali::Window((const Dali::Window &)result);
2964   return jresult;
2965 }
2966
2967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_EventSignal(void * jarg1) {
2968   void * jresult ;
2969   Dali::Window *arg1 = (Dali::Window *) 0 ;
2970   Dali::DevelWindow::TransitionEffectEventSignalType *result = 0 ;
2971
2972   arg1 = (Dali::Window *)jarg1;
2973   {
2974     try {
2975       result = (Dali::DevelWindow::TransitionEffectEventSignalType *) &(Dali::DevelWindow::TransitionEffectEventSignal(*arg1));
2976     } catch (std::out_of_range& e) {
2977       {
2978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2979       };
2980     } catch (std::exception& e) {
2981       {
2982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2983       };
2984     } catch (Dali::DaliException e) {
2985       {
2986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2987       };
2988     } catch (...) {
2989       {
2990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2991       };
2992     }
2993   }
2994
2995   jresult = (void *)result;
2996   return jresult;
2997 }
2998
2999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Empty(void * jarg1) {
3000   unsigned int jresult ;
3001   Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *) 0 ;
3002   bool result;
3003
3004   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *)jarg1;
3005   {
3006     try {
3007       result = (bool)Dali_Signal_Window_Transition_Effect_Event_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > const *)arg1);
3008     } catch (std::out_of_range& e) {
3009       {
3010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3011       };
3012     } catch (std::exception& e) {
3013       {
3014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3015       };
3016     } catch (Dali::DaliException e) {
3017       {
3018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3019       };
3020     } catch (...) {
3021       {
3022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3023       };
3024     }
3025   }
3026
3027   jresult = result;
3028   return jresult;
3029 }
3030
3031
3032 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_GetConnectionCount(void * jarg1) {
3033   unsigned long jresult ;
3034   Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *) 0 ;
3035   std::size_t result;
3036
3037   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *)jarg1;
3038   {
3039     try {
3040       result = Dali_Signal_Window_Transition_Effect_Event_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > const *)arg1);
3041     } catch (std::out_of_range& e) {
3042       {
3043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3044       };
3045     } catch (std::exception& e) {
3046       {
3047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3048       };
3049     } catch (Dali::DaliException e) {
3050       {
3051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3052       };
3053     } catch (...) {
3054       {
3055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3056       };
3057     }
3058   }
3059
3060   jresult = (unsigned long)result;
3061   return jresult;
3062 }
3063
3064
3065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Connect(void * jarg1, void * jarg2) {
3066   Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *) 0 ;
3067   void (*arg2)(Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) = (void (*)(Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType)) 0 ;
3068
3069   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *)jarg1;
3070   arg2 = (void (*)(Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType))jarg2;
3071   {
3072     try {
3073     //DALI_LOG_ERROR("CSharp_Dali_Window_Transition_Effect_Event_Signal_Connect(arg1=0x%x, arg2=0x%x) \n", arg1, arg2);
3074       Dali_Signal_Window_Transition_Effect_Event_Signal_Connect(arg1,arg2);
3075     } catch (std::out_of_range& e) {
3076       {
3077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3078       };
3079     } catch (std::exception& e) {
3080       {
3081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3082       };
3083     } catch (Dali::DaliException e) {
3084       {
3085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3086       };
3087     } catch (...) {
3088       {
3089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3090       };
3091     }
3092   }
3093
3094 }
3095
3096
3097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Disconnect(void * jarg1, void * jarg2) {
3098   Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *) 0 ;
3099   void (*arg2)(Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) = (void (*)(Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType)) 0 ;
3100
3101   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *)jarg1;
3102   arg2 = (void (*)(Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType))jarg2;
3103   {
3104     try {
3105       Dali_Signal_Window_Transition_Effect_Event_Signal_Disconnect(arg1,arg2);
3106     } catch (std::out_of_range& e) {
3107       {
3108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3109       };
3110     } catch (std::exception& e) {
3111       {
3112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3113       };
3114     } catch (Dali::DaliException e) {
3115       {
3116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3117       };
3118     } catch (...) {
3119       {
3120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3121       };
3122     }
3123   }
3124
3125 }
3126
3127
3128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Emit(void * jarg1, void * jarg2, int jarg3, int jarg4) {
3129   Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *) 0 ;
3130   Dali::Window arg2 ;
3131   Dali::Window *argp2 ;
3132
3133   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *)jarg1;
3134   argp2 = (Dali::Window *)jarg2;
3135   if (!argp2) {
3136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
3137     return ;
3138   }
3139   arg2 = *argp2;
3140   {
3141     try {
3142       Dali_Signal_Window_Transition_Effect_Event_Signal_Emit(arg1,arg2, (Dali::DevelWindow::EffectState)jarg3, (Dali::DevelWindow::EffectType)jarg4);
3143     } catch (std::out_of_range& e) {
3144       {
3145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3146       };
3147     } catch (std::exception& e) {
3148       {
3149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3150       };
3151     } catch (Dali::DaliException e) {
3152       {
3153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3154       };
3155     } catch (...) {
3156       {
3157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3158       };
3159     }
3160   }
3161
3162 }
3163
3164
3165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_new() {
3166   void * jresult ;
3167   Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *result = 0 ;
3168
3169   {
3170     try {
3171       result = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *)new Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) >();
3172     } catch (std::out_of_range& e) {
3173       {
3174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3175       };
3176     } catch (std::exception& e) {
3177       {
3178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3179       };
3180     } catch (Dali::DaliException e) {
3181       {
3182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3183       };
3184     } catch (...) {
3185       {
3186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3187       };
3188     }
3189   }
3190
3191   jresult = (void *)result;
3192   return jresult;
3193 }
3194
3195
3196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_delete(void * jarg1) {
3197   Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *) 0 ;
3198
3199   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *)jarg1;
3200   {
3201     try {
3202       delete arg1;
3203     } catch (std::out_of_range& e) {
3204       {
3205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3206       };
3207     } catch (std::exception& e) {
3208       {
3209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3210       };
3211     } catch (Dali::DaliException e) {
3212       {
3213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3214       };
3215     } catch (...) {
3216       {
3217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3218       };
3219     }
3220   }
3221
3222 }
3223
3224 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal(void* jarg1) {
3225   Dali::Window* arg1 = (Dali::Window*) jarg1;
3226   Dali::DevelWindow::VisibilityChangedSignalType* result = 0;
3227
3228   {
3229     try {
3230       result = (Dali::DevelWindow::VisibilityChangedSignalType*) &( Dali::DevelWindow::VisibilityChangedSignal(*arg1) );
3231     }
3232     catch (std::out_of_range & e) {
3233       {
3234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3235       };
3236     }
3237     catch (std::exception & e) {
3238       {
3239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3240       };
3241     }
3242     catch (Dali::DaliException e) {
3243       {
3244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3245       };
3246     }
3247     catch (...) {
3248       {
3249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3250       };
3251     }
3252   }
3253   return (void*)result;
3254 }
3255
3256 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_Empty(void* jarg1) {
3257   bool result;
3258   Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType*) jarg1;
3259
3260   if (arg1 == nullptr) {
3261     DALI_LOG_ERROR("[ERR] arg1 == nullptr");
3262     return false;
3263   }
3264
3265   {
3266     try {
3267       result = arg1->Empty();
3268     }
3269     catch (std::out_of_range & e) {
3270       {
3271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
3272       };
3273     }
3274     catch (std::exception & e) {
3275       {
3276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
3277       };
3278     }
3279     catch (Dali::DaliException e) {
3280       {
3281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
3282       };
3283     }
3284     catch (...) {
3285       {
3286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
3287       };
3288     }
3289   }
3290   return result;
3291 }
3292
3293
3294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_GetConnectionCount(void* jarg1) {
3295   unsigned int result;
3296   Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType *) jarg1;
3297
3298   if (arg1 == nullptr) {
3299     DALI_LOG_ERROR("[ERR] arg1 == nullptr");
3300     return 0;
3301   }
3302
3303   {
3304     try {
3305       result = arg1->GetConnectionCount();
3306     }
3307     catch (std::out_of_range & e) {
3308       {
3309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3310       };
3311     }
3312     catch (std::exception & e) {
3313       {
3314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3315       };
3316     }
3317     catch (Dali::DaliException e) {
3318       {
3319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3320       };
3321     }
3322     catch (...) {
3323       {
3324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3325       };
3326     }
3327   }
3328   return result;
3329 }
3330
3331
3332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_Connect(void* jarg1, void* jarg2) {
3333   Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType *)jarg1;
3334   void (*arg2)(Dali::Window, bool) = ( void (*)(Dali::Window, bool) )jarg2;
3335
3336   if (arg1 == nullptr) {
3337     DALI_LOG_ERROR("[ERR] arg1 == nullptr");
3338     return ;
3339   }
3340
3341   {
3342     try {
3343       arg1->Connect(arg2);
3344     }
3345     catch (std::out_of_range & e) {
3346       {
3347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
3348       };
3349     }
3350     catch (std::exception & e) {
3351       {
3352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
3353       };
3354     }
3355     catch (Dali::DaliException e) {
3356       {
3357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
3358       };
3359     }
3360     catch (...) {
3361       {
3362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
3363       };
3364     }
3365   }
3366   return ;
3367 }
3368
3369
3370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_Disconnect(void* jarg1, void* jarg2) {
3371   Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType*)jarg1;
3372   void (*arg2)(Dali::Window, bool) = (void (*)(Dali::Window, bool))jarg2;
3373
3374   if (arg1 == nullptr) {
3375     DALI_LOG_ERROR("[ERR] arg1 == nullptr");
3376     return;
3377   }
3378
3379   {
3380     try {
3381       arg1->Disconnect(arg2);
3382     }
3383     catch (std::out_of_range & e) {
3384       {
3385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
3386       };
3387     }
3388     catch (std::exception & e) {
3389       {
3390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
3391       };
3392     }
3393     catch (Dali::DaliException e) {
3394       {
3395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
3396       };
3397     }
3398     catch (...) {
3399       {
3400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
3401       };
3402     }
3403   }
3404   return;
3405 }
3406
3407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_Emit(void* jarg1, void* jarg2, bool jarg3) {
3408   Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType*)jarg1;
3409   Dali::Window* arg2 = (Dali::Window*)jarg2;
3410   bool arg3 = jarg3;
3411
3412   if (arg1 == nullptr || arg2 == nullptr) {
3413     DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr");
3414     return;
3415   }
3416
3417   {
3418     try {
3419       arg1->Emit(*arg2, arg3);
3420     }
3421     catch (std::out_of_range & e) {
3422       {
3423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
3424       };
3425     }
3426     catch (std::exception & e) {
3427       {
3428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
3429       };
3430     }
3431     catch (Dali::DaliException e) {
3432       {
3433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
3434       };
3435     }
3436     catch (...) {
3437       {
3438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
3439       };
3440     }
3441   }
3442   return;
3443 }
3444
3445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_delete(void* jarg1) {
3446   Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType*)jarg1;
3447
3448   {
3449     try {
3450       delete arg1;
3451     }
3452     catch (std::out_of_range & e) {
3453       {
3454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
3455       };
3456     }
3457     catch (std::exception & e) {
3458       {
3459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
3460       };
3461     }
3462     catch (Dali::DaliException e) {
3463       {
3464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
3465       };
3466     }
3467     catch (...) {
3468       {
3469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
3470       };
3471     }
3472   }
3473   return;
3474 }
3475
3476 #ifdef __cplusplus
3477 }
3478 #endif
3479