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