dali-csharp-binder/src/window.cpp

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