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
  26 #include <dali-toolkit/devel-api/controls/control-devel.h>
  27
  28 /* Callback for returning strings to C# without leaking memory */
  29 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
  30 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
  31
  32
  33
  34 SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (bool) > const *self){
  35   return self->Empty();
  36 }
  37 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (bool) > const *self){
  38 return self->GetConnectionCount();
  39 }
  40 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
  41   self->Connect( func );
  42 }
  43 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
  44   self->Disconnect( func );
  45 }
  46 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (bool) > *self,bool arg){
  47   self->Emit( arg );
  48 }
  49
  50 /*ResizedSignal*/
  51 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Empty(Dali::Signal< void (Dali::Window::WindowSize) > const *self){
  52   return self->Empty();
  53 }
  54 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Window::WindowSize) > const *self){
  55 return self->GetConnectionCount();
  56 }
  57 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Connect(Dali::Signal< void (Dali::Window::WindowSize) > *self,void (*func)(Dali::Window::WindowSize)){
  58   self->Connect( func );
  59 }
  60 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Disconnect(Dali::Signal< void (Dali::Window::WindowSize) > *self,void (*func)(Dali::Window::WindowSize)){
  61   self->Disconnect( func );
  62 }
  63 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Emit(Dali::Signal< void (Dali::Window::WindowSize) > *self,Dali::Window::WindowSize arg){
  64   self->Emit( arg );
  65 }
  66
  67 //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_GetNativeHandle(void * jarg1) {
 824   void * jresult ;
 825   Dali::Window *arg1 = (Dali::Window *) 0 ;
 826   Dali::Any result;
 827
 828   arg1 = (Dali::Window *)jarg1;
 829   {
 830     try {
 831       result = ((Dali::Window const *)arg1)->GetNativeHandle();
 832     } catch (std::out_of_range& e) {
 833       {
 834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 835       };
 836     } catch (std::exception& e) {
 837       {
 838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 839       };
 840     } catch (Dali::DaliException e) {
 841       {
 842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 843       };
 844     } catch (...) {
 845       {
 846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 847       };
 848     }
 849   }
 850
 851   jresult = new Dali::Any((const Dali::Any &)result);
 852   return jresult;
 853 }
 854
 855 /*window-devel binding*/
 856
 857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
 858   void * jresult ;
 859   Dali::Window arg1 ;
 860   Dali::Window *argp1 ;
 861   Dali::Window::FocusSignalType *result = 0 ;
 862
 863   argp1 = (Dali::Window *)jarg1;
 864   if (!argp1) {
 865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 866     return 0;
 867   }
 868   arg1 = *argp1;
 869   {
 870     try {
 871       result = (Dali::Window::FocusSignalType*)&arg1.FocusChangedSignal();
 872     } catch (std::out_of_range& e) {
 873       {
 874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 875       };
 876     } catch (std::exception& e) {
 877       {
 878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 879       };
 880     } catch (Dali::DaliException e) {
 881       {
 882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 883       };
 884     } catch (...) {
 885       {
 886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 887       };
 888     }
 889   }
 890
 891   jresult = (void *)result;
 892   return jresult;
 893 }
 894
 895
 896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
 897   Dali::Window arg1 ;
 898   bool arg2 ;
 899   Dali::Window *argp1 ;
 900
 901   argp1 = (Dali::Window *)jarg1;
 902   if (!argp1) {
 903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 904     return ;
 905   }
 906   arg1 = *argp1;
 907   arg2 = jarg2 ? true : false;
 908   {
 909     try {
 910       arg1.SetAcceptFocus(arg2);
 911     } catch (std::out_of_range& e) {
 912       {
 913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 914       };
 915     } catch (std::exception& e) {
 916       {
 917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 918       };
 919     } catch (Dali::DaliException e) {
 920       {
 921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 922       };
 923     } catch (...) {
 924       {
 925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 926       };
 927     }
 928   }
 929
 930 }
 931
 932
 933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
 934   unsigned int jresult ;
 935   Dali::Window arg1 ;
 936   Dali::Window *argp1 ;
 937   bool result;
 938
 939   argp1 = (Dali::Window *)jarg1;
 940   if (!argp1) {
 941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 942     return 0;
 943   }
 944   arg1 = *argp1;
 945   {
 946     try {
 947       result = (bool)arg1.IsFocusAcceptable();
 948     } catch (std::out_of_range& e) {
 949       {
 950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 951       };
 952     } catch (std::exception& e) {
 953       {
 954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 955       };
 956     } catch (Dali::DaliException e) {
 957       {
 958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
 959       };
 960     } catch (...) {
 961       {
 962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 963       };
 964     }
 965   }
 966
 967   jresult = result;
 968   return jresult;
 969 }
 970
 971
 972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
 973   Dali::Window arg1 ;
 974   Dali::Window *argp1 ;
 975
 976   argp1 = (Dali::Window *)jarg1;
 977   if (!argp1) {
 978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 979     return ;
 980   }
 981   arg1 = *argp1;
 982   {
 983     try {
 984       arg1.Show();
 985     } catch (std::out_of_range& e) {
 986       {
 987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 988       };
 989     } catch (std::exception& e) {
 990       {
 991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 992       };
 993     } catch (Dali::DaliException e) {
 994       {
 995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
 996       };
 997     } catch (...) {
 998       {
 999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1000       };
1001     }
1002   }
1003
1004 }
1005
1006
1007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
1008   Dali::Window arg1 ;
1009   Dali::Window *argp1 ;
1010
1011   argp1 = (Dali::Window *)jarg1;
1012   if (!argp1) {
1013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1014     return ;
1015   }
1016   arg1 = *argp1;
1017   {
1018     try {
1019       arg1.Hide();
1020     } catch (std::out_of_range& e) {
1021       {
1022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1023       };
1024     } catch (std::exception& e) {
1025       {
1026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1027       };
1028     } catch (Dali::DaliException e) {
1029       {
1030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1031       };
1032     } catch (...) {
1033       {
1034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1035       };
1036     }
1037   }
1038
1039 }
1040
1041
1042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
1043   unsigned int jresult ;
1044   Dali::Window arg1 ;
1045   Dali::Window *argp1 ;
1046   bool result;
1047
1048   argp1 = (Dali::Window *)jarg1;
1049   if (!argp1) {
1050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1051     return 0;
1052   }
1053   arg1 = *argp1;
1054   {
1055     try {
1056       result = (bool)arg1.IsVisible();
1057     } catch (std::out_of_range& e) {
1058       {
1059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1060       };
1061     } catch (std::exception& e) {
1062       {
1063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1064       };
1065     } catch (Dali::DaliException e) {
1066       {
1067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1068       };
1069     } catch (...) {
1070       {
1071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1072       };
1073     }
1074   }
1075
1076   jresult = result;
1077   return jresult;
1078 }
1079
1080
1081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHintCount(void * jarg1) {
1082   unsigned int jresult ;
1083   Dali::Window arg1 ;
1084   Dali::Window *argp1 ;
1085   unsigned int result;
1086
1087   argp1 = (Dali::Window *)jarg1;
1088   if (!argp1) {
1089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1090     return 0;
1091   }
1092   arg1 = *argp1;
1093   {
1094     try {
1095       result = (unsigned int)arg1.GetSupportedAuxiliaryHintCount();
1096     } catch (std::out_of_range& e) {
1097       {
1098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1099       };
1100     } catch (std::exception& e) {
1101       {
1102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1103       };
1104     } catch (Dali::DaliException e) {
1105       {
1106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1107       };
1108     } catch (...) {
1109       {
1110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1111       };
1112     }
1113   }
1114
1115   jresult = result;
1116   return jresult;
1117 }
1118
1119
1120 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHint(void * jarg1, unsigned int jarg2) {
1121   char * jresult ;
1122   Dali::Window arg1 ;
1123   unsigned int arg2 ;
1124   Dali::Window *argp1 ;
1125   std::string result;
1126
1127   argp1 = (Dali::Window *)jarg1;
1128   if (!argp1) {
1129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1130     return 0;
1131   }
1132   arg1 = *argp1;
1133   arg2 = (unsigned int)jarg2;
1134   {
1135     try {
1136       result = arg1.GetSupportedAuxiliaryHint(arg2);
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 = SWIG_csharp_string_callback((&result)->c_str());
1157   return jresult;
1158 }
1159
1160
1161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AddAuxiliaryHint(void * jarg1, char * jarg2, char * jarg3) {
1162   unsigned int jresult ;
1163   Dali::Window arg1 ;
1164   std::string *arg2 = 0 ;
1165   std::string *arg3 = 0 ;
1166   Dali::Window *argp1 ;
1167   unsigned int result;
1168
1169   argp1 = (Dali::Window *)jarg1;
1170   if (!argp1) {
1171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1172     return 0;
1173   }
1174   arg1 = *argp1;
1175   if (!jarg2) {
1176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1177     return 0;
1178   }
1179   std::string arg2_str(jarg2);
1180   arg2 = &arg2_str;
1181   if (!jarg3) {
1182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1183     return 0;
1184   }
1185   std::string arg3_str(jarg3);
1186   arg3 = &arg3_str;
1187   {
1188     try {
1189       result = (unsigned int)arg1.AddAuxiliaryHint((std::string const &)*arg2,(std::string const &)*arg3);
1190     } catch (std::out_of_range& e) {
1191       {
1192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1193       };
1194     } catch (std::exception& e) {
1195       {
1196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1197       };
1198     } catch (Dali::DaliException e) {
1199       {
1200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1201       };
1202     } catch (...) {
1203       {
1204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1205       };
1206     }
1207   }
1208
1209   jresult = result;
1210
1211   return jresult;
1212 }
1213
1214
1215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RemoveAuxiliaryHint(void * jarg1, unsigned int jarg2) {
1216   unsigned int jresult ;
1217   Dali::Window arg1 ;
1218   unsigned int arg2 ;
1219   Dali::Window *argp1 ;
1220   bool result;
1221
1222   argp1 = (Dali::Window *)jarg1;
1223   if (!argp1) {
1224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1225     return 0;
1226   }
1227   arg1 = *argp1;
1228   arg2 = (unsigned int)jarg2;
1229   {
1230     try {
1231       result = (bool)arg1.RemoveAuxiliaryHint(arg2);
1232     } catch (std::out_of_range& e) {
1233       {
1234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1235       };
1236     } catch (std::exception& e) {
1237       {
1238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1239       };
1240     } catch (Dali::DaliException e) {
1241       {
1242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1243       };
1244     } catch (...) {
1245       {
1246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1247       };
1248     }
1249   }
1250
1251   jresult = result;
1252   return jresult;
1253 }
1254
1255
1256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetAuxiliaryHintValue(void * jarg1, unsigned int jarg2, char * jarg3) {
1257   unsigned int jresult ;
1258   Dali::Window arg1 ;
1259   unsigned int arg2 ;
1260   std::string *arg3 = 0 ;
1261   Dali::Window *argp1 ;
1262   bool result;
1263
1264   argp1 = (Dali::Window *)jarg1;
1265   if (!argp1) {
1266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1267     return 0;
1268   }
1269   arg1 = *argp1;
1270   arg2 = (unsigned int)jarg2;
1271   if (!jarg3) {
1272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1273     return 0;
1274   }
1275   std::string arg3_str(jarg3);
1276   arg3 = &arg3_str;
1277   {
1278     try {
1279       result = (bool)arg1.SetAuxiliaryHintValue(arg2,(std::string const &)*arg3);
1280     } catch (std::out_of_range& e) {
1281       {
1282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1283       };
1284     } catch (std::exception& e) {
1285       {
1286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1287       };
1288     } catch (Dali::DaliException e) {
1289       {
1290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1291       };
1292     } catch (...) {
1293       {
1294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1295       };
1296     }
1297   }
1298
1299   jresult = result;
1300
1301   //argout typemap for const std::string&
1302
1303   return jresult;
1304 }
1305
1306
1307 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintValue(void * jarg1, unsigned int jarg2) {
1308   char * jresult ;
1309   Dali::Window arg1 ;
1310   unsigned int arg2 ;
1311   Dali::Window *argp1 ;
1312   std::string result;
1313
1314   argp1 = (Dali::Window *)jarg1;
1315   if (!argp1) {
1316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1317     return 0;
1318   }
1319   arg1 = *argp1;
1320   arg2 = (unsigned int)jarg2;
1321   {
1322     try {
1323       result = arg1.GetAuxiliaryHintValue(arg2);
1324     } catch (std::out_of_range& e) {
1325       {
1326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1327       };
1328     } catch (std::exception& e) {
1329       {
1330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1331       };
1332     } catch (Dali::DaliException e) {
1333       {
1334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1335       };
1336     } catch (...) {
1337       {
1338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1339       };
1340     }
1341   }
1342
1343   jresult = SWIG_csharp_string_callback((&result)->c_str());
1344   return jresult;
1345 }
1346
1347
1348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintId(void * jarg1, char * jarg2) {
1349   unsigned int jresult ;
1350   Dali::Window arg1 ;
1351   std::string *arg2 = 0 ;
1352   Dali::Window *argp1 ;
1353   unsigned int 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   if (!jarg2) {
1362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1363     return 0;
1364   }
1365   std::string arg2_str(jarg2);
1366   arg2 = &arg2_str;
1367   {
1368     try {
1369       result = (unsigned int)arg1.GetAuxiliaryHintId((std::string const &)*arg2);
1370     } catch (std::out_of_range& e) {
1371       {
1372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1373       };
1374     } catch (std::exception& e) {
1375       {
1376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1377       };
1378     } catch (Dali::DaliException e) {
1379       {
1380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1381       };
1382     } catch (...) {
1383       {
1384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1385       };
1386     }
1387   }
1388
1389   jresult = result;
1390
1391   //argout typemap for const std::string&
1392
1393   return jresult;
1394 }
1395
1396
1397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetInputRegion(void * jarg1, void * jarg2) {
1398   Dali::Window arg1 ;
1399   Dali::Rect< int > *arg2 = 0 ;
1400   Dali::Window *argp1 ;
1401
1402   argp1 = (Dali::Window *)jarg1;
1403   if (!argp1) {
1404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1405     return ;
1406   }
1407   arg1 = *argp1;
1408   arg2 = (Dali::Rect< int > *)jarg2;
1409   if (!arg2) {
1410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
1411     return ;
1412   }
1413   {
1414     try {
1415       arg1.SetInputRegion((Dali::Rect< int > const &)*arg2);
1416     } catch (std::out_of_range& e) {
1417       {
1418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1419       };
1420     } catch (std::exception& e) {
1421       {
1422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1423       };
1424     } catch (Dali::DaliException e) {
1425       {
1426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1427       };
1428     } catch (...) {
1429       {
1430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1431       };
1432     }
1433   }
1434
1435 }
1436
1437
1438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetType(void * jarg1, int jarg2) {
1439   Dali::Window arg1 ;
1440   Dali::Window::Type arg2 ;
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::Window::Type)jarg2;
1450   {
1451     try {
1452       arg1.SetType(arg2);
1453     } catch (std::out_of_range& e) {
1454       {
1455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1456       };
1457     } catch (std::exception& e) {
1458       {
1459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1460       };
1461     } catch (Dali::DaliException e) {
1462       {
1463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1464       };
1465     } catch (...) {
1466       {
1467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1468       };
1469     }
1470   }
1471
1472 }
1473
1474
1475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetType(void * jarg1) {
1476   int jresult ;
1477   Dali::Window arg1 ;
1478   Dali::Window *argp1 ;
1479   Dali::Window::Type result;
1480
1481   argp1 = (Dali::Window *)jarg1;
1482   if (!argp1) {
1483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1484     return 0;
1485   }
1486   arg1 = *argp1;
1487   {
1488     try {
1489       result = (Dali::Window::Type)arg1.GetType();
1490     } catch (std::out_of_range& e) {
1491       {
1492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1493       };
1494     } catch (std::exception& e) {
1495       {
1496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1497       };
1498     } catch (Dali::DaliException e) {
1499       {
1500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1501       };
1502     } catch (...) {
1503       {
1504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1505       };
1506     }
1507   }
1508
1509   jresult = (int)result;
1510   return jresult;
1511 }
1512
1513
1514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetNotificationLevel(void * jarg1, int jarg2) {
1515   unsigned int jresult ;
1516   Dali::Window arg1 ;
1517   Dali::Window::NotificationLevel::Type arg2 ;
1518   Dali::Window *argp1 ;
1519   bool result;
1520
1521   argp1 = (Dali::Window *)jarg1;
1522   if (!argp1) {
1523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1524     return 0;
1525   }
1526   arg1 = *argp1;
1527   arg2 = (Dali::Window::NotificationLevel::Type)jarg2;
1528   {
1529     try {
1530       result = (bool)arg1.SetNotificationLevel(arg2);
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 = result;
1551   return jresult;
1552 }
1553
1554
1555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetNotificationLevel(void * jarg1) {
1556   int jresult ;
1557   Dali::Window arg1 ;
1558   Dali::Window *argp1 ;
1559   Dali::Window::NotificationLevel::Type result;
1560
1561   argp1 = (Dali::Window *)jarg1;
1562   if (!argp1) {
1563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1564     return 0;
1565   }
1566   arg1 = *argp1;
1567   {
1568     try {
1569       result = (Dali::Window::NotificationLevel::Type)arg1.GetNotificationLevel();
1570     } catch (std::out_of_range& e) {
1571       {
1572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1573       };
1574     } catch (std::exception& e) {
1575       {
1576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1577       };
1578     } catch (Dali::DaliException e) {
1579       {
1580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1581       };
1582     } catch (...) {
1583       {
1584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1585       };
1586     }
1587   }
1588
1589   jresult = (int)result;
1590   return jresult;
1591 }
1592
1593
1594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetOpaqueState(void * jarg1, unsigned int jarg2) {
1595   Dali::Window arg1 ;
1596   bool arg2 ;
1597   Dali::Window *argp1 ;
1598
1599   argp1 = (Dali::Window *)jarg1;
1600   if (!argp1) {
1601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1602     return ;
1603   }
1604   arg1 = *argp1;
1605   arg2 = jarg2 ? true : false;
1606   {
1607     try {
1608       arg1.SetOpaqueState(arg2);
1609     } catch (std::out_of_range& e) {
1610       {
1611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1612       };
1613     } catch (std::exception& e) {
1614       {
1615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1616       };
1617     } catch (Dali::DaliException e) {
1618       {
1619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1620       };
1621     } catch (...) {
1622       {
1623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1624       };
1625     }
1626   }
1627
1628 }
1629
1630
1631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsOpaqueState(void * jarg1) {
1632   unsigned int jresult ;
1633   Dali::Window arg1 ;
1634   Dali::Window *argp1 ;
1635   bool result;
1636
1637   argp1 = (Dali::Window *)jarg1;
1638   if (!argp1) {
1639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1640     return 0;
1641   }
1642   arg1 = *argp1;
1643   {
1644     try {
1645       result = (bool)arg1.IsOpaqueState();
1646     } catch (std::out_of_range& e) {
1647       {
1648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1649       };
1650     } catch (std::exception& e) {
1651       {
1652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1653       };
1654     } catch (Dali::DaliException e) {
1655       {
1656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1657       };
1658     } catch (...) {
1659       {
1660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1661       };
1662     }
1663   }
1664
1665   jresult = result;
1666   return jresult;
1667 }
1668
1669
1670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetScreenOffMode(void * jarg1, int jarg2) {
1671   unsigned int jresult ;
1672   Dali::Window arg1 ;
1673   Dali::Window::ScreenOffMode::Type arg2 ;
1674   Dali::Window *argp1 ;
1675   bool result;
1676
1677   argp1 = (Dali::Window *)jarg1;
1678   if (!argp1) {
1679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1680     return 0;
1681   }
1682   arg1 = *argp1;
1683   arg2 = (Dali::Window::ScreenOffMode::Type)jarg2;
1684   {
1685     try {
1686       result = (bool)arg1.SetScreenOffMode(arg2);
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 int SWIGSTDCALL CSharp_Dali_GetScreenOffMode(void * jarg1) {
1712   int jresult ;
1713   Dali::Window arg1 ;
1714   Dali::Window *argp1 ;
1715   Dali::Window::ScreenOffMode::Type result;
1716
1717   argp1 = (Dali::Window *)jarg1;
1718   if (!argp1) {
1719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1720     return 0;
1721   }
1722   arg1 = *argp1;
1723   {
1724     try {
1725       result = (Dali::Window::ScreenOffMode::Type)arg1.GetScreenOffMode();
1726     } catch (std::out_of_range& e) {
1727       {
1728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1729       };
1730     } catch (std::exception& e) {
1731       {
1732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1733       };
1734     } catch (Dali::DaliException e) {
1735       {
1736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1737       };
1738     } catch (...) {
1739       {
1740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1741       };
1742     }
1743   }
1744
1745   jresult = (int)result;
1746   return jresult;
1747 }
1748
1749
1750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetBrightness(void * jarg1, int jarg2) {
1751   unsigned int jresult ;
1752   Dali::Window arg1 ;
1753   int arg2 ;
1754   Dali::Window *argp1 ;
1755   bool result;
1756
1757   argp1 = (Dali::Window *)jarg1;
1758   if (!argp1) {
1759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1760     return 0;
1761   }
1762   arg1 = *argp1;
1763   arg2 = (int)jarg2;
1764   {
1765     try {
1766       result = (bool)arg1.SetBrightness(arg2);
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 = result;
1787   return jresult;
1788 }
1789
1790
1791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetBrightness(void * jarg1) {
1792   int jresult ;
1793   Dali::Window arg1 ;
1794   Dali::Window *argp1 ;
1795   int result;
1796
1797   argp1 = (Dali::Window *)jarg1;
1798   if (!argp1) {
1799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1800     return 0;
1801   }
1802   arg1 = *argp1;
1803   {
1804     try {
1805       result = (int)arg1.GetBrightness();
1806     } catch (std::out_of_range& e) {
1807       {
1808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1809       };
1810     } catch (std::exception& e) {
1811       {
1812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1813       };
1814     } catch (Dali::DaliException e) {
1815       {
1816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1817       };
1818     } catch (...) {
1819       {
1820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1821       };
1822     }
1823   }
1824
1825   jresult = result;
1826   return jresult;
1827 }
1828
1829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
1830   unsigned int jresult ;
1831   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1832   bool result;
1833
1834   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1835   {
1836     try {
1837       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
1838     } catch (std::out_of_range& e) {
1839       {
1840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1841       };
1842     } catch (std::exception& e) {
1843       {
1844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1845       };
1846     } catch (Dali::DaliException e) {
1847       {
1848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1849       };
1850     } catch (...) {
1851       {
1852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1853       };
1854     }
1855   }
1856
1857   jresult = result;
1858   return jresult;
1859 }
1860
1861
1862 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
1863   unsigned long jresult ;
1864   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1865   std::size_t result;
1866
1867   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1868   {
1869     try {
1870       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
1871     } catch (std::out_of_range& e) {
1872       {
1873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1874       };
1875     } catch (std::exception& e) {
1876       {
1877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1878       };
1879     } catch (Dali::DaliException e) {
1880       {
1881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1882       };
1883     } catch (...) {
1884       {
1885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1886       };
1887     }
1888   }
1889
1890   jresult = (unsigned long)result;
1891   return jresult;
1892 }
1893
1894
1895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
1896   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1897   void (*arg2)(bool) = (void (*)(bool)) 0 ;
1898
1899   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1900   arg2 = (void (*)(bool))jarg2;
1901   {
1902     try {
1903       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
1904     } catch (std::out_of_range& e) {
1905       {
1906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1907       };
1908     } catch (std::exception& e) {
1909       {
1910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1911       };
1912     } catch (Dali::DaliException e) {
1913       {
1914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1915       };
1916     } catch (...) {
1917       {
1918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1919       };
1920     }
1921   }
1922
1923 }
1924
1925
1926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
1927   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1928   void (*arg2)(bool) = (void (*)(bool)) 0 ;
1929
1930   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1931   arg2 = (void (*)(bool))jarg2;
1932   {
1933     try {
1934       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
1935     } catch (std::out_of_range& e) {
1936       {
1937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1938       };
1939     } catch (std::exception& e) {
1940       {
1941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1942       };
1943     } catch (Dali::DaliException e) {
1944       {
1945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1946       };
1947     } catch (...) {
1948       {
1949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1950       };
1951     }
1952   }
1953
1954 }
1955
1956
1957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
1958   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
1959   bool arg2 ;
1960
1961   arg1 = (Dali::Signal< void (bool) > *)jarg1;
1962   arg2 = jarg2 ? true : false;
1963   {
1964     try {
1965       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
1966     } catch (std::out_of_range& e) {
1967       {
1968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1969       };
1970     } catch (std::exception& e) {
1971       {
1972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1973       };
1974     } catch (Dali::DaliException e) {
1975       {
1976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
1977       };
1978     } catch (...) {
1979       {
1980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1981       };
1982     }
1983   }
1984
1985 }
1986
1987
1988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
1989   void * jresult ;
1990   Dali::Signal< void (bool) > *result = 0 ;
1991
1992   {
1993     try {
1994       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
1995     } catch (std::out_of_range& e) {
1996       {
1997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1998       };
1999     } catch (std::exception& e) {
2000       {
2001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2002       };
2003     } catch (Dali::DaliException e) {
2004       {
2005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2006       };
2007     } catch (...) {
2008       {
2009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2010       };
2011     }
2012   }
2013
2014   jresult = (void *)result;
2015   return jresult;
2016 }
2017
2018
2019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
2020   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
2021
2022   arg1 = (Dali::Signal< void (bool) > *)jarg1;
2023   {
2024     try {
2025       delete arg1;
2026     } catch (std::out_of_range& e) {
2027       {
2028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2029       };
2030     } catch (std::exception& e) {
2031       {
2032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2033       };
2034     } catch (Dali::DaliException e) {
2035       {
2036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2037       };
2038     } catch (...) {
2039       {
2040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2041       };
2042     }
2043   }
2044
2045 }
2046
2047
2048
2049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_ResizedSignal(void * jarg1) {
2050   void * jresult ;
2051   Dali::Window arg1 ;
2052   Dali::Window *argp1 ;
2053   Dali::Window::ResizedSignalType *result = 0 ;
2054
2055   argp1 = (Dali::Window *)jarg1;
2056   if (!argp1) {
2057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2058     return 0;
2059   }
2060   arg1 = *argp1;
2061   {
2062     try {
2063       result = (Dali::Window::ResizedSignalType *) &arg1.ResizedSignal();
2064     } catch (std::out_of_range& e) {
2065       {
2066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2067       };
2068     } catch (std::exception& e) {
2069       {
2070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2071       };
2072     } catch (Dali::DaliException e) {
2073       {
2074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2075       };
2076     } catch (...) {
2077       {
2078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2079       };
2080     }
2081   }
2082
2083   jresult = (void *)result;
2084   return jresult;
2085 }
2086
2087 /*ResizedSignal binding*/
2088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResizedSignal_Empty(void * jarg1) {
2089   unsigned int jresult ;
2090   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2091   bool result;
2092
2093   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2094   {
2095     try {
2096       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Empty((Dali::Signal< void (Dali::Window::WindowSize) > const *)arg1);
2097     } catch (std::out_of_range& e) {
2098       {
2099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2100       };
2101     } catch (std::exception& e) {
2102       {
2103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2104       };
2105     } catch (Dali::DaliException e) {
2106       {
2107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2108       };
2109     } catch (...) {
2110       {
2111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2112       };
2113     }
2114   }
2115
2116   jresult = result;
2117   return jresult;
2118 }
2119
2120
2121 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResizedSignal_GetConnectionCount(void * jarg1) {
2122   unsigned long jresult ;
2123   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2124   std::size_t result;
2125
2126   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2127   {
2128     try {
2129       result = Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Window::WindowSize) > const *)arg1);
2130     } catch (std::out_of_range& e) {
2131       {
2132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2133       };
2134     } catch (std::exception& e) {
2135       {
2136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2137       };
2138     } catch (Dali::DaliException e) {
2139       {
2140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2141       };
2142     } catch (...) {
2143       {
2144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2145       };
2146     }
2147   }
2148
2149   jresult = (unsigned long)result;
2150   return jresult;
2151 }
2152
2153
2154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizedSignal_Connect(void * jarg1, void * jarg2) {
2155   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2156   void (*arg2)(Dali::Window::WindowSize) = (void (*)(Dali::Window::WindowSize)) 0 ;
2157
2158   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2159   arg2 = (void (*)(Dali::Window::WindowSize))jarg2;
2160   {
2161     try {
2162       Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Connect(arg1,arg2);
2163     } catch (std::out_of_range& e) {
2164       {
2165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2166       };
2167     } catch (std::exception& e) {
2168       {
2169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2170       };
2171     } catch (Dali::DaliException e) {
2172       {
2173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2174       };
2175     } catch (...) {
2176       {
2177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2178       };
2179     }
2180   }
2181
2182 }
2183
2184
2185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizedSignal_Disconnect(void * jarg1, void * jarg2) {
2186   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2187   void (*arg2)(Dali::Window::WindowSize) = (void (*)(Dali::Window::WindowSize)) 0 ;
2188
2189   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2190   arg2 = (void (*)(Dali::Window::WindowSize))jarg2;
2191   {
2192     try {
2193       Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Disconnect(arg1,arg2);
2194     } catch (std::out_of_range& e) {
2195       {
2196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2197       };
2198     } catch (std::exception& e) {
2199       {
2200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2201       };
2202     } catch (Dali::DaliException e) {
2203       {
2204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2205       };
2206     } catch (...) {
2207       {
2208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2209       };
2210     }
2211   }
2212
2213 }
2214
2215
2216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizedSignal_Emit(void * jarg1, void * jarg2) {
2217   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2218   Dali::Window::WindowSize arg2 ;
2219   Dali::Window::WindowSize *argp2 ;
2220
2221   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2222   argp2 = (Dali::Window::WindowSize *)jarg2;
2223   if (!argp2) {
2224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0);
2225     return ;
2226   }
2227   arg2 = *argp2;
2228   {
2229     try {
2230       Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Emit(arg1,arg2);
2231     } catch (std::out_of_range& e) {
2232       {
2233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2234       };
2235     } catch (std::exception& e) {
2236       {
2237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2238       };
2239     } catch (Dali::DaliException e) {
2240       {
2241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2242       };
2243     } catch (...) {
2244       {
2245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2246       };
2247     }
2248   }
2249
2250 }
2251
2252
2253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResizedSignal() {
2254   void * jresult ;
2255   Dali::Signal< void (Dali::Window::WindowSize) > *result = 0 ;
2256
2257   {
2258     try {
2259       result = (Dali::Signal< void (Dali::Window::WindowSize) > *)new Dali::Signal< void (Dali::Window::WindowSize) >();
2260     } catch (std::out_of_range& e) {
2261       {
2262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2263       };
2264     } catch (std::exception& e) {
2265       {
2266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2267       };
2268     } catch (Dali::DaliException e) {
2269       {
2270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2271       };
2272     } catch (...) {
2273       {
2274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2275       };
2276     }
2277   }
2278
2279   jresult = (void *)result;
2280   return jresult;
2281 }
2282
2283
2284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResizedSignal(void * jarg1) {
2285   Dali::Signal< void (Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *) 0 ;
2286
2287   arg1 = (Dali::Signal< void (Dali::Window::WindowSize) > *)jarg1;
2288   {
2289     try {
2290       delete arg1;
2291     } catch (std::out_of_range& e) {
2292       {
2293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2294       };
2295     } catch (std::exception& e) {
2296       {
2297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2298       };
2299     } catch (Dali::DaliException e) {
2300       {
2301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2302       };
2303     } catch (...) {
2304       {
2305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2306       };
2307     }
2308   }
2309
2310 }
2311
2312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetSize(void * jarg1, void * jarg2) {
2313   Dali::Window arg1 ;
2314   Dali::Window::WindowSize arg2 ;
2315   Dali::Window *argp1 ;
2316   Dali::Window::WindowSize *argp2 ;
2317
2318   argp1 = (Dali::Window *)jarg1;
2319   if (!argp1) {
2320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2321     return ;
2322   }
2323   arg1 = *argp1;
2324   argp2 = (Dali::Window::WindowSize *)jarg2;
2325   if (!argp2) {
2326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0);
2327     return ;
2328   }
2329   arg2 = *argp2;
2330   {
2331     try {
2332       arg1.SetSize(arg2);
2333     } catch (std::out_of_range& e) {
2334       {
2335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2336       };
2337     } catch (std::exception& e) {
2338       {
2339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2340       };
2341     } catch (Dali::DaliException e) {
2342       {
2343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2344       };
2345     } catch (...) {
2346       {
2347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2348       };
2349     }
2350   }
2351
2352 }
2353
2354
2355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetSize(void * jarg1) {
2356   void * jresult ;
2357   Dali::Window arg1 ;
2358   Dali::Window *argp1 ;
2359   Dali::Window::WindowSize result;
2360
2361   argp1 = (Dali::Window *)jarg1;
2362   if (!argp1) {
2363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2364     return 0;
2365   }
2366   arg1 = *argp1;
2367   {
2368     try {
2369       result = arg1.GetSize();
2370     } catch (std::out_of_range& e) {
2371       {
2372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2373       };
2374     } catch (std::exception& e) {
2375       {
2376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2377       };
2378     } catch (Dali::DaliException e) {
2379       {
2380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2381       };
2382     } catch (...) {
2383       {
2384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2385       };
2386     }
2387   }
2388
2389   jresult = new Dali::Window::WindowSize((const Dali::Window::WindowSize &)result);
2390   return jresult;
2391 }
2392
2393
2394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPosition(void * jarg1, void * jarg2) {
2395   Dali::Window arg1 ;
2396   Dali::Window::WindowPosition arg2 ;
2397   Dali::Window *argp1 ;
2398   Dali::Window::WindowPosition *argp2 ;
2399
2400   argp1 = (Dali::Window *)jarg1;
2401   if (!argp1) {
2402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2403     return ;
2404   }
2405   arg1 = *argp1;
2406   argp2 = (Dali::Window::WindowPosition *)jarg2;
2407   if (!argp2) {
2408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowPosition", 0);
2409     return ;
2410   }
2411   arg2 = *argp2;
2412   {
2413     try {
2414       arg1.SetPosition(arg2);
2415     } catch (std::out_of_range& e) {
2416       {
2417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2418       };
2419     } catch (std::exception& e) {
2420       {
2421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2422       };
2423     } catch (Dali::DaliException e) {
2424       {
2425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2426       };
2427     } catch (...) {
2428       {
2429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2430       };
2431     }
2432   }
2433
2434 }
2435
2436
2437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetPosition(void * jarg1) {
2438   void * jresult ;
2439   Dali::Window arg1 ;
2440   Dali::Window *argp1 ;
2441   Dali::Window::WindowPosition result;
2442
2443   argp1 = (Dali::Window *)jarg1;
2444   if (!argp1) {
2445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2446     return 0;
2447   }
2448   arg1 = *argp1;
2449   {
2450     try {
2451       result = arg1.GetPosition();
2452     } catch (std::out_of_range& e) {
2453       {
2454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2455       };
2456     } catch (std::exception& e) {
2457       {
2458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2459       };
2460     } catch (Dali::DaliException e) {
2461       {
2462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2463       };
2464     } catch (...) {
2465       {
2466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2467       };
2468     }
2469   }
2470
2471   jresult = new Dali::Window::WindowPosition((const Dali::Window::WindowPosition &)result);
2472   return jresult;
2473 }
2474
2475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPositionSize(void* jarg1, void* jarg2)
2476 {
2477   Dali::Window* window = (Dali::Window*)jarg1;
2478   if (!window) {
2479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2480     return ;
2481   }
2482
2483   Dali::Rect<int>* positionSize = (Dali::Rect<int>*)jarg2;
2484   if (!positionSize) {
2485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
2486     return ;
2487   }
2488   {
2489     try {
2490       Dali::DevelWindow::SetPositionSize(*window, *positionSize);
2491     } catch (std::out_of_range& e) {
2492       {
2493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2494       };
2495     } catch (std::exception& e) {
2496       {
2497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2498       };
2499     } catch (Dali::DaliException e) {
2500       {
2501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2502       };
2503     } catch (...) {
2504       {
2505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2506       };
2507     }
2508   }
2509
2510 }
2511
2512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetTransparency(void * jarg1, unsigned int jarg2) {
2513   Dali::Window arg1 ;
2514   bool arg2 ;
2515   Dali::Window *argp1 ;
2516
2517   argp1 = (Dali::Window *)jarg1;
2518   if (!argp1) {
2519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2520     return ;
2521   }
2522   arg1 = *argp1;
2523   arg2 = jarg2 ? true : false;
2524   {
2525     try {
2526       arg1.SetTransparency(arg2);
2527     } catch (std::out_of_range& e) {
2528       {
2529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2530       };
2531     } catch (std::exception& e) {
2532       {
2533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2534       };
2535     } catch (Dali::DaliException e) {
2536       {
2537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2538       };
2539     } catch (...) {
2540       {
2541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2542       };
2543     }
2544   }
2545
2546 }
2547
2548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_FeedKeyEvent(void * jarg1) {
2549   Dali::KeyEvent *arg1 = 0 ;
2550
2551   arg1 = (Dali::KeyEvent *)jarg1;
2552   if (!arg1) {
2553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0);
2554     return ;
2555   }
2556   {
2557     try {
2558       Dali::Adaptor::Get().FeedKeyEvent(*arg1);
2559     } catch (std::out_of_range& e) {
2560       {
2561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2562       };
2563     } catch (std::exception& e) {
2564       {
2565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2566       };
2567     } catch (...) {
2568       {
2569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2570       };
2571     }
2572   }
2573 }
2574
2575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_RenderOnce(void * /* jarg1 */) {
2576   try {
2577     Dali::Adaptor::Get().RenderOnce();
2578   } catch (std::out_of_range& e) {
2579     {
2580       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2581     };
2582   } catch (std::exception& e) {
2583     {
2584       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2585     };
2586   } catch (...) {
2587     {
2588       SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2589     };
2590   }
2591 }
2592
2593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Add(void * jarg1, void * jarg2) {
2594   Dali::Window *arg1 = (Dali::Window *) 0 ;
2595   Dali::Actor arg2 ;
2596   Dali::Actor *argp2 ;
2597
2598   arg1 = (Dali::Window *)jarg1;
2599   argp2 = (Dali::Actor *)jarg2;
2600   if (!argp2) {
2601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2602     return ;
2603   }
2604   arg2 = *argp2;
2605   {
2606     try {
2607       (arg1)->Add(arg2);
2608     } catch (std::out_of_range& e) {
2609       {
2610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2611       };
2612     } catch (std::exception& e) {
2613       {
2614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2615       };
2616     } catch (Dali::DaliException e) {
2617       {
2618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2619       };
2620     } catch (...) {
2621       {
2622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2623       };
2624     }
2625   }
2626 }
2627
2628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Remove(void * jarg1, void * jarg2) {
2629   Dali::Window *arg1 = (Dali::Window *) 0 ;
2630   Dali::Actor *arg2 = 0 ;
2631
2632   arg1 = (Dali::Window *)jarg1;
2633   arg2 = (Dali::Actor *)jarg2;
2634   if (!arg2) {
2635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
2636     return ;
2637   }
2638   {
2639     try {
2640       (arg1)->Remove(*arg2);
2641     } catch (std::out_of_range& e) {
2642       {
2643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2644       };
2645     } catch (std::exception& e) {
2646       {
2647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2648       };
2649     } catch (Dali::DaliException e) {
2650       {
2651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2652       };
2653     } catch (...) {
2654       {
2655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2656       };
2657     }
2658   }
2659 }
2660
2661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetBackgroundColor(void * jarg1, void * jarg2) {
2662   Dali::Window *arg1 = (Dali::Window *) 0 ;
2663   Dali::Vector4 arg2 ;
2664   Dali::Vector4 *argp2 ;
2665
2666   arg1 = (Dali::Window *)jarg1;
2667   argp2 = (Dali::Vector4 *)jarg2;
2668   if (!argp2) {
2669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
2670     return ;
2671   }
2672   arg2 = *argp2;
2673   {
2674     try {
2675       (arg1)->SetBackgroundColor(arg2);
2676     } catch (std::out_of_range& e) {
2677       {
2678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2679       };
2680     } catch (std::exception& e) {
2681       {
2682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2683       };
2684     } catch (Dali::DaliException e) {
2685       {
2686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2687       };
2688     } catch (...) {
2689       {
2690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2691       };
2692     }
2693   }
2694 }
2695
2696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetBackgroundColor(void * jarg1) {
2697   void * jresult ;
2698   Dali::Window *arg1 = (Dali::Window *) 0 ;
2699   Dali::Vector4 result;
2700
2701   arg1 = (Dali::Window *)jarg1;
2702   {
2703     try {
2704       result = ((Dali::Window const *)arg1)->GetBackgroundColor();
2705     } catch (std::out_of_range& e) {
2706       {
2707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2708       };
2709     } catch (std::exception& e) {
2710       {
2711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2712       };
2713     } catch (Dali::DaliException e) {
2714       {
2715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2716       };
2717     } catch (...) {
2718       {
2719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2720       };
2721     }
2722   }
2723
2724   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
2725   return jresult;
2726 }
2727
2728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetRootLayer(void * jarg1) {
2729   void * jresult ;
2730   Dali::Window *arg1 = (Dali::Window *) 0 ;
2731   Dali::Layer result;
2732
2733   arg1 = (Dali::Window *)jarg1;
2734   {
2735     try {
2736       result = ((Dali::Window const *)arg1)->GetRootLayer();
2737     } catch (std::out_of_range& e) {
2738       {
2739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2740       };
2741     } catch (std::exception& e) {
2742       {
2743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2744       };
2745     } catch (Dali::DaliException e) {
2746       {
2747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2748       };
2749     } catch (...) {
2750       {
2751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2752       };
2753     }
2754   }
2755
2756   jresult = new Dali::Layer((const Dali::Layer &)result);
2757   return jresult;
2758 }
2759
2760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_KeyEventSignal(void * jarg1) {
2761   void * jresult ;
2762   Dali::Window *arg1 = (Dali::Window *) 0 ;
2763   Dali::DevelWindow::KeyEventSignalType *result = 0 ;
2764
2765   arg1 = (Dali::Window *)jarg1;
2766   {
2767     try {
2768       result = (Dali::DevelWindow::KeyEventSignalType *) &(Dali::DevelWindow::KeyEventSignal(*arg1));
2769     } catch (std::out_of_range& e) {
2770       {
2771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2772       };
2773     } catch (std::exception& e) {
2774       {
2775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2776       };
2777     } catch (Dali::DaliException e) {
2778       {
2779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2780       };
2781     } catch (...) {
2782       {
2783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2784       };
2785     }
2786   }
2787
2788   jresult = (void *)result;
2789   return jresult;
2790 }
2791
2792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_TouchSignal(void * jarg1) {
2793   void * jresult ;
2794   Dali::Window *arg1 = (Dali::Window *) 0 ;
2795   Dali::DevelWindow::TouchSignalType *result = 0 ;
2796
2797   arg1 = (Dali::Window *)jarg1;
2798   {
2799     try {
2800       result = (Dali::DevelWindow::TouchSignalType *) &(Dali::DevelWindow::TouchSignal(*arg1));
2801     } catch (std::out_of_range& e) {
2802       {
2803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2804       };
2805     } catch (std::exception& e) {
2806       {
2807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2808       };
2809     } catch (Dali::DaliException e) {
2810       {
2811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2812       };
2813     } catch (...) {
2814       {
2815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2816       };
2817     }
2818   }
2819
2820   jresult = (void *)result;
2821   return jresult;
2822 }
2823
2824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetParent(void* jarg1, void* jarg2)
2825 {
2826   Dali::Window* window = (Dali::Window*)jarg1;
2827   if (!window) {
2828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2829     return ;
2830   }
2831
2832   Dali::Window* parent = (Dali::Window*)jarg2;
2833   if (!parent) {
2834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2835     return ;
2836   }
2837   {
2838     try {
2839       Dali::DevelWindow::SetParent(*window, *parent);
2840     } catch (std::out_of_range& e) {
2841       {
2842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2843       };
2844     } catch (std::exception& e) {
2845       {
2846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2847       };
2848     } catch (Dali::DaliException e) {
2849       {
2850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2851       };
2852     } catch (...) {
2853       {
2854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2855       };
2856     }
2857   }
2858
2859 }
2860
2861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Unparent(void* jarg1)
2862 {
2863   Dali::Window* window = (Dali::Window*)jarg1;
2864   if (!window) {
2865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2866     return ;
2867   }
2868   {
2869     try {
2870       Dali::DevelWindow::Unparent(*window);
2871     } catch (std::out_of_range& e) {
2872       {
2873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2874       };
2875     } catch (std::exception& e) {
2876       {
2877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2878       };
2879     } catch (Dali::DaliException e) {
2880       {
2881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2882       };
2883     } catch (...) {
2884       {
2885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2886       };
2887     }
2888   }
2889
2890 }
2891
2892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetParent(void* jarg1)
2893 {
2894   void * jresult ;
2895   Dali::Window* window = (Dali::Window*)jarg1;
2896   Dali::Window result;
2897   if (!window) {
2898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2899     return 0;
2900   }
2901   {
2902     try {
2903       result = Dali::DevelWindow::GetParent(*window);
2904     } catch (std::out_of_range& e) {
2905       {
2906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2907       };
2908     } catch (std::exception& e) {
2909       {
2910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2911       };
2912     } catch (Dali::DaliException e) {
2913       {
2914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2915       };
2916     } catch (...) {
2917       {
2918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2919       };
2920     }
2921   }
2922   jresult = new Dali::Window((const Dali::Window &)result);
2923   return jresult;
2924 }
2925
2926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_EventSignal(void * jarg1) {
2927   void * jresult ;
2928   Dali::Window *arg1 = (Dali::Window *) 0 ;
2929   Dali::DevelWindow::TransitionEffectEventSignalType *result = 0 ;
2930
2931   arg1 = (Dali::Window *)jarg1;
2932   {
2933     try {
2934       result = (Dali::DevelWindow::TransitionEffectEventSignalType *) &(Dali::DevelWindow::TransitionEffectEventSignal(*arg1));
2935     } catch (std::out_of_range& e) {
2936       {
2937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2938       };
2939     } catch (std::exception& e) {
2940       {
2941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2942       };
2943     } catch (Dali::DaliException e) {
2944       {
2945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2946       };
2947     } catch (...) {
2948       {
2949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2950       };
2951     }
2952   }
2953
2954   jresult = (void *)result;
2955   return jresult;
2956 }
2957
2958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Empty(void * jarg1) {
2959   unsigned int jresult ;
2960   Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *) 0 ;
2961   bool result;
2962
2963   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *)jarg1;
2964   {
2965     try {
2966       result = (bool)Dali_Signal_Window_Transition_Effect_Event_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > const *)arg1);
2967     } catch (std::out_of_range& e) {
2968       {
2969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2970       };
2971     } catch (std::exception& e) {
2972       {
2973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2974       };
2975     } catch (Dali::DaliException e) {
2976       {
2977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2978       };
2979     } catch (...) {
2980       {
2981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2982       };
2983     }
2984   }
2985
2986   jresult = result;
2987   return jresult;
2988 }
2989
2990
2991 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_GetConnectionCount(void * jarg1) {
2992   unsigned long jresult ;
2993   Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *) 0 ;
2994   std::size_t result;
2995
2996   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *)jarg1;
2997   {
2998     try {
2999       result = Dali_Signal_Window_Transition_Effect_Event_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > const *)arg1);
3000     } catch (std::out_of_range& e) {
3001       {
3002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3003       };
3004     } catch (std::exception& e) {
3005       {
3006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3007       };
3008     } catch (Dali::DaliException e) {
3009       {
3010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3011       };
3012     } catch (...) {
3013       {
3014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3015       };
3016     }
3017   }
3018
3019   jresult = (unsigned long)result;
3020   return jresult;
3021 }
3022
3023
3024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Connect(void * jarg1, void * jarg2) {
3025   Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *) 0 ;
3026   void (*arg2)(Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) = (void (*)(Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType)) 0 ;
3027
3028   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *)jarg1;
3029   arg2 = (void (*)(Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType))jarg2;
3030   {
3031     try {
3032     //DALI_LOG_ERROR("CSharp_Dali_Window_Transition_Effect_Event_Signal_Connect(arg1=0x%x, arg2=0x%x) \n", arg1, arg2);
3033       Dali_Signal_Window_Transition_Effect_Event_Signal_Connect(arg1,arg2);
3034     } catch (std::out_of_range& e) {
3035       {
3036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3037       };
3038     } catch (std::exception& e) {
3039       {
3040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3041       };
3042     } catch (Dali::DaliException e) {
3043       {
3044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3045       };
3046     } catch (...) {
3047       {
3048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3049       };
3050     }
3051   }
3052
3053 }
3054
3055
3056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Disconnect(void * jarg1, void * jarg2) {
3057   Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *) 0 ;
3058   void (*arg2)(Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) = (void (*)(Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType)) 0 ;
3059
3060   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *)jarg1;
3061   arg2 = (void (*)(Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType))jarg2;
3062   {
3063     try {
3064       Dali_Signal_Window_Transition_Effect_Event_Signal_Disconnect(arg1,arg2);
3065     } catch (std::out_of_range& e) {
3066       {
3067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3068       };
3069     } catch (std::exception& e) {
3070       {
3071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3072       };
3073     } catch (Dali::DaliException e) {
3074       {
3075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3076       };
3077     } catch (...) {
3078       {
3079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3080       };
3081     }
3082   }
3083
3084 }
3085
3086
3087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Emit(void * jarg1, void * jarg2, int jarg3, int jarg4) {
3088   Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *) 0 ;
3089   Dali::Window arg2 ;
3090   Dali::Window *argp2 ;
3091
3092   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *)jarg1;
3093   argp2 = (Dali::Window *)jarg2;
3094   if (!argp2) {
3095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
3096     return ;
3097   }
3098   arg2 = *argp2;
3099   {
3100     try {
3101       Dali_Signal_Window_Transition_Effect_Event_Signal_Emit(arg1,arg2, (Dali::DevelWindow::EffectState)jarg3, (Dali::DevelWindow::EffectType)jarg4);
3102     } catch (std::out_of_range& e) {
3103       {
3104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3105       };
3106     } catch (std::exception& e) {
3107       {
3108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3109       };
3110     } catch (Dali::DaliException e) {
3111       {
3112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3113       };
3114     } catch (...) {
3115       {
3116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3117       };
3118     }
3119   }
3120
3121 }
3122
3123
3124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_new() {
3125   void * jresult ;
3126   Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *result = 0 ;
3127
3128   {
3129     try {
3130       result = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *)new Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) >();
3131     } catch (std::out_of_range& e) {
3132       {
3133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3134       };
3135     } catch (std::exception& e) {
3136       {
3137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3138       };
3139     } catch (Dali::DaliException e) {
3140       {
3141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3142       };
3143     } catch (...) {
3144       {
3145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3146       };
3147     }
3148   }
3149
3150   jresult = (void *)result;
3151   return jresult;
3152 }
3153
3154
3155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_delete(void * jarg1) {
3156   Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *) 0 ;
3157
3158   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::EffectState, Dali::DevelWindow::EffectType) > *)jarg1;
3159   {
3160     try {
3161       delete arg1;
3162     } catch (std::out_of_range& e) {
3163       {
3164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3165       };
3166     } catch (std::exception& e) {
3167       {
3168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3169       };
3170     } catch (Dali::DaliException e) {
3171       {
3172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3173       };
3174     } catch (...) {
3175       {
3176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3177       };
3178     }
3179   }
3180
3181 }
3182
3183
3184
3185 #ifdef __cplusplus
3186 }
3187 #endif
3188