dali-csharp-binder/src/window.cpp

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