dali-csharp-binder/src/window.cpp

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