dali-csharp-binder/src/window-wrap.cpp

   1 /*
   2  * Copyright (c) 2023 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // EXTERNAL INCLUDES
  19 #include <dali/public-api/adaptor-framework/window.h>
  20 #include <dali/devel-api/adaptor-framework/mouse-in-out-event.h>
  21 #include <dali/devel-api/adaptor-framework/window-devel.h>
  22 #include <dali/integration-api/adaptor-framework/adaptor.h>
  23 #include <dali-toolkit/devel-api/controls/control-devel.h>
  24
  25 // INTERNAL INCLUDES
  26 #include "common.h"
  27
  28 /* Callback for returning strings to C# without leaking memory */
  29 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
  30 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
  31
  32
  33
  34 SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Window, bool) > const *self){
  35   return self->Empty();
  36 }
  37 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Window, bool) > const *self){
  38 return self->GetConnectionCount();
  39 }
  40 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Window, bool) > *self,void (*func)(Dali::Window, bool)){
  41   self->Connect( func );
  42 }
  43 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Window, bool) > *self,void (*func)(Dali::Window, bool)){
  44   self->Disconnect( func );
  45 }
  46 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Window, bool) > *self,Dali::Window arg, bool focusIn){
  47   self->Emit( arg, focusIn );
  48 }
  49
  50 /*ResizeSignal*/
  51 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Empty(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *self){
  52   return self->Empty();
  53 }
  54 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *self){
  55 return self->GetConnectionCount();
  56 }
  57 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Connect(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self,void (*func)(Dali::Window, Dali::Window::WindowSize)){
  58   self->Connect( func );
  59 }
  60 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Disconnect(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self,void (*func)(Dali::Window, Dali::Window::WindowSize)){
  61   self->Disconnect( func );
  62 }
  63 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Emit(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self, Dali::Window arg, Dali::Window::WindowSize size){
  64   self->Emit( arg, size );
  65 }
  66
  67 //Transition effect
  68 SWIGINTERN bool Dali_Signal_Window_Transition_Effect_Event_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > const *self){
  69   return self->Empty();
  70 }
  71 SWIGINTERN std::size_t Dali_Signal_Window_Transition_Effect_Event_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > const *self){
  72 return self->GetConnectionCount();
  73 }
  74 SWIGINTERN void Dali_Signal_Window_Transition_Effect_Event_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *self, void (*func)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType)){
  75   self->Connect( func );
  76 }
  77 SWIGINTERN void Dali_Signal_Window_Transition_Effect_Event_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *self,void (*func)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType)){
  78   self->Disconnect( func );
  79 }
  80 SWIGINTERN void Dali_Signal_Window_Transition_Effect_Event_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *self,Dali::Window arg, Dali::WindowEffectState state, Dali::WindowEffectType type){
  81   self->Emit( arg, state, type );
  82 }
  83
  84 /* Moved signal */
  85 SWIGINTERN bool Dali_Signal_Window_Moved_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *self){
  86   return self->Empty();
  87 }
  88 SWIGINTERN std::size_t Dali_Signal_Window_Moved_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *self){
  89 return self->GetConnectionCount();
  90 }
  91 SWIGINTERN void Dali_Signal_Window_Moved_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self, void (*func)(Dali::Window, Dali::Window::WindowPosition)){
  92   self->Connect( func );
  93 }
  94 SWIGINTERN void Dali_Signal_Window_Moved_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self,void (*func)(Dali::Window, Dali::Window::WindowPosition)){
  95   self->Disconnect( func );
  96 }
  97 SWIGINTERN void Dali_Signal_Window_Moved_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self,Dali::Window window, Dali::Window::WindowPosition position){
  98   self->Emit( window, position );
  99 }
 100
 101 //Orientation Changed
 102 SWIGINTERN bool Dali_Signal_Window_Orientation_Changed_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > const *self){
 103   return self->Empty();
 104 }
 105 SWIGINTERN std::size_t Dali_Signal_Window_Orientation_Changed_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > const *self){
 106 return self->GetConnectionCount();
 107 }
 108 SWIGINTERN void Dali_Signal_Window_Orientation_Changed_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *self, void (*func)(Dali::Window, Dali::WindowOrientation)){
 109   self->Connect( func );
 110 }
 111 SWIGINTERN void Dali_Signal_Window_Orientation_Changed_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *self, void (*func)(Dali::Window, Dali::WindowOrientation)){
 112   self->Disconnect( func );
 113 }
 114 SWIGINTERN void Dali_Signal_Window_Orientation_Changed_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *self, Dali::Window arg, Dali::WindowOrientation orientation){
 115   self->Emit( arg, orientation );
 116 }
 117
 118 //input
 119 SWIGINTERN bool Dali_Signal_Window_MouseInOutEvent_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > const *self){
 120   return self->Empty();
 121 }
 122 SWIGINTERN std::size_t Dali_Signal_Window_MouseInOutEvent_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > const *self){
 123 return self->GetConnectionCount();
 124 }
 125 SWIGINTERN void Dali_Signal_Window_MouseInOutEvent_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *self, void (*func)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &)){
 126   self->Connect( func );
 127 }
 128 SWIGINTERN void Dali_Signal_Window_MouseInOutEvent_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *self, void (*func)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &)){
 129   self->Disconnect( func );
 130 }
 131 SWIGINTERN void Dali_Signal_Window_MouseInOutEvent_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *self, Dali::Window arg, Dali::DevelWindow::MouseInOutEvent const &mouseInOutEvent){
 132   self->Emit( arg, mouseInOutEvent );
 133 }
 134
 135 /* Move Completed signal */
 136 SWIGINTERN bool Dali_Signal_Window_Move_Completed_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *self){
 137   return self->Empty();
 138 }
 139 SWIGINTERN std::size_t Dali_Signal_Window_Move_Completed_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *self){
 140 return self->GetConnectionCount();
 141 }
 142 SWIGINTERN void Dali_Signal_Window_Move_Completed_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self, void (*func)(Dali::Window, Dali::Window::WindowPosition)){
 143   self->Connect( func );
 144 }
 145 SWIGINTERN void Dali_Signal_Window_Move_Completed_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self,void (*func)(Dali::Window, Dali::Window::WindowPosition)){
 146   self->Disconnect( func );
 147 }
 148 SWIGINTERN void Dali_Signal_Window_Move_Completed_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self,Dali::Window window, Dali::Window::WindowPosition position){
 149   self->Emit( window, position );
 150 }
 151
 152 /* Resize Completed signal */
 153 SWIGINTERN bool Dali_Signal_Window_Resize_Completed_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *self){
 154   return self->Empty();
 155 }
 156 SWIGINTERN std::size_t Dali_Signal_Window_Resize_Completed_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *self){
 157 return self->GetConnectionCount();
 158 }
 159 SWIGINTERN void Dali_Signal_Window_Resize_Completed_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self, void (*func)(Dali::Window, Dali::Window::WindowSize)){
 160   self->Connect( func );
 161 }
 162 SWIGINTERN void Dali_Signal_Window_Resize_Completed_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self,void (*func)(Dali::Window, Dali::Window::WindowSize)){
 163   self->Disconnect( func );
 164 }
 165 SWIGINTERN void Dali_Signal_Window_Resize_Completed_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self,Dali::Window window, Dali::Window::WindowSize size){
 166   self->Emit( window, size );
 167 }
 168
 169
 170 #ifdef __cplusplus
 171 extern "C" {
 172 #endif
 173
 174 /*Window binding*/
 175 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
 176   return (Dali::BaseHandle *)jarg1;
 177 }
 178
 179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
 180   void * jresult ;
 181   Dali::PositionSize arg1 ;
 182   std::string *arg2 = 0 ;
 183   bool arg3 ;
 184   Dali::PositionSize *argp1 ;
 185   Dali::Window result;
 186
 187   argp1 = (Dali::PositionSize *)jarg1;
 188   if (!argp1)
 189   {
 190     arg1 = Dali::PositionSize(0, 0, 0, 0);
 191   }
 192   else
 193   {
 194     arg1 = *argp1;
 195   }
 196   if (!jarg2) {
 197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 198     return 0;
 199   }
 200   std::string arg2_str(jarg2);
 201   arg2 = &arg2_str;
 202   arg3 = jarg3 ? true : false;
 203   {
 204     try {
 205       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
 206     } CALL_CATCH_EXCEPTION(0);
 207   }
 208
 209   jresult = new Dali::Window((const Dali::Window &)result);
 210
 211   //argout typemap for const std::string&
 212
 213   return jresult;
 214 }
 215
 216
 217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
 218   void * jresult ;
 219   Dali::PositionSize arg1 ;
 220   std::string *arg2 = 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   {
 237     try {
 238       result = Dali::Window::New(arg1,(std::string const &)*arg2);
 239     } CALL_CATCH_EXCEPTION(0);
 240   }
 241
 242   jresult = new Dali::Window((const Dali::Window &)result);
 243
 244   //argout typemap for const std::string&
 245
 246   return jresult;
 247 }
 248
 249
 250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
 251   void * jresult ;
 252   Dali::PositionSize arg1 ;
 253   std::string *arg2 = 0 ;
 254   std::string *arg3 = 0 ;
 255   bool arg4 ;
 256   Dali::PositionSize *argp1 ;
 257   Dali::Window result;
 258
 259   argp1 = (Dali::PositionSize *)jarg1;
 260   if (!argp1) {
 261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
 262     return 0;
 263   }
 264   arg1 = *argp1;
 265   if (!jarg2) {
 266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 267     return 0;
 268   }
 269   std::string arg2_str(jarg2);
 270   arg2 = &arg2_str;
 271   if (!jarg3) {
 272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 273     return 0;
 274   }
 275   std::string arg3_str(jarg3);
 276   arg3 = &arg3_str;
 277   arg4 = jarg4 ? true : false;
 278   {
 279     try {
 280       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
 281     } CALL_CATCH_EXCEPTION(0);
 282   }
 283
 284   jresult = new Dali::Window((const Dali::Window &)result);
 285
 286   return jresult;
 287 }
 288
 289
 290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
 291   void * jresult ;
 292   Dali::PositionSize arg1 ;
 293   std::string *arg2 = 0 ;
 294   std::string *arg3 = 0 ;
 295   Dali::PositionSize *argp1 ;
 296   Dali::Window result;
 297
 298   argp1 = (Dali::PositionSize *)jarg1;
 299   if (!argp1) {
 300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
 301     return 0;
 302   }
 303   arg1 = *argp1;
 304   if (!jarg2) {
 305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 306     return 0;
 307   }
 308   std::string arg2_str(jarg2);
 309   arg2 = &arg2_str;
 310   if (!jarg3) {
 311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 312     return 0;
 313   }
 314   std::string arg3_str(jarg3);
 315   arg3 = &arg3_str;
 316   {
 317     try {
 318       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
 319     } CALL_CATCH_EXCEPTION(0);
 320   }
 321
 322   jresult = new Dali::Window((const Dali::Window &)result);
 323
 324   return jresult;
 325 }
 326
 327
 328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
 329   void * jresult ;
 330   Dali::Window *result = 0 ;
 331
 332   {
 333     try {
 334       result = (Dali::Window *)new Dali::Window();
 335     } CALL_CATCH_EXCEPTION(0);
 336   }
 337
 338   jresult = (void *)result;
 339   return jresult;
 340 }
 341
 342
 343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
 344   Dali::Window *arg1 = (Dali::Window *) 0 ;
 345
 346   arg1 = (Dali::Window *)jarg1;
 347   {
 348     try {
 349       delete arg1;
 350     } CALL_CATCH_EXCEPTION();
 351   }
 352
 353 }
 354
 355
 356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
 357   void * jresult ;
 358   Dali::Window *arg1 = 0 ;
 359   Dali::Window *result = 0 ;
 360
 361   arg1 = (Dali::Window *)jarg1;
 362   if (!arg1) {
 363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
 364     return 0;
 365   }
 366   {
 367     try {
 368       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
 369     } CALL_CATCH_EXCEPTION(0);
 370   }
 371
 372   jresult = (void *)result;
 373   return jresult;
 374 }
 375
 376
 377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
 378   void * jresult ;
 379   Dali::Window *arg1 = (Dali::Window *) 0 ;
 380   Dali::Window *arg2 = 0 ;
 381   Dali::Window *result = 0 ;
 382
 383   arg1 = (Dali::Window *)jarg1;
 384   arg2 = (Dali::Window *)jarg2;
 385   if (!arg2) {
 386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
 387     return 0;
 388   }
 389   {
 390     try {
 391       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
 392     } CALL_CATCH_EXCEPTION(0);
 393   }
 394
 395   jresult = (void *)result;
 396   return jresult;
 397 }
 398
 399
 400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
 401   Dali::Window *arg1 = (Dali::Window *) 0 ;
 402   std::string arg2 ;
 403   std::string arg3 ;
 404
 405   arg1 = (Dali::Window *)jarg1;
 406   if (!jarg2) {
 407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 408     return ;
 409   }
 410   (&arg2)->assign(jarg2);
 411   if (!jarg3) {
 412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 413     return ;
 414   }
 415   (&arg3)->assign(jarg3);
 416   {
 417     try {
 418       (arg1)->SetClass(arg2,arg3);
 419     } CALL_CATCH_EXCEPTION();
 420   }
 421
 422 }
 423
 424
 425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
 426   Dali::Window *arg1 = (Dali::Window *) 0 ;
 427
 428   arg1 = (Dali::Window *)jarg1;
 429   {
 430     try {
 431       (arg1)->Raise();
 432     } CALL_CATCH_EXCEPTION();
 433   }
 434
 435 }
 436
 437
 438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
 439   Dali::Window *arg1 = (Dali::Window *) 0 ;
 440
 441   arg1 = (Dali::Window *)jarg1;
 442   {
 443     try {
 444       (arg1)->Lower();
 445     } CALL_CATCH_EXCEPTION();
 446   }
 447
 448 }
 449
 450
 451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
 452   Dali::Window *arg1 = (Dali::Window *) 0 ;
 453
 454   arg1 = (Dali::Window *)jarg1;
 455   {
 456     try {
 457       (arg1)->Activate();
 458     } CALL_CATCH_EXCEPTION();
 459   }
 460
 461 }
 462
 463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Maximize(void * winHandle, bool maximize) {
 464   Dali::Window *window = (Dali::Window *) 0 ;
 465
 466   window = (Dali::Window *)winHandle;
 467   {
 468     try {
 469       Dali::DevelWindow::Maximize(*window, maximize);
 470     } CALL_CATCH_EXCEPTION();
 471   }
 472 }
 473
 474 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_IsMaximized(void * winHandle) {
 475   Dali::Window *window = (Dali::Window *) 0 ;
 476   bool isMaximized = false;
 477
 478   window = (Dali::Window *)winHandle;
 479   {
 480     try {
 481       isMaximized = Dali::DevelWindow::IsMaximized(*window);
 482     } CALL_CATCH_EXCEPTION(false);
 483   }
 484   return isMaximized;
 485 }
 486
 487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Set_Maximum_Size(void * winHandle, void * size) {
 488   Dali::Window *window = (Dali::Window *) 0 ;
 489   Dali::Window::WindowSize *winSize;
 490   Dali::Window::WindowSize maximumSize;
 491
 492   window = (Dali::Window *)winHandle;
 493
 494   winSize = (Dali::Window::WindowSize *)size;
 495   if (!winSize) {
 496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0);
 497     return ;
 498   }
 499   maximumSize = *winSize;
 500
 501   {
 502     try {
 503       Dali::DevelWindow::SetMaximumSize(*window, maximumSize);
 504     } CALL_CATCH_EXCEPTION();
 505   }
 506 }
 507
 508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Minimize(void * winHandle, bool minimize) {
 509   Dali::Window *window = (Dali::Window *) 0 ;
 510
 511   window = (Dali::Window *)winHandle;
 512   {
 513     try {
 514       Dali::DevelWindow::Minimize(*window, minimize);
 515     } CALL_CATCH_EXCEPTION();
 516   }
 517 }
 518
 519 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_IsMinimized(void * winHandle) {
 520   Dali::Window *window = (Dali::Window *) 0 ;
 521   bool isMinimized = false;
 522
 523   window = (Dali::Window *)winHandle;
 524   {
 525     try {
 526       isMinimized = Dali::DevelWindow::IsMinimized(*window);
 527     } CALL_CATCH_EXCEPTION(false);
 528   }
 529   return isMinimized;
 530 }
 531
 532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Set_Minimum_Size(void * winHandle, void * size) {
 533   Dali::Window *window = (Dali::Window *) 0 ;
 534   Dali::Window::WindowSize *winSize;
 535   Dali::Window::WindowSize minimumSize;
 536
 537   window = (Dali::Window *)winHandle;
 538
 539   winSize = (Dali::Window::WindowSize *)size;
 540   if (!winSize) {
 541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0);
 542     return ;
 543   }
 544   minimumSize = *winSize;
 545
 546   window = (Dali::Window *)winHandle;
 547   {
 548     try {
 549       Dali::DevelWindow::SetMimimumSize(*window, minimumSize);
 550     } CALL_CATCH_EXCEPTION();
 551   }
 552 }
 553
 554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
 555   Dali::Window *arg1 = (Dali::Window *) 0 ;
 556   Dali::WindowOrientation arg2 ;
 557
 558   arg1 = (Dali::Window *)jarg1;
 559   arg2 = (Dali::WindowOrientation)jarg2;
 560   {
 561     try {
 562       (arg1)->AddAvailableOrientation(arg2);
 563     } CALL_CATCH_EXCEPTION();
 564   }
 565
 566 }
 567
 568
 569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
 570   Dali::Window *arg1 = (Dali::Window *) 0 ;
 571   Dali::WindowOrientation arg2 ;
 572
 573   arg1 = (Dali::Window *)jarg1;
 574   arg2 = (Dali::WindowOrientation)jarg2;
 575   {
 576     try {
 577       (arg1)->RemoveAvailableOrientation(arg2);
 578     } CALL_CATCH_EXCEPTION();
 579   }
 580
 581 }
 582
 583
 584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
 585   Dali::Window *arg1 = (Dali::Window *) 0 ;
 586   Dali::WindowOrientation arg2 ;
 587
 588   arg1 = (Dali::Window *)jarg1;
 589   arg2 = (Dali::WindowOrientation)jarg2;
 590   {
 591     try {
 592       (arg1)->SetPreferredOrientation(arg2);
 593     } CALL_CATCH_EXCEPTION();
 594   }
 595
 596 }
 597
 598
 599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
 600   int jresult ;
 601   Dali::Window *arg1 = (Dali::Window *) 0 ;
 602   Dali::WindowOrientation result;
 603
 604   arg1 = (Dali::Window *)jarg1;
 605   {
 606     try {
 607       result = (Dali::WindowOrientation)(arg1)->GetPreferredOrientation();
 608     } CALL_CATCH_EXCEPTION(0);
 609   }
 610
 611   jresult = (int)result;
 612   return jresult;
 613 }
 614
 615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetCurrentOrientation(void * jarg1) {
 616   int jresult ;
 617   Dali::WindowOrientation result;
 618   Dali::Window* window = (Dali::Window*)jarg1;
 619   if (!window) {
 620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 621     return 0;
 622   }
 623   {
 624     try {
 625       result = Dali::DevelWindow::GetCurrentOrientation(*window);
 626     } CALL_CATCH_EXCEPTION(0);
 627   }
 628
 629   jresult = (int)result;
 630   return jresult;
 631 }
 632
 633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetAvailableOrientations(void * jarg1, void* jarg2, int jarg3) {
 634   Dali::Window* window = (Dali::Window*)jarg1;
 635   if(!window)
 636   {
 637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 638     return;
 639   }
 640   Dali::Property::Array *arg2 = (static_cast<Dali::Property::Array *>(jarg2));
 641   unsigned int count = static_cast<unsigned int>(jarg3);
 642
 643   Dali::Vector< Dali::WindowOrientation> orientations;
 644   orientations.Resize( count );
 645   for(Dali::Property::Array::SizeType i = 0; i < count; ++i)
 646   {
 647     int angle = arg2->GetElementAt(i).Get<int>();
 648     orientations[i] = static_cast< Dali::WindowOrientation >(angle);
 649   }
 650   {
 651     try {
 652       Dali::DevelWindow::SetAvailableOrientations(*window, orientations);
 653     } CALL_CATCH_EXCEPTION();
 654   }
 655
 656 }
 657
 658
 659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
 660   void * jresult ;
 661   Dali::Window *arg1 = (Dali::Window *) 0 ;
 662   Dali::Any result;
 663
 664   arg1 = (Dali::Window *)jarg1;
 665   {
 666     try {
 667       result = ((Dali::Window const *)arg1)->GetNativeHandle();
 668     } CALL_CATCH_EXCEPTION(0);
 669   }
 670
 671   jresult = new Dali::Any((const Dali::Any &)result);
 672   return jresult;
 673 }
 674
 675 /*window-devel binding*/
 676
 677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
 678   void * jresult ;
 679   Dali::Window arg1 ;
 680   Dali::Window *argp1 ;
 681   Dali::Window::FocusChangeSignalType *result = 0 ;
 682
 683   argp1 = (Dali::Window *)jarg1;
 684   if (!argp1) {
 685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 686     return 0;
 687   }
 688   arg1 = *argp1;
 689   {
 690     try {
 691       result = (Dali::Window::FocusChangeSignalType*)&arg1.FocusChangeSignal();
 692     } CALL_CATCH_EXCEPTION(0);
 693   }
 694
 695   jresult = (void *)result;
 696   return jresult;
 697 }
 698
 699
 700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
 701   Dali::Window arg1 ;
 702   bool arg2 ;
 703   Dali::Window *argp1 ;
 704
 705   argp1 = (Dali::Window *)jarg1;
 706   if (!argp1) {
 707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 708     return ;
 709   }
 710   arg1 = *argp1;
 711   arg2 = jarg2 ? true : false;
 712   {
 713     try {
 714       arg1.SetAcceptFocus(arg2);
 715     } CALL_CATCH_EXCEPTION();
 716   }
 717
 718 }
 719
 720
 721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
 722   unsigned int jresult ;
 723   Dali::Window arg1 ;
 724   Dali::Window *argp1 ;
 725   bool result;
 726
 727   argp1 = (Dali::Window *)jarg1;
 728   if (!argp1) {
 729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 730     return 0;
 731   }
 732   arg1 = *argp1;
 733   {
 734     try {
 735       result = (bool)arg1.IsFocusAcceptable();
 736     } CALL_CATCH_EXCEPTION(0);
 737   }
 738
 739   jresult = result;
 740   return jresult;
 741 }
 742
 743
 744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
 745   Dali::Window arg1 ;
 746   Dali::Window *argp1 ;
 747
 748   argp1 = (Dali::Window *)jarg1;
 749   if (!argp1) {
 750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 751     return ;
 752   }
 753   arg1 = *argp1;
 754   {
 755     try {
 756       arg1.Show();
 757     } CALL_CATCH_EXCEPTION();
 758   }
 759
 760 }
 761
 762
 763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
 764   Dali::Window arg1 ;
 765   Dali::Window *argp1 ;
 766
 767   argp1 = (Dali::Window *)jarg1;
 768   if (!argp1) {
 769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 770     return ;
 771   }
 772   arg1 = *argp1;
 773   {
 774     try {
 775       arg1.Hide();
 776     } CALL_CATCH_EXCEPTION();
 777   }
 778
 779 }
 780
 781
 782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
 783   unsigned int jresult ;
 784   Dali::Window arg1 ;
 785   Dali::Window *argp1 ;
 786   bool result;
 787
 788   argp1 = (Dali::Window *)jarg1;
 789   if (!argp1) {
 790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 791     return 0;
 792   }
 793   arg1 = *argp1;
 794   {
 795     try {
 796       result = (bool)arg1.IsVisible();
 797     } CALL_CATCH_EXCEPTION(0);
 798   }
 799
 800   jresult = result;
 801   return jresult;
 802 }
 803
 804
 805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHintCount(void * jarg1) {
 806   unsigned int jresult ;
 807   Dali::Window arg1 ;
 808   Dali::Window *argp1 ;
 809   unsigned int result;
 810
 811   argp1 = (Dali::Window *)jarg1;
 812   if (!argp1) {
 813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 814     return 0;
 815   }
 816   arg1 = *argp1;
 817   {
 818     try {
 819       result = (unsigned int)arg1.GetSupportedAuxiliaryHintCount();
 820     } CALL_CATCH_EXCEPTION(0);
 821   }
 822
 823   jresult = result;
 824   return jresult;
 825 }
 826
 827
 828 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHint(void * jarg1, unsigned int jarg2) {
 829   char * jresult ;
 830   Dali::Window arg1 ;
 831   unsigned int arg2 ;
 832   Dali::Window *argp1 ;
 833   std::string result;
 834
 835   argp1 = (Dali::Window *)jarg1;
 836   if (!argp1) {
 837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 838     return 0;
 839   }
 840   arg1 = *argp1;
 841   arg2 = (unsigned int)jarg2;
 842   {
 843     try {
 844       result = arg1.GetSupportedAuxiliaryHint(arg2);
 845     } CALL_CATCH_EXCEPTION(0);
 846   }
 847
 848   jresult = SWIG_csharp_string_callback((&result)->c_str());
 849   return jresult;
 850 }
 851
 852
 853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AddAuxiliaryHint(void * jarg1, char * jarg2, char * jarg3) {
 854   unsigned int jresult ;
 855   Dali::Window arg1 ;
 856   std::string *arg2 = 0 ;
 857   std::string *arg3 = 0 ;
 858   Dali::Window *argp1 ;
 859   unsigned int result;
 860
 861   argp1 = (Dali::Window *)jarg1;
 862   if (!argp1) {
 863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 864     return 0;
 865   }
 866   arg1 = *argp1;
 867   if (!jarg2) {
 868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 869     return 0;
 870   }
 871   std::string arg2_str(jarg2);
 872   arg2 = &arg2_str;
 873   if (!jarg3) {
 874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 875     return 0;
 876   }
 877   std::string arg3_str(jarg3);
 878   arg3 = &arg3_str;
 879   {
 880     try {
 881       result = (unsigned int)arg1.AddAuxiliaryHint((std::string const &)*arg2,(std::string const &)*arg3);
 882     } CALL_CATCH_EXCEPTION(0);
 883   }
 884
 885   jresult = result;
 886
 887   return jresult;
 888 }
 889
 890
 891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RemoveAuxiliaryHint(void * jarg1, unsigned int jarg2) {
 892   unsigned int jresult ;
 893   Dali::Window arg1 ;
 894   unsigned int arg2 ;
 895   Dali::Window *argp1 ;
 896   bool result;
 897
 898   argp1 = (Dali::Window *)jarg1;
 899   if (!argp1) {
 900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 901     return 0;
 902   }
 903   arg1 = *argp1;
 904   arg2 = (unsigned int)jarg2;
 905   {
 906     try {
 907       result = (bool)arg1.RemoveAuxiliaryHint(arg2);
 908     } CALL_CATCH_EXCEPTION(0);
 909   }
 910
 911   jresult = result;
 912   return jresult;
 913 }
 914
 915
 916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetAuxiliaryHintValue(void * jarg1, unsigned int jarg2, char * jarg3) {
 917   unsigned int jresult ;
 918   Dali::Window arg1 ;
 919   unsigned int arg2 ;
 920   std::string *arg3 = 0 ;
 921   Dali::Window *argp1 ;
 922   bool result;
 923
 924   argp1 = (Dali::Window *)jarg1;
 925   if (!argp1) {
 926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 927     return 0;
 928   }
 929   arg1 = *argp1;
 930   arg2 = (unsigned int)jarg2;
 931   if (!jarg3) {
 932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 933     return 0;
 934   }
 935   std::string arg3_str(jarg3);
 936   arg3 = &arg3_str;
 937   {
 938     try {
 939       result = (bool)arg1.SetAuxiliaryHintValue(arg2,(std::string const &)*arg3);
 940     } CALL_CATCH_EXCEPTION(0);
 941   }
 942
 943   jresult = result;
 944
 945   //argout typemap for const std::string&
 946
 947   return jresult;
 948 }
 949
 950
 951 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintValue(void * jarg1, unsigned int jarg2) {
 952   char * jresult ;
 953   Dali::Window arg1 ;
 954   unsigned int arg2 ;
 955   Dali::Window *argp1 ;
 956   std::string result;
 957
 958   argp1 = (Dali::Window *)jarg1;
 959   if (!argp1) {
 960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 961     return 0;
 962   }
 963   arg1 = *argp1;
 964   arg2 = (unsigned int)jarg2;
 965   {
 966     try {
 967       result = arg1.GetAuxiliaryHintValue(arg2);
 968     } CALL_CATCH_EXCEPTION(0);
 969   }
 970
 971   jresult = SWIG_csharp_string_callback((&result)->c_str());
 972   return jresult;
 973 }
 974
 975
 976 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintId(void * jarg1, char * jarg2) {
 977   unsigned int jresult ;
 978   Dali::Window arg1 ;
 979   std::string *arg2 = 0 ;
 980   Dali::Window *argp1 ;
 981   unsigned int result;
 982
 983   argp1 = (Dali::Window *)jarg1;
 984   if (!argp1) {
 985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
 986     return 0;
 987   }
 988   arg1 = *argp1;
 989   if (!jarg2) {
 990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 991     return 0;
 992   }
 993   std::string arg2_str(jarg2);
 994   arg2 = &arg2_str;
 995   {
 996     try {
 997       result = (unsigned int)arg1.GetAuxiliaryHintId((std::string const &)*arg2);
 998     } CALL_CATCH_EXCEPTION(0);
 999   }
1000
1001   jresult = result;
1002
1003   //argout typemap for const std::string&
1004
1005   return jresult;
1006 }
1007
1008
1009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetInputRegion(void * jarg1, void * jarg2) {
1010   Dali::Window arg1 ;
1011   Dali::Rect< int > *arg2 = 0 ;
1012   Dali::Window *argp1 ;
1013
1014   argp1 = (Dali::Window *)jarg1;
1015   if (!argp1) {
1016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1017     return ;
1018   }
1019   arg1 = *argp1;
1020   arg2 = (Dali::Rect< int > *)jarg2;
1021   if (!arg2) {
1022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
1023     return ;
1024   }
1025   {
1026     try {
1027       arg1.SetInputRegion((Dali::Rect< int > const &)*arg2);
1028     } CALL_CATCH_EXCEPTION();
1029   }
1030
1031 }
1032
1033
1034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetType(void * jarg1, int jarg2) {
1035   Dali::Window arg1 ;
1036   Dali::WindowType arg2 ;
1037   Dali::Window *argp1 ;
1038
1039   argp1 = (Dali::Window *)jarg1;
1040   if (!argp1) {
1041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1042     return ;
1043   }
1044   arg1 = *argp1;
1045   arg2 = (Dali::WindowType)jarg2;
1046   {
1047     try {
1048       arg1.SetType(arg2);
1049     } CALL_CATCH_EXCEPTION();
1050   }
1051
1052 }
1053
1054
1055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetType(void * jarg1) {
1056   int jresult ;
1057   Dali::Window arg1 ;
1058   Dali::Window *argp1 ;
1059   Dali::WindowType result;
1060
1061   argp1 = (Dali::Window *)jarg1;
1062   if (!argp1) {
1063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1064     return 0;
1065   }
1066   arg1 = *argp1;
1067   {
1068     try {
1069       result = (Dali::WindowType)arg1.GetType();
1070     } CALL_CATCH_EXCEPTION(0);
1071   }
1072
1073   jresult = (int)result;
1074   return jresult;
1075 }
1076
1077
1078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetNotificationLevel(void * jarg1, int jarg2) {
1079   unsigned int jresult ;
1080   Dali::Window arg1 ;
1081   Dali::WindowNotificationLevel arg2 ;
1082   Dali::Window *argp1 ;
1083   int result;
1084
1085   argp1 = (Dali::Window *)jarg1;
1086   if (!argp1) {
1087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1088     return 0;
1089   }
1090   arg1 = *argp1;
1091   arg2 = (Dali::WindowNotificationLevel)jarg2;
1092   {
1093     try {
1094       result = (int)arg1.SetNotificationLevel(arg2);
1095     } CALL_CATCH_EXCEPTION(0);
1096   }
1097
1098   jresult = result;
1099   return jresult;
1100 }
1101
1102
1103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetNotificationLevel(void * jarg1) {
1104   int jresult ;
1105   Dali::Window arg1 ;
1106   Dali::Window *argp1 ;
1107   Dali::WindowNotificationLevel result;
1108
1109   argp1 = (Dali::Window *)jarg1;
1110   if (!argp1) {
1111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1112     return 0;
1113   }
1114   arg1 = *argp1;
1115   {
1116     try {
1117       result = (Dali::WindowNotificationLevel)arg1.GetNotificationLevel();
1118     } CALL_CATCH_EXCEPTION(0);
1119   }
1120
1121   jresult = (int)result;
1122   return jresult;
1123 }
1124
1125
1126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetOpaqueState(void * jarg1, unsigned int jarg2) {
1127   Dali::Window arg1 ;
1128   bool arg2 ;
1129   Dali::Window *argp1 ;
1130
1131   argp1 = (Dali::Window *)jarg1;
1132   if (!argp1) {
1133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1134     return ;
1135   }
1136   arg1 = *argp1;
1137   arg2 = jarg2 ? true : false;
1138   {
1139     try {
1140       arg1.SetOpaqueState(arg2);
1141     } CALL_CATCH_EXCEPTION();
1142   }
1143
1144 }
1145
1146
1147 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsOpaqueState(void * jarg1) {
1148   unsigned int jresult ;
1149   Dali::Window arg1 ;
1150   Dali::Window *argp1 ;
1151   bool result;
1152
1153   argp1 = (Dali::Window *)jarg1;
1154   if (!argp1) {
1155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1156     return 0;
1157   }
1158   arg1 = *argp1;
1159   {
1160     try {
1161       result = (bool)arg1.IsOpaqueState();
1162     } CALL_CATCH_EXCEPTION(0);
1163   }
1164
1165   jresult = result;
1166   return jresult;
1167 }
1168
1169
1170 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetScreenOffMode(void * jarg1, int jarg2) {
1171   unsigned int jresult ;
1172   Dali::Window arg1 ;
1173   Dali::WindowScreenOffMode arg2 ;
1174   Dali::Window *argp1 ;
1175   int result;
1176
1177   argp1 = (Dali::Window *)jarg1;
1178   if (!argp1) {
1179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1180     return 0;
1181   }
1182   arg1 = *argp1;
1183   arg2 = (Dali::WindowScreenOffMode)jarg2;
1184   {
1185     try {
1186       result = (int)arg1.SetScreenOffMode(arg2);
1187     } CALL_CATCH_EXCEPTION(0);
1188   }
1189
1190   jresult = result;
1191   return jresult;
1192 }
1193
1194
1195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetScreenOffMode(void * jarg1) {
1196   int jresult ;
1197   Dali::Window arg1 ;
1198   Dali::Window *argp1 ;
1199   Dali::WindowScreenOffMode result;
1200
1201   argp1 = (Dali::Window *)jarg1;
1202   if (!argp1) {
1203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1204     return 0;
1205   }
1206   arg1 = *argp1;
1207   {
1208     try {
1209       result = (Dali::WindowScreenOffMode)arg1.GetScreenOffMode();
1210     } CALL_CATCH_EXCEPTION(0);
1211   }
1212
1213   jresult = (int)result;
1214   return jresult;
1215 }
1216
1217
1218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetBrightness(void * jarg1, int jarg2) {
1219   unsigned int jresult ;
1220   Dali::Window arg1 ;
1221   int arg2 ;
1222   Dali::Window *argp1 ;
1223   int result;
1224
1225   argp1 = (Dali::Window *)jarg1;
1226   if (!argp1) {
1227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1228     return 0;
1229   }
1230   arg1 = *argp1;
1231   arg2 = (int)jarg2;
1232   {
1233     try {
1234       result = (int)arg1.SetBrightness(arg2);
1235     } CALL_CATCH_EXCEPTION(0);
1236   }
1237
1238   jresult = result;
1239   return jresult;
1240 }
1241
1242
1243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetBrightness(void * jarg1) {
1244   int jresult ;
1245   Dali::Window arg1 ;
1246   Dali::Window *argp1 ;
1247   int result;
1248
1249   argp1 = (Dali::Window *)jarg1;
1250   if (!argp1) {
1251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1252     return 0;
1253   }
1254   arg1 = *argp1;
1255   {
1256     try {
1257       result = (int)arg1.GetBrightness();
1258     } CALL_CATCH_EXCEPTION(0);
1259   }
1260
1261   jresult = result;
1262   return jresult;
1263 }
1264
1265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
1266   unsigned int jresult ;
1267   Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *) 0 ;
1268   bool result;
1269
1270   arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1;
1271   {
1272     try {
1273       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Window, bool) > const *)arg1);
1274     } CALL_CATCH_EXCEPTION(0);
1275   }
1276
1277   jresult = result;
1278   return jresult;
1279 }
1280
1281
1282 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
1283   unsigned long jresult ;
1284   Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *) 0 ;
1285   std::size_t result;
1286
1287   arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1;
1288   {
1289     try {
1290       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Window, bool) > const *)arg1);
1291     } CALL_CATCH_EXCEPTION(0);
1292   }
1293
1294   jresult = (unsigned long)result;
1295   return jresult;
1296 }
1297
1298
1299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
1300   Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *) 0 ;
1301   void (*arg2)(Dali::Window, bool) = (void (*)(Dali::Window, bool)) 0 ;
1302
1303   arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1;
1304   arg2 = (void (*)(Dali::Window, bool))jarg2;
1305   {
1306     try {
1307       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
1308     } CALL_CATCH_EXCEPTION();
1309   }
1310
1311 }
1312
1313
1314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
1315   Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *) 0 ;
1316   void (*arg2)(Dali::Window, bool) = (void (*)(Dali::Window, bool)) 0 ;
1317
1318   arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1;
1319   arg2 = (void (*)(Dali::Window, bool))jarg2;
1320   {
1321     try {
1322       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
1323     } CALL_CATCH_EXCEPTION();
1324   }
1325
1326 }
1327
1328
1329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, void* jarg2, unsigned int jarg3) {
1330   Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1;
1331   Dali::Window* arg2 = (Dali::Window*)jarg2;
1332   bool arg3 = jarg3 ? true : false;;
1333
1334   if (arg1 == nullptr || arg2 == nullptr) {
1335     DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr");
1336     return;
1337   }
1338
1339   {
1340     try {
1341       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,*arg2,arg3);
1342     } CALL_CATCH_EXCEPTION();
1343   }
1344
1345 }
1346
1347
1348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
1349   void * jresult ;
1350   Dali::Signal< void (Dali::Window, bool) > *result = 0 ;
1351
1352   {
1353     try {
1354       result = (Dali::Signal< void (Dali::Window, bool) > *)new Dali::Signal< void (Dali::Window, bool) >();
1355     } CALL_CATCH_EXCEPTION(0);
1356   }
1357
1358   jresult = (void *)result;
1359   return jresult;
1360 }
1361
1362
1363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
1364   Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *) 0 ;
1365
1366   arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1;
1367   {
1368     try {
1369       delete arg1;
1370     } CALL_CATCH_EXCEPTION();
1371   }
1372
1373 }
1374
1375
1376
1377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_ResizeSignal(void * jarg1) {
1378   void * jresult ;
1379   Dali::Window arg1 ;
1380   Dali::Window *argp1 ;
1381   Dali::Window::ResizeSignalType *result = 0 ;
1382
1383   argp1 = (Dali::Window *)jarg1;
1384   if (!argp1) {
1385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1386     return 0;
1387   }
1388   arg1 = *argp1;
1389   {
1390     try {
1391       result = (Dali::Window::ResizeSignalType *) &arg1.ResizeSignal();
1392     } CALL_CATCH_EXCEPTION(0);
1393   }
1394
1395   jresult = (void *)result;
1396   return jresult;
1397 }
1398
1399 /*ResizedSignal binding*/
1400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResizeSignal_Empty(void * jarg1) {
1401   unsigned int jresult ;
1402   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
1403   bool result;
1404
1405   arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1;
1406   {
1407     try {
1408       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Empty((Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *)arg1);
1409     } CALL_CATCH_EXCEPTION(0);
1410   }
1411
1412   jresult = result;
1413   return jresult;
1414 }
1415
1416
1417 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResizeSignal_GetConnectionCount(void * jarg1) {
1418   unsigned long jresult ;
1419   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
1420   std::size_t result;
1421
1422   arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1;
1423   {
1424     try {
1425       result = Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *)arg1);
1426     } CALL_CATCH_EXCEPTION(0);
1427   }
1428
1429   jresult = (unsigned long)result;
1430   return jresult;
1431 }
1432
1433
1434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizeSignal_Connect(void * jarg1, void * jarg2) {
1435   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
1436   void (*arg2)(Dali::Window, Dali::Window::WindowSize) = (void (*)(Dali::Window, Dali::Window::WindowSize)) 0 ;
1437
1438   arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1;
1439   arg2 = (void (*)(Dali::Window, Dali::Window::WindowSize))jarg2;
1440   {
1441     try {
1442       Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Connect(arg1,arg2);
1443     } CALL_CATCH_EXCEPTION();
1444   }
1445
1446 }
1447
1448
1449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizeSignal_Disconnect(void * jarg1, void * jarg2) {
1450   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
1451   void (*arg2)(Dali::Window, Dali::Window::WindowSize) = (void (*)(Dali::Window, Dali::Window::WindowSize)) 0 ;
1452
1453   arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1;
1454   arg2 = (void (*)(Dali::Window, Dali::Window::WindowSize))jarg2;
1455   {
1456     try {
1457       Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Disconnect(arg1,arg2);
1458     } CALL_CATCH_EXCEPTION();
1459   }
1460
1461 }
1462
1463
1464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizeSignal_Emit(void * jarg1, void* jarg2, void * jarg3) {
1465   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
1466   Dali::Window* arg2 = (Dali::Window*)jarg2;
1467   Dali::Window::WindowSize arg3 ;
1468   Dali::Window::WindowSize *argp3 ;
1469
1470   arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1;
1471   if (arg1 == nullptr || arg2 == nullptr) {
1472     DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr");
1473     return;
1474   }
1475
1476   argp3 = (Dali::Window::WindowSize *)jarg3;
1477   if (!argp3) {
1478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0);
1479     return ;
1480   }
1481   arg3 = *argp3;
1482   {
1483     try {
1484       Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Emit(arg1,*arg2,arg3);
1485     } CALL_CATCH_EXCEPTION();
1486   }
1487
1488 }
1489
1490
1491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResizeSignal() {
1492   void * jresult ;
1493   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *result = 0 ;
1494
1495   {
1496     try {
1497       result = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)new Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) >();
1498     } CALL_CATCH_EXCEPTION(0);
1499   }
1500
1501   jresult = (void *)result;
1502   return jresult;
1503 }
1504
1505
1506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResizeSignal(void * jarg1) {
1507   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
1508
1509   arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1;
1510   {
1511     try {
1512       delete arg1;
1513     } CALL_CATCH_EXCEPTION();
1514   }
1515
1516 }
1517
1518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetSize(void * jarg1, void * jarg2) {
1519   Dali::Window arg1 ;
1520   Dali::Window::WindowSize arg2 ;
1521   Dali::Window *argp1 ;
1522   Dali::Window::WindowSize *argp2 ;
1523
1524   argp1 = (Dali::Window *)jarg1;
1525   if (!argp1) {
1526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1527     return ;
1528   }
1529   arg1 = *argp1;
1530   argp2 = (Dali::Window::WindowSize *)jarg2;
1531   if (!argp2) {
1532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0);
1533     return ;
1534   }
1535   arg2 = *argp2;
1536   {
1537     try {
1538       arg1.SetSize(arg2);
1539     } CALL_CATCH_EXCEPTION();
1540   }
1541
1542 }
1543
1544
1545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetSize(void * jarg1) {
1546   void * jresult ;
1547   Dali::Window arg1 ;
1548   Dali::Window *argp1 ;
1549   Dali::Window::WindowSize result;
1550
1551   argp1 = (Dali::Window *)jarg1;
1552   if (!argp1) {
1553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1554     return 0;
1555   }
1556   arg1 = *argp1;
1557   {
1558     try {
1559       result = arg1.GetSize();
1560     } CALL_CATCH_EXCEPTION(0);
1561   }
1562
1563   jresult = new Dali::Window::WindowSize((const Dali::Window::WindowSize &)result);
1564   return jresult;
1565 }
1566
1567
1568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPosition(void * handle, void * position) {
1569   Dali::Window *pWindow;
1570   Dali::Window window;
1571   Dali::Window::WindowPosition *pPosition;
1572   Dali::Window::WindowPosition windowPosition;
1573
1574   pWindow = (Dali::Window *)handle;
1575   if (!pWindow) {
1576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1577     return ;
1578   }
1579   window = *pWindow;
1580
1581   pPosition = (Dali::Window::WindowPosition *)position;
1582   if (!pPosition) {
1583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::WindowPosition", 0);
1584     return ;
1585   }
1586   windowPosition = *pPosition;
1587
1588   {
1589     try {
1590       window.SetPosition(windowPosition);
1591     } CALL_CATCH_EXCEPTION();
1592   }
1593
1594 }
1595
1596
1597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetPosition(void * handle) {
1598   Dali::Window *pWindow ;
1599   Dali::Window window ;
1600   Dali::Window::WindowPosition windowPosition;
1601   Dali::Window::WindowPosition result;
1602   void * jresult ;
1603
1604   pWindow = (Dali::Window *)handle;
1605   if (!pWindow) {
1606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1607     return 0;
1608   }
1609   window = *pWindow;
1610   {
1611     try {
1612       windowPosition = window.GetPosition();
1613     } CALL_CATCH_EXCEPTION(0);
1614   }
1615
1616   jresult = new Dali::Window::WindowPosition((const Dali::Window::WindowPosition &)windowPosition);
1617   return jresult;
1618 }
1619
1620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPositionSize(void* jarg1, void* jarg2)
1621 {
1622   Dali::Window* window = (Dali::Window*)jarg1;
1623   if (!window) {
1624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1625     return ;
1626   }
1627
1628   Dali::Rect<int>* positionSize = (Dali::Rect<int>*)jarg2;
1629   if (!positionSize) {
1630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
1631     return ;
1632   }
1633   {
1634     try {
1635       Dali::DevelWindow::SetPositionSize(*window, *positionSize);
1636     } CALL_CATCH_EXCEPTION();
1637   }
1638
1639 }
1640
1641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetLayout(void* handle, unsigned int numCols, unsigned int numRows, unsigned int column, unsigned int row, unsigned int colSpan, unsigned int rowSpan)
1642 {
1643   Dali::Window *pWindow;
1644   Dali::Window window;
1645
1646   pWindow = (Dali::Window *)handle;
1647   if (!pWindow) {
1648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1649     return ;
1650   }
1651   window = *pWindow;
1652
1653   {
1654     try {
1655       window.SetLayout(numCols, numRows, column, row, colSpan, rowSpan);
1656     } CALL_CATCH_EXCEPTION();
1657   }
1658 }
1659
1660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetTransparency(void * jarg1, unsigned int jarg2) {
1661   Dali::Window arg1 ;
1662   bool arg2 ;
1663   Dali::Window *argp1 ;
1664
1665   argp1 = (Dali::Window *)jarg1;
1666   if (!argp1) {
1667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1668     return ;
1669   }
1670   arg1 = *argp1;
1671   arg2 = jarg2 ? true : false;
1672   {
1673     try {
1674       arg1.SetTransparency(arg2);
1675     } CALL_CATCH_EXCEPTION();
1676   }
1677
1678 }
1679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_FeedKey_Default_Window(void * event) {
1680   Dali::KeyEvent *keyEvent = 0 ;
1681
1682   keyEvent = (Dali::KeyEvent *)event;
1683   if (!keyEvent) {
1684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0);
1685     return ;
1686   }
1687   {
1688     try {
1689       Dali::Adaptor::Get().FeedKeyEvent(*keyEvent);
1690     } CALL_CATCH_EXCEPTION();
1691   }
1692 }
1693
1694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_FeedKey(void * window, void * event) {
1695   Dali::Window* win = (Dali::Window*)window;
1696   if (!win) {
1697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1698     return ;
1699   }
1700
1701   Dali::KeyEvent *keyEvent = 0 ;
1702   keyEvent = (Dali::KeyEvent *)event;
1703   if (!keyEvent) {
1704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0);
1705     return ;
1706   }
1707   {
1708     try {
1709       Dali::DevelWindow::FeedKeyEvent(*win, *keyEvent);
1710     } CALL_CATCH_EXCEPTION();
1711   }
1712 }
1713
1714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_FeedTouch(void * window, void * event, int timeStamp) {
1715   Dali::Window* win = (Dali::Window*)window;
1716   if (!win) {
1717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1718     return ;
1719   }
1720
1721   Dali::TouchPoint *touchPoint = 0 ;
1722   touchPoint = (Dali::TouchPoint *)event;
1723   if (!touchPoint) {
1724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint & type is null", 0);
1725     return ;
1726   }
1727   {
1728     try {
1729       Dali::DevelWindow::FeedTouchPoint(*win, *touchPoint, timeStamp);
1730     } CALL_CATCH_EXCEPTION();
1731   }
1732 }
1733
1734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_FeedWheel(void * window, void * event) {
1735   Dali::Window* win = (Dali::Window*)window;
1736   if (!win) {
1737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1738     return ;
1739   }
1740
1741   Dali::WheelEvent *wheelEvent = 0 ;
1742   wheelEvent = (Dali::WheelEvent *)event;
1743   if (!wheelEvent) {
1744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent & type is null", 0);
1745     return ;
1746   }
1747   {
1748     try {
1749       Dali::DevelWindow::FeedWheelEvent(*win, *wheelEvent);
1750     } CALL_CATCH_EXCEPTION();
1751   }
1752 }
1753
1754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_RenderOnce(void * /* jarg1 */) {
1755   try {
1756     Dali::Adaptor::Get().RenderOnce();
1757   } CALL_CATCH_EXCEPTION();
1758 }
1759
1760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Add(void * jarg1, void * jarg2) {
1761   Dali::Window *arg1 = (Dali::Window *) 0 ;
1762   Dali::Actor arg2 ;
1763   Dali::Actor *argp2 ;
1764
1765   arg1 = (Dali::Window *)jarg1;
1766   argp2 = (Dali::Actor *)jarg2;
1767   if (!argp2) {
1768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
1769     return ;
1770   }
1771   arg2 = *argp2;
1772   {
1773     try {
1774       (arg1)->Add(arg2);
1775     } CALL_CATCH_EXCEPTION();
1776   }
1777 }
1778
1779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Remove(void * jarg1, void * jarg2) {
1780   Dali::Window *arg1 = (Dali::Window *) 0 ;
1781   Dali::Actor *arg2 = 0 ;
1782
1783   arg1 = (Dali::Window *)jarg1;
1784   arg2 = (Dali::Actor *)jarg2;
1785   if (!arg2) {
1786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
1787     return ;
1788   }
1789   {
1790     try {
1791       (arg1)->Remove(*arg2);
1792     } CALL_CATCH_EXCEPTION();
1793   }
1794 }
1795
1796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetBackgroundColor(void * jarg1, void * jarg2) {
1797   Dali::Window *arg1 = (Dali::Window *) 0 ;
1798   Dali::Vector4 arg2 ;
1799   Dali::Vector4 *argp2 ;
1800
1801   arg1 = (Dali::Window *)jarg1;
1802   argp2 = (Dali::Vector4 *)jarg2;
1803   if (!argp2) {
1804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
1805     return ;
1806   }
1807   arg2 = *argp2;
1808   {
1809     try {
1810       (arg1)->SetBackgroundColor(arg2);
1811     } CALL_CATCH_EXCEPTION();
1812   }
1813 }
1814
1815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetBackgroundColor(void * jarg1) {
1816   void * jresult ;
1817   Dali::Window *arg1 = (Dali::Window *) 0 ;
1818   Dali::Vector4 result;
1819
1820   arg1 = (Dali::Window *)jarg1;
1821   {
1822     try {
1823       result = ((Dali::Window const *)arg1)->GetBackgroundColor();
1824     } CALL_CATCH_EXCEPTION(0);
1825   }
1826
1827   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
1828   return jresult;
1829 }
1830
1831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetRootLayer(void * csWindow) {
1832   void * jresult ;
1833   Dali::Window *window = (Dali::Window *) 0 ;
1834   Dali::Layer result;
1835
1836   window = (Dali::Window *)csWindow;
1837   {
1838     try {
1839       result = ((Dali::Window const *)window)->GetRootLayer();
1840     } CALL_CATCH_EXCEPTION(0);
1841   }
1842
1843   jresult = new Dali::Layer((const Dali::Layer &)result);
1844   return jresult;
1845 }
1846
1847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetOverlayLayer(void * csWindow) {
1848   void * jresult ;
1849   Dali::Window *window = (Dali::Window *) 0 ;
1850   Dali::Layer result;
1851
1852   window = (Dali::Window *)csWindow;
1853   {
1854     try {
1855       result = ((Dali::Window *)window)->GetOverlayLayer();
1856     } CALL_CATCH_EXCEPTION(0);
1857   }
1858
1859   jresult = new Dali::Layer((const Dali::Layer &)result);
1860   return jresult;
1861 }
1862
1863
1864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_KeyEventSignal(void * jarg1) {
1865   void * jresult ;
1866   Dali::Window *arg1 = (Dali::Window *) 0 ;
1867   Dali::Window::KeyEventSignalType *result = 0 ;
1868
1869   arg1 = (Dali::Window *)jarg1;
1870   {
1871     try {
1872       result = (Dali::Window::KeyEventSignalType *) &(arg1->KeyEventSignal());
1873     } CALL_CATCH_EXCEPTION(0);
1874   }
1875
1876   jresult = (void *)result;
1877   return jresult;
1878 }
1879
1880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_InterceptKeyEventSignal(void * winHandle) {
1881   void * jresult ;
1882   Dali::Window *window = (Dali::Window *) 0 ;
1883   Dali::DevelWindow::InterceptKeyEventSignalType *result = 0 ;
1884
1885   window = (Dali::Window *)winHandle;
1886   if (!window) {
1887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1888     return 0;
1889   }
1890   {
1891     try {
1892       result = (Dali::DevelWindow::InterceptKeyEventSignalType *) &(Dali::DevelWindow::InterceptKeyEventSignal(*window));
1893     } CALL_CATCH_EXCEPTION(0);
1894   }
1895
1896   jresult = (void *)result;
1897   return jresult;
1898 }
1899
1900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_TouchSignal(void * jarg1) {
1901   void * jresult ;
1902   Dali::Window *arg1 = (Dali::Window *) 0 ;
1903   Dali::Window::TouchEventSignalType *result = 0 ;
1904
1905   arg1 = (Dali::Window *)jarg1;
1906   {
1907     try {
1908       result = (Dali::Window::TouchEventSignalType *) &(arg1->TouchedSignal());
1909     } CALL_CATCH_EXCEPTION(0);
1910   }
1911
1912   jresult = (void *)result;
1913   return jresult;
1914 }
1915
1916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetParent(void* child, void* parent)
1917 {
1918   Dali::Window* childWindow = (Dali::Window*)child;
1919   if (!childWindow) {
1920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1921     return ;
1922   }
1923
1924   Dali::Window* parentWindow = (Dali::Window*)parent;
1925   if (!parentWindow) {
1926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1927     return ;
1928   }
1929   {
1930     try {
1931       Dali::DevelWindow::SetParent(*childWindow, *parentWindow);
1932     } CALL_CATCH_EXCEPTION();
1933   }
1934
1935 }
1936
1937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetParent_With_Stack(void* child, void* parent, bool belowParent)
1938 {
1939   Dali::Window* childWindow = (Dali::Window*)child;
1940   if (!childWindow) {
1941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1942     return ;
1943   }
1944
1945   Dali::Window* parentWindow = (Dali::Window*)parent;
1946   if (!parentWindow) {
1947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1948     return ;
1949   }
1950   {
1951     try {
1952       Dali::DevelWindow::SetParent(*childWindow, *parentWindow, belowParent);
1953     } CALL_CATCH_EXCEPTION();
1954   }
1955
1956 }
1957
1958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Unparent(void* jarg1)
1959 {
1960   Dali::Window* window = (Dali::Window*)jarg1;
1961   if (!window) {
1962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1963     return ;
1964   }
1965   {
1966     try {
1967       Dali::DevelWindow::Unparent(*window);
1968     } CALL_CATCH_EXCEPTION();
1969   }
1970
1971 }
1972
1973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetParent(void* jarg1)
1974 {
1975   void * jresult ;
1976   Dali::Window* window = (Dali::Window*)jarg1;
1977   Dali::Window result;
1978   if (!window) {
1979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1980     return 0;
1981   }
1982   {
1983     try {
1984       result = Dali::DevelWindow::GetParent(*window);
1985     } CALL_CATCH_EXCEPTION(0);
1986   }
1987   jresult = new Dali::Window((const Dali::Window &)result);
1988   return jresult;
1989 }
1990
1991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetWindow(void * jarg1) {
1992   void * jresult ;
1993   Dali::Window result;
1994
1995   {
1996     try {
1997       result = Dali::DevelWindow::Get(*(Dali::Actor*)jarg1);
1998     } CALL_CATCH_EXCEPTION(0);
1999   }
2000   jresult = new Dali::Window((const Dali::Window &)result);
2001   return jresult;
2002 }
2003
2004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_EventSignal(void * jarg1) {
2005   void * jresult ;
2006   Dali::Window *arg1 = (Dali::Window *) 0 ;
2007   Dali::DevelWindow::TransitionEffectEventSignalType *result = 0 ;
2008
2009   arg1 = (Dali::Window *)jarg1;
2010   {
2011     try {
2012       result = (Dali::DevelWindow::TransitionEffectEventSignalType *) &(Dali::DevelWindow::TransitionEffectEventSignal(*arg1));
2013     } CALL_CATCH_EXCEPTION(0);
2014   }
2015
2016   jresult = (void *)result;
2017   return jresult;
2018 }
2019
2020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Empty(void * jarg1) {
2021   unsigned int jresult ;
2022   Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ;
2023   bool result;
2024
2025   arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1;
2026   {
2027     try {
2028       result = (bool)Dali_Signal_Window_Transition_Effect_Event_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > const *)arg1);
2029     } CALL_CATCH_EXCEPTION(0);
2030   }
2031
2032   jresult = result;
2033   return jresult;
2034 }
2035
2036
2037 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_GetConnectionCount(void * jarg1) {
2038   unsigned long jresult ;
2039   Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ;
2040   std::size_t result;
2041
2042   arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1;
2043   {
2044     try {
2045       result = Dali_Signal_Window_Transition_Effect_Event_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > const *)arg1);
2046     } CALL_CATCH_EXCEPTION(0);
2047   }
2048
2049   jresult = (unsigned long)result;
2050   return jresult;
2051 }
2052
2053
2054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Connect(void * jarg1, void * jarg2) {
2055   Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ;
2056   void (*arg2)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) = (void (*)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType)) 0 ;
2057
2058   arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1;
2059   arg2 = (void (*)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType))jarg2;
2060   {
2061     try {
2062     //DALI_LOG_ERROR("CSharp_Dali_Window_Transition_Effect_Event_Signal_Connect(arg1=0x%x, arg2=0x%x) \n", arg1, arg2);
2063       Dali_Signal_Window_Transition_Effect_Event_Signal_Connect(arg1,arg2);
2064     } CALL_CATCH_EXCEPTION();
2065   }
2066
2067 }
2068
2069
2070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Disconnect(void * jarg1, void * jarg2) {
2071   Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ;
2072   void (*arg2)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) = (void (*)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType)) 0 ;
2073
2074   arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1;
2075   arg2 = (void (*)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType))jarg2;
2076   {
2077     try {
2078       Dali_Signal_Window_Transition_Effect_Event_Signal_Disconnect(arg1,arg2);
2079     } CALL_CATCH_EXCEPTION();
2080   }
2081
2082 }
2083
2084
2085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Emit(void * jarg1, void * jarg2, int jarg3, int jarg4) {
2086   Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ;
2087   Dali::Window arg2 ;
2088   Dali::Window *argp2 ;
2089
2090   arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1;
2091   argp2 = (Dali::Window *)jarg2;
2092   if (!argp2) {
2093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2094     return ;
2095   }
2096   arg2 = *argp2;
2097   {
2098     try {
2099       Dali_Signal_Window_Transition_Effect_Event_Signal_Emit(arg1,arg2, (Dali::WindowEffectState)jarg3, (Dali::WindowEffectType)jarg4);
2100     } CALL_CATCH_EXCEPTION();
2101   }
2102
2103 }
2104
2105
2106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_new() {
2107   void * jresult ;
2108   Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *result = 0 ;
2109
2110   {
2111     try {
2112       result = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)new Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) >();
2113     } CALL_CATCH_EXCEPTION(0);
2114   }
2115
2116   jresult = (void *)result;
2117   return jresult;
2118 }
2119
2120
2121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_delete(void * jarg1) {
2122   Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ;
2123
2124   arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1;
2125   {
2126     try {
2127       delete arg1;
2128     } CALL_CATCH_EXCEPTION();
2129   }
2130
2131 }
2132
2133
2134 ////////////////////////////////////////////////////////////////////
2135 /// Auxiliary Message event
2136
2137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Auxiliary_Message_Signal(void * jarg1) {
2138   void * jresult ;
2139   Dali::Window *window = (Dali::Window *) 0 ;
2140   Dali::DevelWindow::AuxiliaryMessageSignalType *result = 0 ;
2141
2142   window = (Dali::Window *)jarg1;
2143   {
2144     try {
2145       result = (Dali::DevelWindow::AuxiliaryMessageSignalType *) &(Dali::DevelWindow::AuxiliaryMessageSignal(*window));
2146     } CALL_CATCH_EXCEPTION(0);
2147   }
2148
2149   jresult = (void *)result;
2150   return jresult;
2151 }
2152
2153 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_Auxiliary_Message_Signal_Empty(void * jarg1) {
2154   bool result;
2155   Dali::DevelWindow::AuxiliaryMessageSignalType* arg1 = (Dali::DevelWindow::AuxiliaryMessageSignalType*) jarg1;
2156
2157   if (arg1 == nullptr) {
2158     DALI_LOG_ERROR("[ERR] arg1 == nullptr");
2159     return false;
2160   }
2161
2162   {
2163     try {
2164       result = arg1->Empty();
2165     }
2166     CALL_CATCH_EXCEPTION(false);
2167   }
2168   return result;
2169 }
2170
2171
2172 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Window_Auxiliary_Message_Signal_GetConnectionCount(void * jarg1) {
2173   unsigned int result;
2174   Dali::DevelWindow::AuxiliaryMessageSignalType* arg1 = (Dali::DevelWindow::AuxiliaryMessageSignalType *) jarg1;
2175
2176   if (arg1 == nullptr) {
2177     DALI_LOG_ERROR("[ERR] arg1 == nullptr");
2178     return 0;
2179   }
2180
2181   {
2182     try {
2183       result = arg1->GetConnectionCount();
2184     }
2185     CALL_CATCH_EXCEPTION(0);
2186   }
2187   return result;
2188 }
2189
2190
2191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Auxiliary_Message_Signal_Connect(void * jarg1, void * jarg2) {
2192   Dali::DevelWindow::AuxiliaryMessageSignalType* arg1 = (Dali::DevelWindow::AuxiliaryMessageSignalType *)jarg1;
2193   void (*arg2)(const std::string&, const std::string&, const Dali::Property::Array&) = ( void (*)(const std::string&, const std::string&, const Dali::Property::Array&) )jarg2;
2194
2195   if (arg1 == nullptr) {
2196     DALI_LOG_ERROR("[ERR] arg1 == nullptr");
2197     return ;
2198   }
2199
2200   {
2201     try {
2202       arg1->Connect(arg2);
2203     }
2204     CALL_CATCH_EXCEPTION();
2205   }
2206   return ;
2207 }
2208
2209
2210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Auxiliary_Message_Signal_Disconnect(void * jarg1, void * jarg2) {
2211   Dali::DevelWindow::AuxiliaryMessageSignalType* arg1 = (Dali::DevelWindow::AuxiliaryMessageSignalType *)jarg1;
2212   void (*arg2)(const std::string&, const std::string&, const Dali::Property::Array&) = ( void (*)(const std::string&, const std::string&, const Dali::Property::Array&) )jarg2;
2213
2214   if (arg1 == nullptr) {
2215     DALI_LOG_ERROR("[ERR] arg1 == nullptr");
2216     return;
2217   }
2218
2219   {
2220     try {
2221       arg1->Disconnect(arg2);
2222     }
2223     CALL_CATCH_EXCEPTION();
2224   }
2225   return;
2226 }
2227
2228 /////////////////
2229 // Keyboard Repeat Settings Changed
2230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_ChangedSignal(void * jarg1) {
2231   void * jresult ;
2232   Dali::Window *arg1 = (Dali::Window *) 0 ;
2233   Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *result = 0 ;
2234
2235   arg1 = (Dali::Window *)jarg1;
2236   {
2237     try {
2238       result = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *) &(Dali::DevelWindow::KeyboardRepeatSettingsChangedSignal(*arg1));
2239     } CALL_CATCH_EXCEPTION(0);
2240   }
2241
2242   jresult = (void *)result;
2243   return jresult;
2244 }
2245
2246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_Empty(void * jarg1) {
2247   unsigned int jresult ;
2248   Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType*)jarg1;
2249   if (arg1 == nullptr) {
2250     DALI_LOG_ERROR("[ERR] arg1 == nullptr");
2251     return false;
2252   }
2253
2254   bool result;
2255   {
2256     try {
2257       result = (bool)((Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType const *)arg1)->Empty();
2258     } CALL_CATCH_EXCEPTION(0);
2259   }
2260
2261   jresult = result;
2262   return jresult;
2263 }
2264
2265 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_GetConnectionCount(void * jarg1) {
2266   unsigned long jresult ;
2267   Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)jarg1;
2268   if (arg1 == nullptr) {
2269     DALI_LOG_ERROR("[ERR] arg1 == nullptr");
2270     return false;
2271   }
2272
2273   std::size_t result;
2274   {
2275     try {
2276       result = ((Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType const *)arg1)->GetConnectionCount();
2277     } CALL_CATCH_EXCEPTION(0);
2278   }
2279
2280   jresult = (unsigned long)result;
2281   return jresult;
2282 }
2283
2284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_Connect(void * jarg1, void * jarg2) {
2285   Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)jarg1;
2286   void (*arg2)() = (void (*)())jarg2;
2287
2288   if (arg1 == nullptr) {
2289     DALI_LOG_ERROR("[ERR] arg1 == nullptr");
2290     return;
2291   }
2292
2293   {
2294     try {
2295       (arg1)->Connect(arg2);
2296     } CALL_CATCH_EXCEPTION();
2297   }
2298
2299 }
2300
2301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_Disconnect(void * jarg1, void * jarg2) {
2302   Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)jarg1;
2303   void (*arg2)() = (void (*)())jarg2;
2304
2305   if (arg1 == nullptr) {
2306     DALI_LOG_ERROR("[ERR] arg1 == nullptr");
2307     return;
2308   }
2309
2310   {
2311     try {
2312       (arg1)->Disconnect(arg2);
2313     } CALL_CATCH_EXCEPTION();
2314   }
2315
2316 }
2317
2318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_Emit(void * jarg1) {
2319   Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)jarg1;
2320
2321   if (arg1 == nullptr) {
2322     DALI_LOG_ERROR("[ERR] arg1 == nullptr");
2323     return;
2324   }
2325
2326   {
2327     try {
2328       (arg1)->Emit();
2329     } CALL_CATCH_EXCEPTION();
2330   }
2331
2332 }
2333
2334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_new() {
2335   void * jresult ;
2336   Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *result = 0;
2337
2338   {
2339     try {
2340       result = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)new Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType();
2341     } CALL_CATCH_EXCEPTION(0);
2342   }
2343
2344   jresult = (void *)result;
2345   return jresult;
2346 }
2347
2348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_delete(void * jarg1) {
2349   Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType*) 0;
2350
2351   arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)jarg1;
2352   {
2353     try {
2354       delete arg1;
2355     } CALL_CATCH_EXCEPTION();
2356   }
2357
2358 }
2359
2360
2361 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal(void* jarg1) {
2362   Dali::Window* arg1 = (Dali::Window*) jarg1;
2363   Dali::DevelWindow::VisibilityChangedSignalType* result = 0;
2364
2365   {
2366     try {
2367       result = (Dali::DevelWindow::VisibilityChangedSignalType*) &( Dali::DevelWindow::VisibilityChangedSignal(*arg1) );
2368     }
2369     CALL_CATCH_EXCEPTION(0);
2370   }
2371   return (void*)result;
2372 }
2373
2374 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_Empty(void* jarg1) {
2375   bool result;
2376   Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType*) jarg1;
2377
2378   if (arg1 == nullptr) {
2379     DALI_LOG_ERROR("[ERR] arg1 == nullptr");
2380     return false;
2381   }
2382
2383   {
2384     try {
2385       result = arg1->Empty();
2386     }
2387     CALL_CATCH_EXCEPTION(false);
2388   }
2389   return result;
2390 }
2391
2392
2393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_GetConnectionCount(void* jarg1) {
2394   unsigned int result;
2395   Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType *) jarg1;
2396
2397   if (arg1 == nullptr) {
2398     DALI_LOG_ERROR("[ERR] arg1 == nullptr");
2399     return 0;
2400   }
2401
2402   {
2403     try {
2404       result = arg1->GetConnectionCount();
2405     }
2406     CALL_CATCH_EXCEPTION(0);
2407   }
2408   return result;
2409 }
2410
2411
2412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_Connect(void* jarg1, void* jarg2) {
2413   Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType *)jarg1;
2414   void (*arg2)(Dali::Window, bool) = ( void (*)(Dali::Window, bool) )jarg2;
2415
2416   if (arg1 == nullptr) {
2417     DALI_LOG_ERROR("[ERR] arg1 == nullptr");
2418     return ;
2419   }
2420
2421   {
2422     try {
2423       arg1->Connect(arg2);
2424     }
2425     CALL_CATCH_EXCEPTION();
2426   }
2427   return ;
2428 }
2429
2430
2431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_Disconnect(void* jarg1, void* jarg2) {
2432   Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType*)jarg1;
2433   void (*arg2)(Dali::Window, bool) = (void (*)(Dali::Window, bool))jarg2;
2434
2435   if (arg1 == nullptr) {
2436     DALI_LOG_ERROR("[ERR] arg1 == nullptr");
2437     return;
2438   }
2439
2440   {
2441     try {
2442       arg1->Disconnect(arg2);
2443     }
2444     CALL_CATCH_EXCEPTION();
2445   }
2446   return;
2447 }
2448
2449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_Emit(void* jarg1, void* jarg2, bool jarg3) {
2450   Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType*)jarg1;
2451   Dali::Window* arg2 = (Dali::Window*)jarg2;
2452   bool arg3 = jarg3;
2453
2454   if (arg1 == nullptr || arg2 == nullptr) {
2455     DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr");
2456     return;
2457   }
2458
2459   {
2460     try {
2461       arg1->Emit(*arg2, arg3);
2462     }
2463     CALL_CATCH_EXCEPTION();
2464   }
2465   return;
2466 }
2467
2468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_delete(void* jarg1) {
2469   Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType*)jarg1;
2470
2471   {
2472     try {
2473       delete arg1;
2474     }
2475     CALL_CATCH_EXCEPTION();
2476   }
2477   return;
2478 }
2479
2480 SWIGEXPORT int32_t SWIGSTDCALL CSharp_Dali_Window_GetNativeId( void* jarg1 )
2481 {
2482   Dali::Window* window = (Dali::Window*)jarg1;
2483   int32_t ret = -1;
2484   if( !window )
2485   {
2486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2487     return ret;
2488   }
2489
2490   {
2491     try {
2492       ret = Dali::DevelWindow::GetNativeId( *window );
2493     }
2494     CALL_CATCH_EXCEPTION(ret);
2495   }
2496   return ret;
2497 }
2498
2499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddFrameRenderedCallback( void* nuiWindow, void* nuiCallback, int nuiFrameId )
2500 {
2501   Dali::Window* window = (Dali::Window*)nuiWindow;
2502   void (*callback)(int32_t) = (void (*)(int32_t))nuiCallback;
2503
2504   if( !window || !callback )
2505   {
2506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null", 0);
2507     return;
2508   }
2509
2510   try
2511   {
2512     Dali::DevelWindow::AddFrameRenderedCallback( *window, std::unique_ptr< Dali::CallbackBase >( Dali::MakeCallback( callback ) ), nuiFrameId );
2513   }
2514   CALL_CATCH_EXCEPTION();
2515 }
2516
2517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddFramePresentedCallback( void* nuiWindow, void* nuiCallback, int nuiFrameId )
2518 {
2519   Dali::Window* window = (Dali::Window*)nuiWindow;
2520   void (*callback)(int32_t) = (void (*)(int32_t))nuiCallback;
2521
2522   if( !window || !callback )
2523   {
2524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null", 0);
2525     return;
2526   }
2527
2528   try
2529   {
2530     Dali::DevelWindow::AddFramePresentedCallback( *window, std::unique_ptr< Dali::CallbackBase >( Dali::MakeCallback( callback ) ), nuiFrameId );
2531   }
2532   CALL_CATCH_EXCEPTION();
2533 }
2534
2535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPositionSizeWithOrientation(void* jarg1, void* jarg2, int jarg3)
2536 {
2537   Dali::Window* window = (Dali::Window*)jarg1;
2538   if (!window) {
2539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2540     return ;
2541   }
2542
2543   Dali::Rect<int>* positionSize = (Dali::Rect<int>*)jarg2;
2544   if (!positionSize) {
2545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
2546     return ;
2547   }
2548
2549   Dali::WindowOrientation orientation = (Dali::WindowOrientation)jarg3;
2550   {
2551     try {
2552       Dali::DevelWindow::SetPositionSizeWithOrientation(*window, *positionSize, orientation);
2553     } CALL_CATCH_EXCEPTION();
2554   }
2555
2556 }
2557
2558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RequestMoveToServer(void* jarg1)
2559 {
2560   Dali::Window* window = (Dali::Window*)jarg1;
2561   if (!window) {
2562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2563     return ;
2564   }
2565
2566   {
2567     try {
2568       Dali::DevelWindow::RequestMoveToServer(*window);
2569     } CALL_CATCH_EXCEPTION();
2570   }
2571
2572 }
2573
2574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RequestResizeToServer(void* jarg1, int jarg2)
2575 {
2576   Dali::Window* window = (Dali::Window*)jarg1;
2577   if (!window) {
2578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2579     return ;
2580   }
2581
2582   Dali::WindowResizeDirection direction = (Dali::WindowResizeDirection)jarg2;
2583
2584   {
2585     try {
2586       Dali::DevelWindow::RequestResizeToServer(*window, direction);
2587     } CALL_CATCH_EXCEPTION();
2588   }
2589
2590 }
2591
2592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_EnableFloatingMode(void* jarg1, bool jarg2)
2593 {
2594   Dali::Window* window = (Dali::Window*)jarg1;
2595   if (!window) {
2596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2597     return;
2598   }
2599
2600   bool enable = jarg2;
2601   {
2602     try {
2603       Dali::DevelWindow::EnableFloatingMode(*window, enable);
2604     } CALL_CATCH_EXCEPTION();
2605   }
2606
2607 }
2608
2609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_IncludeInputRegion(void* winHandle, void* region)
2610 {
2611   Dali::Window* window = (Dali::Window*)winHandle;
2612   Dali::Rect<int> *addedRegion = (Dali::Rect<int> *)region;
2613   if (!window) {
2614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2615     return;
2616   }
2617   {
2618     try {
2619       Dali::DevelWindow::IncludeInputRegion(*window, *addedRegion);
2620     } CALL_CATCH_EXCEPTION();
2621   }
2622
2623 }
2624
2625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ExcludeInputRegion(void* winHandle, void* region)
2626 {
2627   Dali::Window* window = (Dali::Window*)winHandle;
2628   Dali::Rect<int> *subtractedRegion = (Dali::Rect<int> *)region;
2629   if (!window) {
2630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2631     return;
2632   }
2633   {
2634     try {
2635       Dali::DevelWindow::ExcludeInputRegion(*window, *subtractedRegion);
2636     } CALL_CATCH_EXCEPTION();
2637   }
2638
2639 }
2640
2641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_KeepRendering(void* winHandle, float durationSeconds)
2642 {
2643   Dali::Window* window = static_cast<Dali::Window*>(winHandle);
2644   if(!window)
2645   {
2646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2647     return;
2648   }
2649   {
2650     try
2651     {
2652       window->KeepRendering(durationSeconds);
2653     }
2654     CALL_CATCH_EXCEPTION();
2655   }
2656 }
2657
2658 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal(void* winHandle) {
2659   Dali::Window* window = (Dali::Window*) winHandle;
2660   Dali::DevelWindow::AccessibilityHighlightSignalType* result = 0;
2661
2662   {
2663     try {
2664       result = (Dali::DevelWindow::AccessibilityHighlightSignalType*) &( Dali::DevelWindow::AccessibilityHighlightSignal(*window) );
2665     }
2666     CALL_CATCH_EXCEPTION(0);
2667   }
2668   return (void*)result;
2669 }
2670
2671 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_Empty(void* accessibilityHighlightSignalTypeHandle) {
2672   bool result;
2673   Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType*) accessibilityHighlightSignalTypeHandle;
2674
2675   if (accessibilityHighlightSignalType == nullptr) {
2676     DALI_LOG_ERROR("[ERR] accessibilityHighlightSignalType == nullptr");
2677     return false;
2678   }
2679
2680   {
2681     try {
2682       result = accessibilityHighlightSignalType->Empty();
2683     }
2684     CALL_CATCH_EXCEPTION(false);
2685   }
2686   return result;
2687 }
2688
2689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_GetConnectionCount(void* accessibilityHighlightSignalTypeHandle) {
2690   unsigned int result;
2691   Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType *) accessibilityHighlightSignalTypeHandle;
2692
2693   if (accessibilityHighlightSignalType == nullptr) {
2694     DALI_LOG_ERROR("[ERR] accessibilityHighlightSignalType == nullptr");
2695     return 0;
2696   }
2697
2698   {
2699     try {
2700       result = accessibilityHighlightSignalType->GetConnectionCount();
2701     }
2702     CALL_CATCH_EXCEPTION(0);
2703   }
2704   return result;
2705 }
2706
2707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_Connect(void* accessibilityHighlightSignalTypeHandle, void* winHandle) {
2708   Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType *)accessibilityHighlightSignalTypeHandle;
2709   void (*window)(Dali::Window, bool) = ( void (*)(Dali::Window, bool) )winHandle;
2710
2711   if (accessibilityHighlightSignalType == nullptr) {
2712     DALI_LOG_ERROR("[ERR] accessibilityHighlightSignalType == nullptr");
2713     return ;
2714   }
2715
2716   {
2717     try {
2718       accessibilityHighlightSignalType->Connect(window);
2719     }
2720     CALL_CATCH_EXCEPTION();
2721   }
2722   return ;
2723 }
2724
2725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_Disconnect(void* accessibilityHighlightSignalTypeHandle, void* winHandle) {
2726   Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType*)accessibilityHighlightSignalTypeHandle;
2727   void (*window)(Dali::Window, bool) = (void (*)(Dali::Window, bool))winHandle;
2728
2729   if (accessibilityHighlightSignalType == nullptr) {
2730     DALI_LOG_ERROR("[ERR] accessibilityHighlightSignalType == nullptr");
2731     return;
2732   }
2733
2734   {
2735     try {
2736       accessibilityHighlightSignalType->Disconnect(window);
2737     }
2738     CALL_CATCH_EXCEPTION();
2739   }
2740   return;
2741 }
2742
2743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_delete(void* accessibilityHighlightSignalTypeHandle) {
2744   Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType*)accessibilityHighlightSignalTypeHandle;
2745
2746   {
2747     try {
2748       delete accessibilityHighlightSignalType;
2749     }
2750     CALL_CATCH_EXCEPTION();
2751   }
2752   return;
2753 }
2754
2755 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_IsWindowRotating(void* winHandle)
2756 {
2757   Dali::Window* window = (Dali::Window*)winHandle;
2758   bool result = false;
2759   if (!window) {
2760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2761     return result;
2762   }
2763   {
2764     try {
2765       result = Dali::DevelWindow::IsWindowRotating(*window);
2766     } CALL_CATCH_EXCEPTION(false);
2767   }
2768
2769   return result;
2770 }
2771
2772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetLastKeyEvent(void* winHandle)
2773 {
2774   Dali::Window* window = (Dali::Window*)winHandle;
2775   void * jresult;
2776   Dali::KeyEvent *result = 0;
2777   if (!window) {
2778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2779     return 0;
2780   }
2781   {
2782     try {
2783       result = (Dali::KeyEvent *)&Dali::DevelWindow::GetLastKeyEvent(*window);
2784     } CALL_CATCH_EXCEPTION(0);
2785   }
2786   jresult = (void *)result;
2787   return jresult;
2788 }
2789
2790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetLastTouchEvent(void* winHandle)
2791 {
2792   Dali::Window* window = (Dali::Window*)winHandle;
2793   void * jresult;
2794   Dali::TouchEvent *result = 0;
2795   if (!window) {
2796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2797     return 0;
2798   }
2799   {
2800     try {
2801       result = (Dali::TouchEvent *)&Dali::DevelWindow::GetLastTouchEvent(*window);
2802     } CALL_CATCH_EXCEPTION(0);
2803   }
2804   jresult = (void *)result;
2805   return jresult;
2806 }
2807
2808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_InternalRetrievingLastKeyEvent(void* winHandle, void* keyHandle)
2809 {
2810   Dali::Window* window = (Dali::Window*)winHandle;
2811   Dali::KeyEvent* keyEvent = (Dali::KeyEvent*)keyHandle;
2812
2813   if (!window) {
2814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2815     return;
2816   }
2817   if (!keyEvent) {
2818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::KeyEvent", 0);
2819     return;
2820   }
2821   {
2822     try {
2823       (*keyEvent) = *((Dali::KeyEvent *)&Dali::DevelWindow::GetLastKeyEvent(*window));
2824     } CALL_CATCH_EXCEPTION();
2825   }
2826 }
2827
2828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_InternalRetrievingLastTouchEvent(void* winHandle, void* touchHandle)
2829 {
2830   Dali::Window* window = (Dali::Window*)winHandle;
2831   Dali::TouchEvent* touchEvent = (Dali::TouchEvent*)touchHandle;
2832
2833   if (!window) {
2834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2835     return;
2836   }
2837   if (!touchEvent) {
2838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TouchEvent", 0);
2839     return;
2840   }
2841   {
2842     try {
2843       (*touchEvent) = *((Dali::TouchEvent *)&Dali::DevelWindow::GetLastTouchEvent(*window));
2844     } CALL_CATCH_EXCEPTION();
2845   }
2846 }
2847
2848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetNeedsRotationCompletedAcknowledgement(void* winHandle, bool needAcknowledgement)
2849 {
2850   Dali::Window* window = (Dali::Window*)winHandle;
2851   if (!window) {
2852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2853     return;
2854   }
2855   {
2856     try {
2857       Dali::DevelWindow::SetNeedsRotationCompletedAcknowledgement(*window, needAcknowledgement);
2858     } CALL_CATCH_EXCEPTION();
2859   }
2860 }
2861
2862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SendRotationCompletedAcknowledgement(void* winHandle)
2863 {
2864   Dali::Window* window = (Dali::Window*)winHandle;
2865   if (!window) {
2866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2867     return;
2868   }
2869   {
2870     try {
2871       Dali::DevelWindow::SendRotationCompletedAcknowledgement(*window);
2872     } CALL_CATCH_EXCEPTION();
2873   }
2874 }
2875
2876 /* Moved signal binding */
2877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Moved_Signal(void* winHandle)
2878 {
2879   void *result;
2880   Dali::Window window;
2881   Dali::Window *win;
2882   Dali::DevelWindow::MovedSignalType* movedSignal;
2883
2884   win = (Dali::Window *)winHandle;
2885   if (!win) {
2886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2887     return 0;
2888   }
2889   window = *win;
2890   {
2891     try {
2892       movedSignal = (Dali::DevelWindow::MovedSignalType *) &Dali::DevelWindow::MovedSignal(window);
2893     } CALL_CATCH_EXCEPTION(0);
2894   }
2895
2896   result = (void *)movedSignal;
2897   return result;
2898 }
2899
2900
2901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Moved_Signal_Empty(void * signal)
2902 {
2903   unsigned int result;
2904   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
2905   bool flag;
2906
2907   movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
2908   {
2909     try {
2910       flag = (bool)Dali_Signal_Window_Moved_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *)movedSignal);
2911     } CALL_CATCH_EXCEPTION(0);
2912   }
2913
2914   result = (unsigned int)flag;
2915   return result;
2916 }
2917
2918
2919 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Moved_Signal_GetConnectionCount(void * signal) {
2920   unsigned long result;
2921   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
2922   std::size_t count;
2923
2924   movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
2925   {
2926     try {
2927       count = Dali_Signal_Window_Moved_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *)movedSignal);
2928     } CALL_CATCH_EXCEPTION(0);
2929   }
2930
2931   result = (unsigned long)count;
2932   return result;
2933 }
2934
2935
2936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Moved_Signal_Connect(void * signal, void * func) {
2937   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
2938   void (*functionPtr)(Dali::Window, Dali::Window::WindowPosition) = (void (*)(Dali::Window, Dali::Window::WindowPosition)) 0 ;
2939
2940   movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
2941   functionPtr = (void (*)(Dali::Window, Dali::Window::WindowPosition))func;
2942   {
2943     try {
2944       Dali_Signal_Window_Moved_Signal_Connect(movedSignal, functionPtr);
2945     } CALL_CATCH_EXCEPTION();
2946   }
2947
2948 }
2949
2950
2951 SWIGEXPORT void SWIGSTDCALL CSharp_Moved_Signal_Disconnect(void * signal, void * func) {
2952   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
2953   void (*functionPtr)(Dali::Window, Dali::Window::WindowPosition) = (void (*)(Dali::Window, Dali::Window::WindowPosition)) 0 ;
2954
2955   movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
2956   functionPtr = (void (*)(Dali::Window, Dali::Window::WindowPosition))func;
2957   {
2958     try {
2959       Dali_Signal_Window_Moved_Signal_Disconnect(movedSignal, functionPtr);
2960     } CALL_CATCH_EXCEPTION();
2961   }
2962
2963 }
2964
2965
2966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Moved_Signal_Emit(void * signal, void* winHandle, void * position) {
2967   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
2968   Dali::Window* win = (Dali::Window*)winHandle;
2969   Dali::Window window;
2970   Dali::Window::WindowPosition windowPosition;
2971   Dali::Window::WindowPosition *pPosition;
2972
2973   movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
2974   if (movedSignal == nullptr || window == nullptr) {
2975     DALI_LOG_ERROR("[ERR] movedSignal == nullptr or window == nullptr");
2976     return;
2977   }
2978
2979   pPosition = (Dali::Window::WindowPosition *)position;
2980   if (!pPosition) {
2981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
2982     return ;
2983   }
2984   window = *win;
2985   windowPosition = *pPosition;
2986   {
2987     try {
2988       Dali_Signal_Window_Moved_Signal_Emit(movedSignal, window, windowPosition);
2989     } CALL_CATCH_EXCEPTION();
2990   }
2991
2992 }
2993
2994
2995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Moved_Signal() {
2996   void * result ;
2997   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = 0 ;
2998
2999   {
3000     try {
3001       movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)new Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) >();
3002     } CALL_CATCH_EXCEPTION(0);
3003   }
3004
3005   result = (void *)movedSignal;
3006   return result;
3007 }
3008
3009
3010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Moved_Signal(void * signal) {
3011   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
3012
3013   movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
3014   {
3015     try {
3016       delete movedSignal;
3017     } CALL_CATCH_EXCEPTION();
3018   }
3019
3020 }
3021
3022 /* Orientation Changed signal binding */
3023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Orientation_Changed_Signal(void* winHandle)
3024 {
3025   void *result;
3026   Dali::Window window;
3027   Dali::Window *win;
3028   Dali::DevelWindow::OrientationChangedSignalType* orientationChangedSignal;
3029
3030   win = (Dali::Window *)winHandle;
3031   if (!win) {
3032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
3033     return 0;
3034   }
3035   window = *win;
3036   {
3037     try {
3038       orientationChangedSignal = (Dali::DevelWindow::OrientationChangedSignalType *) &Dali::DevelWindow::OrientationChangedSignal(window);
3039     } CALL_CATCH_EXCEPTION(0);
3040   }
3041
3042   result = (void *)orientationChangedSignal;
3043   return result;
3044 }
3045
3046
3047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Orientation_Changed_Signal_Empty(void * signal)
3048 {
3049   unsigned int result;
3050   Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ;
3051   bool flag;
3052
3053   orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal;
3054   {
3055     try {
3056       flag = (bool)Dali_Signal_Window_Orientation_Changed_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > const *)orientationChangedSignal);
3057     } CALL_CATCH_EXCEPTION(0);
3058   }
3059
3060   result = (unsigned int)flag;
3061   return result;
3062 }
3063
3064
3065 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Orientation_Changed_Signal_GetConnectionCount(void * signal) {
3066   unsigned long result;
3067   Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ;
3068   std::size_t count;
3069
3070   orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal;
3071   {
3072     try {
3073       count = Dali_Signal_Window_Orientation_Changed_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > const *)orientationChangedSignal);
3074     } CALL_CATCH_EXCEPTION(0);
3075   }
3076
3077   result = (unsigned long)count;
3078   return result;
3079 }
3080
3081
3082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Orientation_Changed_Signal_Connect(void * signal, void * func) {
3083   Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ;
3084   void (*functionPtr)(Dali::Window, Dali::WindowOrientation) = (void (*)(Dali::Window, Dali::WindowOrientation)) 0 ;
3085
3086   orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal;
3087   functionPtr = (void (*)(Dali::Window, Dali::WindowOrientation))func;
3088   {
3089     try {
3090       Dali_Signal_Window_Orientation_Changed_Signal_Connect(orientationChangedSignal, functionPtr);
3091     } CALL_CATCH_EXCEPTION();
3092   }
3093
3094 }
3095
3096
3097 SWIGEXPORT void SWIGSTDCALL CSharp_Orientation_Changed_Signal_Disconnect(void * signal, void * func) {
3098   Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ;
3099   void (*functionPtr)(Dali::Window, Dali::WindowOrientation) = (void (*)(Dali::Window, Dali::WindowOrientation)) 0 ;
3100
3101   orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal;
3102   functionPtr = (void (*)(Dali::Window, Dali::WindowOrientation))func;
3103   {
3104     try {
3105       Dali_Signal_Window_Orientation_Changed_Signal_Disconnect(orientationChangedSignal, functionPtr);
3106     } CALL_CATCH_EXCEPTION();
3107   }
3108
3109 }
3110
3111
3112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Orientation_Changed_Signal_Emit(void * signal, void* winHandle, int orientation) {
3113   Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ;
3114   Dali::Window* win = (Dali::Window*)winHandle;
3115   Dali::Window window;
3116   Dali::WindowOrientation windowOrientation;
3117
3118   orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal;
3119   if (orientationChangedSignal == nullptr || window == nullptr) {
3120     DALI_LOG_ERROR("[ERR] orientationChangedSignal == nullptr or window == nullptr");
3121     return;
3122   }
3123
3124   window = *win;
3125   windowOrientation = static_cast<Dali::WindowOrientation>(orientation);
3126   {
3127     try {
3128       Dali_Signal_Window_Orientation_Changed_Signal_Emit(orientationChangedSignal, window, windowOrientation);
3129     } CALL_CATCH_EXCEPTION();
3130   }
3131
3132 }
3133
3134
3135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Orientation_Changed_Signal() {
3136   void * result ;
3137   Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = 0 ;
3138
3139   {
3140     try {
3141       orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)new Dali::Signal< void (Dali::Window, Dali::WindowOrientation) >();
3142     } CALL_CATCH_EXCEPTION(0);
3143   }
3144
3145   result = (void *)orientationChangedSignal;
3146   return result;
3147 }
3148
3149
3150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Orientation_Changed_Signal(void * signal) {
3151   Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ;
3152
3153   orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal;
3154   {
3155     try {
3156       delete orientationChangedSignal;
3157     } CALL_CATCH_EXCEPTION();
3158   }
3159
3160 }
3161
3162 //
3163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal(void* winHandle)
3164 {
3165   void *result;
3166   Dali::Window window;
3167   Dali::Window *win;
3168   Dali::DevelWindow::MouseInOutEventSignalType* mouseInOutSignal;
3169
3170   win = (Dali::Window *)winHandle;
3171   if (!win) {
3172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
3173     return 0;
3174   }
3175   window = *win;
3176   {
3177     try {
3178       mouseInOutSignal = (Dali::DevelWindow::MouseInOutEventSignalType *) &Dali::DevelWindow::MouseInOutEventSignal(window);
3179     } CALL_CATCH_EXCEPTION(0);
3180   }
3181
3182   result = (void *)mouseInOutSignal;
3183   return result;
3184 }
3185
3186
3187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_Empty(void * jarg1) {
3188   unsigned int jresult ;
3189   Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ;
3190   bool result;
3191
3192   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1;
3193   {
3194     try {
3195       result = (bool)Dali_Signal_Window_MouseInOutEvent_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > const *)arg1);
3196     } CALL_CATCH_EXCEPTION(0);
3197   }
3198
3199   jresult = result;
3200   return jresult;
3201 }
3202
3203
3204 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_GetConnectionCount(void * jarg1) {
3205   unsigned long jresult ;
3206   Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ;
3207   std::size_t result;
3208
3209   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1;
3210   {
3211     try {
3212       result = Dali_Signal_Window_MouseInOutEvent_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > const *)arg1);
3213     } CALL_CATCH_EXCEPTION(0);
3214   }
3215
3216   jresult = (unsigned long)result;
3217   return jresult;
3218 }
3219
3220
3221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_Connect(void * jarg1, void * jarg2) {
3222   Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ;
3223   void (*arg2)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) = (void (*)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &)) 0 ;
3224
3225   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1;
3226   arg2 = (void (*)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &))jarg2;
3227   {
3228     try {
3229       Dali_Signal_Window_MouseInOutEvent_Signal_Connect(arg1,arg2);
3230     } CALL_CATCH_EXCEPTION();
3231   }
3232
3233 }
3234
3235
3236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_Disconnect(void * jarg1, void * jarg2) {
3237   Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ;
3238   void (*arg2)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) = (void (*)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &)) 0 ;
3239
3240   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1;
3241   arg2 = (void (*)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &))jarg2;
3242   {
3243     try {
3244       Dali_Signal_Window_MouseInOutEvent_Signal_Disconnect(arg1,arg2);
3245     } CALL_CATCH_EXCEPTION();
3246   }
3247
3248 }
3249
3250
3251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_Emit(void * jarg1, void* jarg2, void* jarg3) {
3252   Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1;
3253   Dali::Window* arg2 = (Dali::Window*)jarg2;
3254   Dali::DevelWindow::MouseInOutEvent* arg3 = (Dali::DevelWindow::MouseInOutEvent*)jarg3;
3255
3256   if (!arg1) {
3257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Signal", 0);
3258     return ;
3259   }
3260
3261   if (!arg2) {
3262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
3263     return ;
3264   }
3265
3266   if (!arg3) {
3267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DevelWindow::MouseInOutEvent", 0);
3268     return ;
3269   }
3270
3271   {
3272     try {
3273       Dali_Signal_Window_MouseInOutEvent_Signal_Emit(arg1,*arg2,*arg3);
3274     } CALL_CATCH_EXCEPTION();
3275   }
3276
3277 }
3278
3279
3280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowMouseInOutEventSignal() {
3281   void * jresult ;
3282   Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *result = 0 ;
3283
3284   {
3285     try {
3286       result = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)new Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) >();
3287     } CALL_CATCH_EXCEPTION(0);
3288   }
3289
3290   jresult = (void *)result;
3291   return jresult;
3292 }
3293
3294
3295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowMouseInOutEventSignal(void * jarg1) {
3296   Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ;
3297
3298   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1;
3299   {
3300     try {
3301       delete arg1;
3302     } CALL_CATCH_EXCEPTION();
3303   }
3304
3305 }
3306
3307
3308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_MouseInOutEvent__SWIG_0(int jarg1, unsigned int jarg2, void * jarg3, unsigned int jarg4) {
3309   void * jresult ;
3310   Dali::DevelWindow::MouseInOutEvent::Type arg1 ;
3311   unsigned int arg2 ;
3312   Dali::Vector2 arg3 ;
3313   unsigned int arg4 ;
3314
3315   Dali::Vector2 *argp3 ;
3316
3317   Dali::DevelWindow::MouseInOutEvent *result = 0;
3318
3319   arg1 = static_cast<Dali::DevelWindow::MouseInOutEvent::Type>(jarg1);
3320   arg2 = (unsigned int)jarg2;
3321   argp3 = (Dali::Vector2 *)jarg3;
3322   if (!argp3) {
3323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
3324     return 0;
3325   }
3326   arg3 = *argp3;
3327   arg4 = (unsigned int)jarg4;
3328   {
3329     try {
3330       result = (Dali::DevelWindow::MouseInOutEvent *)new Dali::DevelWindow::MouseInOutEvent(arg1, arg2, arg3, arg4, Dali::Device::Class::NONE, Dali::Device::Subclass::NONE);
3331     } CALL_CATCH_EXCEPTION(0);
3332   }
3333
3334   jresult = (void *)result;
3335   return jresult;
3336 }
3337
3338
3339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MouseInOutEvent(void * jarg1) {
3340   Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ;
3341
3342   arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1;
3343   {
3344     try {
3345       delete arg1;
3346     } CALL_CATCH_EXCEPTION();
3347   }
3348
3349 }
3350
3351
3352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_type_get(void * jarg1) {
3353   int jresult ;
3354   Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ;
3355   Dali::DevelWindow::MouseInOutEvent::Type result;
3356
3357   arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1;
3358   {
3359     try {
3360       result = ((Dali::DevelWindow::MouseInOutEvent const *)arg1)->type;
3361     } CALL_CATCH_EXCEPTION(0);
3362   }
3363
3364   jresult = (int)result;
3365   return jresult;
3366 }
3367
3368
3369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_modifiers_get(void * jarg1) {
3370   unsigned int jresult ;
3371   Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ;
3372   unsigned int result;
3373
3374   arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1;
3375   {
3376     try {
3377       result = ((Dali::DevelWindow::MouseInOutEvent const *)arg1)->modifiers;
3378     } CALL_CATCH_EXCEPTION(0);
3379   }
3380
3381   jresult = result;
3382   return jresult;
3383 }
3384
3385
3386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MouseInOutEvent_point_get(void * jarg1) {
3387   void * jresult ;
3388   Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ;
3389   Dali::Vector2 *result = 0 ;
3390
3391   arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1;
3392   {
3393     try {
3394       result = (Dali::Vector2 *) &((Dali::DevelWindow::MouseInOutEvent const *)arg1)->point;
3395     } CALL_CATCH_EXCEPTION(0);
3396   }
3397
3398   jresult = (void *)result;
3399   return jresult;
3400 }
3401
3402
3403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_timeStamp_get(void * jarg1) {
3404   unsigned int jresult ;
3405   Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ;
3406   unsigned int result;
3407
3408   arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1;
3409   {
3410     try {
3411       result = ((Dali::DevelWindow::MouseInOutEvent const *)arg1)->timeStamp;
3412     } CALL_CATCH_EXCEPTION(0);
3413   }
3414
3415   jresult = result;
3416   return jresult;
3417 }
3418
3419
3420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_GetDeviceClass(void * jarg1) {
3421   int jresult ;
3422   Dali::DevelWindow::MouseInOutEvent *arg1 = 0 ;
3423   Dali::Device::Class::Type result;
3424
3425   arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1;
3426   if (!arg1) {
3427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelWindow::MouseInOutEvent const & type is null", 0);
3428     return 0;
3429   }
3430   {
3431     try {
3432       result = (Dali::Device::Class::Type)arg1->deviceClass;
3433     } CALL_CATCH_EXCEPTION(0);
3434   }
3435
3436   jresult = (int)result;
3437   return jresult;
3438 }
3439
3440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_GetDeviceSubClass(void * jarg1) {
3441   int jresult ;
3442   Dali::DevelWindow::MouseInOutEvent *arg1 = 0 ;
3443   Dali::Device::Subclass::Type result;
3444
3445   arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1;
3446   if (!arg1) {
3447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelWindow::MouseInOutEvent const & type is null", 0);
3448     return 0;
3449   }
3450   {
3451     try {
3452       result = (Dali::Device::Subclass::Type)arg1->deviceSubclass;
3453     } CALL_CATCH_EXCEPTION(0);
3454   }
3455
3456   jresult = (int)result;
3457   return jresult;
3458 }
3459
3460 /* Move Completed signal binding */
3461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Move_Completed_Signal(void* winHandle)
3462 {
3463   void *result;
3464   Dali::Window window;
3465   Dali::Window *win;
3466   Dali::DevelWindow::MoveCompletedSignalType* moveCompletedSignal;
3467
3468   win = (Dali::Window *)winHandle;
3469   if (!win) {
3470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
3471     return 0;
3472   }
3473   window = *win;
3474   {
3475     try {
3476       moveCompletedSignal = (Dali::DevelWindow::MoveCompletedSignalType *) &Dali::DevelWindow::MoveCompletedSignal(window);
3477     } CALL_CATCH_EXCEPTION(0);
3478   }
3479
3480   result = (void *)moveCompletedSignal;
3481   return result;
3482 }
3483
3484
3485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Move_Completed_Signal_Empty(void * signal)
3486 {
3487   unsigned int result;
3488   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
3489   bool flag;
3490
3491   moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
3492   {
3493     try {
3494       flag = (bool)Dali_Signal_Window_Move_Completed_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *)moveCompletedSignal);
3495     } CALL_CATCH_EXCEPTION(0);
3496   }
3497
3498   result = (unsigned int)flag;
3499   return result;
3500 }
3501
3502
3503 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Move_Completed_Signal_GetConnectionCount(void * signal) {
3504   unsigned long result;
3505   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
3506   std::size_t count;
3507
3508   moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
3509   {
3510     try {
3511       count = Dali_Signal_Window_Move_Completed_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *)moveCompletedSignal);
3512     } CALL_CATCH_EXCEPTION(0);
3513   }
3514
3515   result = (unsigned long)count;
3516   return result;
3517 }
3518
3519
3520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Move_Completed_Signal_Connect(void * signal, void * func) {
3521   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
3522   void (*functionPtr)(Dali::Window, Dali::Window::WindowPosition) = (void (*)(Dali::Window, Dali::Window::WindowPosition)) 0 ;
3523
3524   moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
3525   functionPtr = (void (*)(Dali::Window, Dali::Window::WindowPosition))func;
3526   {
3527     try {
3528       Dali_Signal_Window_Move_Completed_Signal_Connect(moveCompletedSignal, functionPtr);
3529     } CALL_CATCH_EXCEPTION();
3530   }
3531
3532 }
3533
3534
3535 SWIGEXPORT void SWIGSTDCALL CSharp_Move_Completed_Signal_Disconnect(void * signal, void * func) {
3536   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
3537   void (*functionPtr)(Dali::Window, Dali::Window::WindowPosition) = (void (*)(Dali::Window, Dali::Window::WindowPosition)) 0 ;
3538
3539   moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
3540   functionPtr = (void (*)(Dali::Window, Dali::Window::WindowPosition))func;
3541   {
3542     try {
3543       Dali_Signal_Window_Move_Completed_Signal_Disconnect(moveCompletedSignal, functionPtr);
3544     } CALL_CATCH_EXCEPTION();
3545   }
3546
3547 }
3548
3549
3550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Move_Completed_Signal_Emit(void * signal, void* winHandle, void * position) {
3551   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
3552   Dali::Window* win = (Dali::Window*)winHandle;
3553   Dali::Window window;
3554   Dali::Window::WindowPosition windowPosition;
3555   Dali::Window::WindowPosition *pPosition;
3556
3557   moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
3558   if (moveCompletedSignal == nullptr || window == nullptr) {
3559     DALI_LOG_ERROR("[ERR] moveCompletedSignal == nullptr or window == nullptr");
3560     return;
3561   }
3562
3563   pPosition = (Dali::Window::WindowPosition *)position;
3564   if (!pPosition) {
3565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
3566     return ;
3567   }
3568   window = *win;
3569   windowPosition = *pPosition;
3570   {
3571     try {
3572       Dali_Signal_Window_Move_Completed_Signal_Emit(moveCompletedSignal, window, windowPosition);
3573     } CALL_CATCH_EXCEPTION();
3574   }
3575
3576 }
3577
3578
3579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Move_Completed_Signal() {
3580   void * result ;
3581   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = 0 ;
3582
3583   {
3584     try {
3585       moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)new Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) >();
3586     } CALL_CATCH_EXCEPTION(0);
3587   }
3588
3589   result = (void *)moveCompletedSignal;
3590   return result;
3591 }
3592
3593
3594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Move_Completed_Signal(void * signal) {
3595   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
3596
3597   moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
3598   {
3599     try {
3600       delete moveCompletedSignal;
3601     } CALL_CATCH_EXCEPTION();
3602   }
3603
3604 }
3605
3606 /* Resized Completed signal binding */
3607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Resize_Completed_Signal(void* winHandle)
3608 {
3609   void *result;
3610   Dali::Window window;
3611   Dali::Window *win;
3612   Dali::DevelWindow::ResizeCompletedSignalType* resizeCompletedSignal;
3613
3614   win = (Dali::Window *)winHandle;
3615   if (!win) {
3616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
3617     return 0;
3618   }
3619   window = *win;
3620   {
3621     try {
3622       resizeCompletedSignal = (Dali::DevelWindow::ResizeCompletedSignalType *) &Dali::DevelWindow::ResizeCompletedSignal(window);
3623     } CALL_CATCH_EXCEPTION(0);
3624   }
3625
3626   result = (void *)resizeCompletedSignal;
3627   return result;
3628 }
3629
3630
3631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Resize_Completed_Signal_Empty(void * signal)
3632 {
3633   unsigned int result;
3634   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
3635   bool flag;
3636
3637   resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal;
3638   {
3639     try {
3640       flag = (bool)Dali_Signal_Window_Resize_Completed_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *)resizeCompletedSignal);
3641     } CALL_CATCH_EXCEPTION(0);
3642   }
3643
3644   result = (unsigned int)flag;
3645   return result;
3646 }
3647
3648
3649 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Resize_Completed_Signal_GetConnectionCount(void * signal) {
3650   unsigned long result;
3651   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
3652   std::size_t count;
3653
3654   resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal;
3655   {
3656     try {
3657       count = Dali_Signal_Window_Resize_Completed_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *)resizeCompletedSignal);
3658     } CALL_CATCH_EXCEPTION(0);
3659   }
3660
3661   result = (unsigned long)count;
3662   return result;
3663 }
3664
3665
3666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Resize_Completed_Signal_Connect(void * signal, void * func) {
3667   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
3668   void (*functionPtr)(Dali::Window, Dali::Window::WindowSize) = (void (*)(Dali::Window, Dali::Window::WindowSize)) 0 ;
3669
3670   resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal;
3671   functionPtr = (void (*)(Dali::Window, Dali::Window::WindowSize))func;
3672   {
3673     try {
3674       Dali_Signal_Window_Resize_Completed_Signal_Connect(resizeCompletedSignal, functionPtr);
3675     } CALL_CATCH_EXCEPTION();
3676   }
3677
3678 }
3679
3680
3681 SWIGEXPORT void SWIGSTDCALL CSharp_Resize_Completed_Signal_Disconnect(void * signal, void * func) {
3682   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
3683   void (*functionPtr)(Dali::Window, Dali::Window::WindowSize) = (void (*)(Dali::Window, Dali::Window::WindowSize)) 0 ;
3684
3685   resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal;
3686   functionPtr = (void (*)(Dali::Window, Dali::Window::WindowSize))func;
3687   {
3688     try {
3689       Dali_Signal_Window_Resize_Completed_Signal_Disconnect(resizeCompletedSignal, functionPtr);
3690     } CALL_CATCH_EXCEPTION();
3691   }
3692
3693 }
3694
3695
3696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Resize_Completed_Signal_Emit(void * signal, void* winHandle, void * size) {
3697   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
3698   Dali::Window* win = (Dali::Window*)winHandle;
3699   Dali::Window window;
3700   Dali::Window::WindowSize windowSize;
3701   Dali::Window::WindowSize *pSize;
3702
3703   resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal;
3704   if (resizeCompletedSignal == nullptr || window == nullptr) {
3705     DALI_LOG_ERROR("[ERR] resizeCompletedSignal == nullptr or window == nullptr");
3706     return;
3707   }
3708
3709   pSize = (Dali::Window::WindowSize *)size;
3710   if (!pSize) {
3711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
3712     return ;
3713   }
3714   window = *win;
3715   windowSize = *pSize;
3716   {
3717     try {
3718       Dali_Signal_Window_Resize_Completed_Signal_Emit(resizeCompletedSignal, window, windowSize);
3719     } CALL_CATCH_EXCEPTION();
3720   }
3721
3722 }
3723
3724
3725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Resize_Completed_Signal() {
3726   void * result ;
3727   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = 0 ;
3728
3729   {
3730     try {
3731       resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)new Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) >();
3732     } CALL_CATCH_EXCEPTION(0);
3733   }
3734
3735   result = (void *)resizeCompletedSignal;
3736   return result;
3737 }
3738
3739
3740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Resize_Completed_Signal(void * signal) {
3741   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
3742
3743   resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal;
3744   {
3745     try {
3746       delete resizeCompletedSignal;
3747     } CALL_CATCH_EXCEPTION();
3748   }
3749
3750 }
3751
3752
3753 #ifdef __cplusplus
3754 }
3755 #endif