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

   1 /*
   2  * Copyright (c) 2022 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 bool SWIGSTDCALL CSharp_Dali_Window_IsFloatingModeEnabled(void* winHandle)
2610 {
2611   Dali::Window* window = (Dali::Window*)winHandle;
2612   bool result = false;
2613   if (!window) {
2614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2615     return false;
2616   }
2617
2618   {
2619     try {
2620       result = Dali::DevelWindow::IsFloatingModeEnabled(*window);
2621     } CALL_CATCH_EXCEPTION(0);
2622   }
2623   return result;
2624
2625 }
2626
2627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_IncludeInputRegion(void* winHandle, void* region)
2628 {
2629   Dali::Window* window = (Dali::Window*)winHandle;
2630   Dali::Rect<int> *addedRegion = (Dali::Rect<int> *)region;
2631   if (!window) {
2632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2633     return;
2634   }
2635   {
2636     try {
2637       Dali::DevelWindow::IncludeInputRegion(*window, *addedRegion);
2638     } CALL_CATCH_EXCEPTION();
2639   }
2640
2641 }
2642
2643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ExcludeInputRegion(void* winHandle, void* region)
2644 {
2645   Dali::Window* window = (Dali::Window*)winHandle;
2646   Dali::Rect<int> *subtractedRegion = (Dali::Rect<int> *)region;
2647   if (!window) {
2648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2649     return;
2650   }
2651   {
2652     try {
2653       Dali::DevelWindow::ExcludeInputRegion(*window, *subtractedRegion);
2654     } CALL_CATCH_EXCEPTION();
2655   }
2656
2657 }
2658
2659 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal(void* winHandle) {
2660   Dali::Window* window = (Dali::Window*) winHandle;
2661   Dali::DevelWindow::AccessibilityHighlightSignalType* result = 0;
2662
2663   {
2664     try {
2665       result = (Dali::DevelWindow::AccessibilityHighlightSignalType*) &( Dali::DevelWindow::AccessibilityHighlightSignal(*window) );
2666     }
2667     CALL_CATCH_EXCEPTION(0);
2668   }
2669   return (void*)result;
2670 }
2671
2672 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_Empty(void* accessibilityHighlightSignalTypeHandle) {
2673   bool result;
2674   Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType*) accessibilityHighlightSignalTypeHandle;
2675
2676   if (accessibilityHighlightSignalType == nullptr) {
2677     DALI_LOG_ERROR("[ERR] accessibilityHighlightSignalType == nullptr");
2678     return false;
2679   }
2680
2681   {
2682     try {
2683       result = accessibilityHighlightSignalType->Empty();
2684     }
2685     CALL_CATCH_EXCEPTION(false);
2686   }
2687   return result;
2688 }
2689
2690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_GetConnectionCount(void* accessibilityHighlightSignalTypeHandle) {
2691   unsigned int result;
2692   Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType *) accessibilityHighlightSignalTypeHandle;
2693
2694   if (accessibilityHighlightSignalType == nullptr) {
2695     DALI_LOG_ERROR("[ERR] accessibilityHighlightSignalType == nullptr");
2696     return 0;
2697   }
2698
2699   {
2700     try {
2701       result = accessibilityHighlightSignalType->GetConnectionCount();
2702     }
2703     CALL_CATCH_EXCEPTION(0);
2704   }
2705   return result;
2706 }
2707
2708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_Connect(void* accessibilityHighlightSignalTypeHandle, void* winHandle) {
2709   Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType *)accessibilityHighlightSignalTypeHandle;
2710   void (*window)(Dali::Window, bool) = ( void (*)(Dali::Window, bool) )winHandle;
2711
2712   if (accessibilityHighlightSignalType == nullptr) {
2713     DALI_LOG_ERROR("[ERR] accessibilityHighlightSignalType == nullptr");
2714     return ;
2715   }
2716
2717   {
2718     try {
2719       accessibilityHighlightSignalType->Connect(window);
2720     }
2721     CALL_CATCH_EXCEPTION();
2722   }
2723   return ;
2724 }
2725
2726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_Disconnect(void* accessibilityHighlightSignalTypeHandle, void* winHandle) {
2727   Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType*)accessibilityHighlightSignalTypeHandle;
2728   void (*window)(Dali::Window, bool) = (void (*)(Dali::Window, bool))winHandle;
2729
2730   if (accessibilityHighlightSignalType == nullptr) {
2731     DALI_LOG_ERROR("[ERR] accessibilityHighlightSignalType == nullptr");
2732     return;
2733   }
2734
2735   {
2736     try {
2737       accessibilityHighlightSignalType->Disconnect(window);
2738     }
2739     CALL_CATCH_EXCEPTION();
2740   }
2741   return;
2742 }
2743
2744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_delete(void* accessibilityHighlightSignalTypeHandle) {
2745   Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType*)accessibilityHighlightSignalTypeHandle;
2746
2747   {
2748     try {
2749       delete accessibilityHighlightSignalType;
2750     }
2751     CALL_CATCH_EXCEPTION();
2752   }
2753   return;
2754 }
2755
2756 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_IsWindowRotating(void* winHandle)
2757 {
2758   Dali::Window* window = (Dali::Window*)winHandle;
2759   bool result = false;
2760   if (!window) {
2761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2762     return result;
2763   }
2764   {
2765     try {
2766       result = Dali::DevelWindow::IsWindowRotating(*window);
2767     } CALL_CATCH_EXCEPTION(false);
2768   }
2769
2770   return result;
2771 }
2772
2773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetLastKeyEvent(void* winHandle)
2774 {
2775   Dali::Window* window = (Dali::Window*)winHandle;
2776   void * jresult;
2777   Dali::KeyEvent *result = 0;
2778   if (!window) {
2779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2780     return 0;
2781   }
2782   {
2783     try {
2784       result = (Dali::KeyEvent *)&Dali::DevelWindow::GetLastKeyEvent(*window);
2785     } CALL_CATCH_EXCEPTION(0);
2786   }
2787   jresult = (void *)result;
2788   return jresult;
2789 }
2790
2791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetLastTouchEvent(void* winHandle)
2792 {
2793   Dali::Window* window = (Dali::Window*)winHandle;
2794   void * jresult;
2795   Dali::TouchEvent *result = 0;
2796   if (!window) {
2797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2798     return 0;
2799   }
2800   {
2801     try {
2802       result = (Dali::TouchEvent *)&Dali::DevelWindow::GetLastTouchEvent(*window);
2803     } CALL_CATCH_EXCEPTION(0);
2804   }
2805   jresult = (void *)result;
2806   return jresult;
2807 }
2808
2809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetNeedsRotationCompletedAcknowledgement(void* winHandle, bool needAcknowledgement)
2810 {
2811   Dali::Window* window = (Dali::Window*)winHandle;
2812   if (!window) {
2813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2814     return;
2815   }
2816   {
2817     try {
2818       Dali::DevelWindow::SetNeedsRotationCompletedAcknowledgement(*window, needAcknowledgement);
2819     } CALL_CATCH_EXCEPTION();
2820   }
2821 }
2822
2823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SendRotationCompletedAcknowledgement(void* winHandle)
2824 {
2825   Dali::Window* window = (Dali::Window*)winHandle;
2826   if (!window) {
2827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2828     return;
2829   }
2830   {
2831     try {
2832       Dali::DevelWindow::SendRotationCompletedAcknowledgement(*window);
2833     } CALL_CATCH_EXCEPTION();
2834   }
2835 }
2836
2837 /* Moved signal binding */
2838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Moved_Signal(void* winHandle)
2839 {
2840   void *result;
2841   Dali::Window window;
2842   Dali::Window *win;
2843   Dali::DevelWindow::MovedSignalType* movedSignal;
2844
2845   win = (Dali::Window *)winHandle;
2846   if (!win) {
2847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2848     return 0;
2849   }
2850   window = *win;
2851   {
2852     try {
2853       movedSignal = (Dali::DevelWindow::MovedSignalType *) &Dali::DevelWindow::MovedSignal(window);
2854     } CALL_CATCH_EXCEPTION(0);
2855   }
2856
2857   result = (void *)movedSignal;
2858   return result;
2859 }
2860
2861
2862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Moved_Signal_Empty(void * signal)
2863 {
2864   unsigned int result;
2865   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
2866   bool flag;
2867
2868   movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
2869   {
2870     try {
2871       flag = (bool)Dali_Signal_Window_Moved_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *)movedSignal);
2872     } CALL_CATCH_EXCEPTION(0);
2873   }
2874
2875   result = (unsigned int)flag;
2876   return result;
2877 }
2878
2879
2880 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Moved_Signal_GetConnectionCount(void * signal) {
2881   unsigned long result;
2882   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
2883   std::size_t count;
2884
2885   movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
2886   {
2887     try {
2888       count = Dali_Signal_Window_Moved_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *)movedSignal);
2889     } CALL_CATCH_EXCEPTION(0);
2890   }
2891
2892   result = (unsigned long)count;
2893   return result;
2894 }
2895
2896
2897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Moved_Signal_Connect(void * signal, void * func) {
2898   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
2899   void (*functionPtr)(Dali::Window, Dali::Window::WindowPosition) = (void (*)(Dali::Window, Dali::Window::WindowPosition)) 0 ;
2900
2901   movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
2902   functionPtr = (void (*)(Dali::Window, Dali::Window::WindowPosition))func;
2903   {
2904     try {
2905       Dali_Signal_Window_Moved_Signal_Connect(movedSignal, functionPtr);
2906     } CALL_CATCH_EXCEPTION();
2907   }
2908
2909 }
2910
2911
2912 SWIGEXPORT void SWIGSTDCALL CSharp_Moved_Signal_Disconnect(void * signal, void * func) {
2913   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
2914   void (*functionPtr)(Dali::Window, Dali::Window::WindowPosition) = (void (*)(Dali::Window, Dali::Window::WindowPosition)) 0 ;
2915
2916   movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
2917   functionPtr = (void (*)(Dali::Window, Dali::Window::WindowPosition))func;
2918   {
2919     try {
2920       Dali_Signal_Window_Moved_Signal_Disconnect(movedSignal, functionPtr);
2921     } CALL_CATCH_EXCEPTION();
2922   }
2923
2924 }
2925
2926
2927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Moved_Signal_Emit(void * signal, void* winHandle, void * position) {
2928   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
2929   Dali::Window* win = (Dali::Window*)winHandle;
2930   Dali::Window window;
2931   Dali::Window::WindowPosition windowPosition;
2932   Dali::Window::WindowPosition *pPosition;
2933
2934   movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
2935   if (movedSignal == nullptr || window == nullptr) {
2936     DALI_LOG_ERROR("[ERR] movedSignal == nullptr or window == nullptr");
2937     return;
2938   }
2939
2940   pPosition = (Dali::Window::WindowPosition *)position;
2941   if (!pPosition) {
2942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
2943     return ;
2944   }
2945   window = *win;
2946   windowPosition = *pPosition;
2947   {
2948     try {
2949       Dali_Signal_Window_Moved_Signal_Emit(movedSignal, window, windowPosition);
2950     } CALL_CATCH_EXCEPTION();
2951   }
2952
2953 }
2954
2955
2956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Moved_Signal() {
2957   void * result ;
2958   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = 0 ;
2959
2960   {
2961     try {
2962       movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)new Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) >();
2963     } CALL_CATCH_EXCEPTION(0);
2964   }
2965
2966   result = (void *)movedSignal;
2967   return result;
2968 }
2969
2970
2971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Moved_Signal(void * signal) {
2972   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
2973
2974   movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
2975   {
2976     try {
2977       delete movedSignal;
2978     } CALL_CATCH_EXCEPTION();
2979   }
2980
2981 }
2982
2983 /* Orientation Changed signal binding */
2984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Orientation_Changed_Signal(void* winHandle)
2985 {
2986   void *result;
2987   Dali::Window window;
2988   Dali::Window *win;
2989   Dali::DevelWindow::OrientationChangedSignalType* orientationChangedSignal;
2990
2991   win = (Dali::Window *)winHandle;
2992   if (!win) {
2993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
2994     return 0;
2995   }
2996   window = *win;
2997   {
2998     try {
2999       orientationChangedSignal = (Dali::DevelWindow::OrientationChangedSignalType *) &Dali::DevelWindow::OrientationChangedSignal(window);
3000     } CALL_CATCH_EXCEPTION(0);
3001   }
3002
3003   result = (void *)orientationChangedSignal;
3004   return result;
3005 }
3006
3007
3008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Orientation_Changed_Signal_Empty(void * signal)
3009 {
3010   unsigned int result;
3011   Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ;
3012   bool flag;
3013
3014   orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal;
3015   {
3016     try {
3017       flag = (bool)Dali_Signal_Window_Orientation_Changed_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > const *)orientationChangedSignal);
3018     } CALL_CATCH_EXCEPTION(0);
3019   }
3020
3021   result = (unsigned int)flag;
3022   return result;
3023 }
3024
3025
3026 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Orientation_Changed_Signal_GetConnectionCount(void * signal) {
3027   unsigned long result;
3028   Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ;
3029   std::size_t count;
3030
3031   orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal;
3032   {
3033     try {
3034       count = Dali_Signal_Window_Orientation_Changed_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > const *)orientationChangedSignal);
3035     } CALL_CATCH_EXCEPTION(0);
3036   }
3037
3038   result = (unsigned long)count;
3039   return result;
3040 }
3041
3042
3043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Orientation_Changed_Signal_Connect(void * signal, void * func) {
3044   Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ;
3045   void (*functionPtr)(Dali::Window, Dali::WindowOrientation) = (void (*)(Dali::Window, Dali::WindowOrientation)) 0 ;
3046
3047   orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal;
3048   functionPtr = (void (*)(Dali::Window, Dali::WindowOrientation))func;
3049   {
3050     try {
3051       Dali_Signal_Window_Orientation_Changed_Signal_Connect(orientationChangedSignal, functionPtr);
3052     } CALL_CATCH_EXCEPTION();
3053   }
3054
3055 }
3056
3057
3058 SWIGEXPORT void SWIGSTDCALL CSharp_Orientation_Changed_Signal_Disconnect(void * signal, void * func) {
3059   Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ;
3060   void (*functionPtr)(Dali::Window, Dali::WindowOrientation) = (void (*)(Dali::Window, Dali::WindowOrientation)) 0 ;
3061
3062   orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal;
3063   functionPtr = (void (*)(Dali::Window, Dali::WindowOrientation))func;
3064   {
3065     try {
3066       Dali_Signal_Window_Orientation_Changed_Signal_Disconnect(orientationChangedSignal, functionPtr);
3067     } CALL_CATCH_EXCEPTION();
3068   }
3069
3070 }
3071
3072
3073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Orientation_Changed_Signal_Emit(void * signal, void* winHandle, int orientation) {
3074   Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ;
3075   Dali::Window* win = (Dali::Window*)winHandle;
3076   Dali::Window window;
3077   Dali::WindowOrientation windowOrientation;
3078
3079   orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal;
3080   if (orientationChangedSignal == nullptr || window == nullptr) {
3081     DALI_LOG_ERROR("[ERR] orientationChangedSignal == nullptr or window == nullptr");
3082     return;
3083   }
3084
3085   window = *win;
3086   windowOrientation = static_cast<Dali::WindowOrientation>(orientation);
3087   {
3088     try {
3089       Dali_Signal_Window_Orientation_Changed_Signal_Emit(orientationChangedSignal, window, windowOrientation);
3090     } CALL_CATCH_EXCEPTION();
3091   }
3092
3093 }
3094
3095
3096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Orientation_Changed_Signal() {
3097   void * result ;
3098   Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = 0 ;
3099
3100   {
3101     try {
3102       orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)new Dali::Signal< void (Dali::Window, Dali::WindowOrientation) >();
3103     } CALL_CATCH_EXCEPTION(0);
3104   }
3105
3106   result = (void *)orientationChangedSignal;
3107   return result;
3108 }
3109
3110
3111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Orientation_Changed_Signal(void * signal) {
3112   Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ;
3113
3114   orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal;
3115   {
3116     try {
3117       delete orientationChangedSignal;
3118     } CALL_CATCH_EXCEPTION();
3119   }
3120
3121 }
3122
3123 //
3124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal(void* winHandle)
3125 {
3126   void *result;
3127   Dali::Window window;
3128   Dali::Window *win;
3129   Dali::DevelWindow::MouseInOutEventSignalType* mouseInOutSignal;
3130
3131   win = (Dali::Window *)winHandle;
3132   if (!win) {
3133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
3134     return 0;
3135   }
3136   window = *win;
3137   {
3138     try {
3139       mouseInOutSignal = (Dali::DevelWindow::MouseInOutEventSignalType *) &Dali::DevelWindow::MouseInOutEventSignal(window);
3140     } CALL_CATCH_EXCEPTION(0);
3141   }
3142
3143   result = (void *)mouseInOutSignal;
3144   return result;
3145 }
3146
3147
3148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_Empty(void * jarg1) {
3149   unsigned int jresult ;
3150   Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ;
3151   bool result;
3152
3153   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1;
3154   {
3155     try {
3156       result = (bool)Dali_Signal_Window_MouseInOutEvent_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > const *)arg1);
3157     } CALL_CATCH_EXCEPTION(0);
3158   }
3159
3160   jresult = result;
3161   return jresult;
3162 }
3163
3164
3165 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_GetConnectionCount(void * jarg1) {
3166   unsigned long jresult ;
3167   Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ;
3168   std::size_t result;
3169
3170   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1;
3171   {
3172     try {
3173       result = Dali_Signal_Window_MouseInOutEvent_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > const *)arg1);
3174     } CALL_CATCH_EXCEPTION(0);
3175   }
3176
3177   jresult = (unsigned long)result;
3178   return jresult;
3179 }
3180
3181
3182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_Connect(void * jarg1, void * jarg2) {
3183   Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ;
3184   void (*arg2)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) = (void (*)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &)) 0 ;
3185
3186   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1;
3187   arg2 = (void (*)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &))jarg2;
3188   {
3189     try {
3190       Dali_Signal_Window_MouseInOutEvent_Signal_Connect(arg1,arg2);
3191     } CALL_CATCH_EXCEPTION();
3192   }
3193
3194 }
3195
3196
3197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_Disconnect(void * jarg1, void * jarg2) {
3198   Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ;
3199   void (*arg2)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) = (void (*)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &)) 0 ;
3200
3201   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1;
3202   arg2 = (void (*)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &))jarg2;
3203   {
3204     try {
3205       Dali_Signal_Window_MouseInOutEvent_Signal_Disconnect(arg1,arg2);
3206     } CALL_CATCH_EXCEPTION();
3207   }
3208
3209 }
3210
3211
3212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_Emit(void * jarg1, void* jarg2, void* jarg3) {
3213   Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1;
3214   Dali::Window* arg2 = (Dali::Window*)jarg2;
3215   Dali::DevelWindow::MouseInOutEvent* arg3 = (Dali::DevelWindow::MouseInOutEvent*)jarg3;
3216
3217   if (!arg1) {
3218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Signal", 0);
3219     return ;
3220   }
3221
3222   if (!arg2) {
3223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
3224     return ;
3225   }
3226
3227   if (!arg3) {
3228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DevelWindow::MouseInOutEvent", 0);
3229     return ;
3230   }
3231
3232   {
3233     try {
3234       Dali_Signal_Window_MouseInOutEvent_Signal_Emit(arg1,*arg2,*arg3);
3235     } CALL_CATCH_EXCEPTION();
3236   }
3237
3238 }
3239
3240
3241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowMouseInOutEventSignal() {
3242   void * jresult ;
3243   Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *result = 0 ;
3244
3245   {
3246     try {
3247       result = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)new Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) >();
3248     } CALL_CATCH_EXCEPTION(0);
3249   }
3250
3251   jresult = (void *)result;
3252   return jresult;
3253 }
3254
3255
3256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowMouseInOutEventSignal(void * jarg1) {
3257   Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ;
3258
3259   arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1;
3260   {
3261     try {
3262       delete arg1;
3263     } CALL_CATCH_EXCEPTION();
3264   }
3265
3266 }
3267
3268
3269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_MouseInOutEvent__SWIG_0(int jarg1, unsigned int jarg2, void * jarg3, unsigned int jarg4) {
3270   void * jresult ;
3271   Dali::DevelWindow::MouseInOutEvent::Type arg1 ;
3272   unsigned int arg2 ;
3273   Dali::Vector2 arg3 ;
3274   unsigned int arg4 ;
3275
3276   Dali::Vector2 *argp3 ;
3277
3278   Dali::DevelWindow::MouseInOutEvent *result = 0;
3279
3280   arg1 = static_cast<Dali::DevelWindow::MouseInOutEvent::Type>(jarg1);
3281   arg2 = (unsigned int)jarg2;
3282   argp3 = (Dali::Vector2 *)jarg3;
3283   if (!argp3) {
3284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
3285     return 0;
3286   }
3287   arg3 = *argp3;
3288   arg4 = (unsigned int)jarg4;
3289   {
3290     try {
3291       result = (Dali::DevelWindow::MouseInOutEvent *)new Dali::DevelWindow::MouseInOutEvent(arg1, arg2, arg3, arg4, Dali::Device::Class::NONE, Dali::Device::Subclass::NONE);
3292     } CALL_CATCH_EXCEPTION(0);
3293   }
3294
3295   jresult = (void *)result;
3296   return jresult;
3297 }
3298
3299
3300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MouseInOutEvent(void * jarg1) {
3301   Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ;
3302
3303   arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1;
3304   {
3305     try {
3306       delete arg1;
3307     } CALL_CATCH_EXCEPTION();
3308   }
3309
3310 }
3311
3312
3313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_type_get(void * jarg1) {
3314   int jresult ;
3315   Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ;
3316   Dali::DevelWindow::MouseInOutEvent::Type result;
3317
3318   arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1;
3319   {
3320     try {
3321       result = ((Dali::DevelWindow::MouseInOutEvent const *)arg1)->type;
3322     } CALL_CATCH_EXCEPTION(0);
3323   }
3324
3325   jresult = (int)result;
3326   return jresult;
3327 }
3328
3329
3330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_modifiers_get(void * jarg1) {
3331   unsigned int jresult ;
3332   Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ;
3333   unsigned int result;
3334
3335   arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1;
3336   {
3337     try {
3338       result = ((Dali::DevelWindow::MouseInOutEvent const *)arg1)->modifiers;
3339     } CALL_CATCH_EXCEPTION(0);
3340   }
3341
3342   jresult = result;
3343   return jresult;
3344 }
3345
3346
3347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MouseInOutEvent_point_get(void * jarg1) {
3348   void * jresult ;
3349   Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ;
3350   Dali::Vector2 *result = 0 ;
3351
3352   arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1;
3353   {
3354     try {
3355       result = (Dali::Vector2 *) &((Dali::DevelWindow::MouseInOutEvent const *)arg1)->point;
3356     } CALL_CATCH_EXCEPTION(0);
3357   }
3358
3359   jresult = (void *)result;
3360   return jresult;
3361 }
3362
3363
3364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_timeStamp_get(void * jarg1) {
3365   unsigned int jresult ;
3366   Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ;
3367   unsigned int result;
3368
3369   arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1;
3370   {
3371     try {
3372       result = ((Dali::DevelWindow::MouseInOutEvent const *)arg1)->timeStamp;
3373     } CALL_CATCH_EXCEPTION(0);
3374   }
3375
3376   jresult = result;
3377   return jresult;
3378 }
3379
3380
3381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_GetDeviceClass(void * jarg1) {
3382   int jresult ;
3383   Dali::DevelWindow::MouseInOutEvent *arg1 = 0 ;
3384   Dali::Device::Class::Type result;
3385
3386   arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1;
3387   if (!arg1) {
3388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelWindow::MouseInOutEvent const & type is null", 0);
3389     return 0;
3390   }
3391   {
3392     try {
3393       result = (Dali::Device::Class::Type)arg1->deviceClass;
3394     } CALL_CATCH_EXCEPTION(0);
3395   }
3396
3397   jresult = (int)result;
3398   return jresult;
3399 }
3400
3401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_GetDeviceSubClass(void * jarg1) {
3402   int jresult ;
3403   Dali::DevelWindow::MouseInOutEvent *arg1 = 0 ;
3404   Dali::Device::Subclass::Type result;
3405
3406   arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1;
3407   if (!arg1) {
3408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelWindow::MouseInOutEvent const & type is null", 0);
3409     return 0;
3410   }
3411   {
3412     try {
3413       result = (Dali::Device::Subclass::Type)arg1->deviceSubclass;
3414     } CALL_CATCH_EXCEPTION(0);
3415   }
3416
3417   jresult = (int)result;
3418   return jresult;
3419 }
3420
3421 /* Move Completed signal binding */
3422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Move_Completed_Signal(void* winHandle)
3423 {
3424   void *result;
3425   Dali::Window window;
3426   Dali::Window *win;
3427   Dali::DevelWindow::MoveCompletedSignalType* moveCompletedSignal;
3428
3429   win = (Dali::Window *)winHandle;
3430   if (!win) {
3431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
3432     return 0;
3433   }
3434   window = *win;
3435   {
3436     try {
3437       moveCompletedSignal = (Dali::DevelWindow::MoveCompletedSignalType *) &Dali::DevelWindow::MoveCompletedSignal(window);
3438     } CALL_CATCH_EXCEPTION(0);
3439   }
3440
3441   result = (void *)moveCompletedSignal;
3442   return result;
3443 }
3444
3445
3446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Move_Completed_Signal_Empty(void * signal)
3447 {
3448   unsigned int result;
3449   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
3450   bool flag;
3451
3452   moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
3453   {
3454     try {
3455       flag = (bool)Dali_Signal_Window_Move_Completed_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *)moveCompletedSignal);
3456     } CALL_CATCH_EXCEPTION(0);
3457   }
3458
3459   result = (unsigned int)flag;
3460   return result;
3461 }
3462
3463
3464 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Move_Completed_Signal_GetConnectionCount(void * signal) {
3465   unsigned long result;
3466   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
3467   std::size_t count;
3468
3469   moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
3470   {
3471     try {
3472       count = Dali_Signal_Window_Move_Completed_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *)moveCompletedSignal);
3473     } CALL_CATCH_EXCEPTION(0);
3474   }
3475
3476   result = (unsigned long)count;
3477   return result;
3478 }
3479
3480
3481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Move_Completed_Signal_Connect(void * signal, void * func) {
3482   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
3483   void (*functionPtr)(Dali::Window, Dali::Window::WindowPosition) = (void (*)(Dali::Window, Dali::Window::WindowPosition)) 0 ;
3484
3485   moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
3486   functionPtr = (void (*)(Dali::Window, Dali::Window::WindowPosition))func;
3487   {
3488     try {
3489       Dali_Signal_Window_Move_Completed_Signal_Connect(moveCompletedSignal, functionPtr);
3490     } CALL_CATCH_EXCEPTION();
3491   }
3492
3493 }
3494
3495
3496 SWIGEXPORT void SWIGSTDCALL CSharp_Move_Completed_Signal_Disconnect(void * signal, void * func) {
3497   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
3498   void (*functionPtr)(Dali::Window, Dali::Window::WindowPosition) = (void (*)(Dali::Window, Dali::Window::WindowPosition)) 0 ;
3499
3500   moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
3501   functionPtr = (void (*)(Dali::Window, Dali::Window::WindowPosition))func;
3502   {
3503     try {
3504       Dali_Signal_Window_Move_Completed_Signal_Disconnect(moveCompletedSignal, functionPtr);
3505     } CALL_CATCH_EXCEPTION();
3506   }
3507
3508 }
3509
3510
3511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Move_Completed_Signal_Emit(void * signal, void* winHandle, void * position) {
3512   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
3513   Dali::Window* win = (Dali::Window*)winHandle;
3514   Dali::Window window;
3515   Dali::Window::WindowPosition windowPosition;
3516   Dali::Window::WindowPosition *pPosition;
3517
3518   moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
3519   if (moveCompletedSignal == nullptr || window == nullptr) {
3520     DALI_LOG_ERROR("[ERR] moveCompletedSignal == nullptr or window == nullptr");
3521     return;
3522   }
3523
3524   pPosition = (Dali::Window::WindowPosition *)position;
3525   if (!pPosition) {
3526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
3527     return ;
3528   }
3529   window = *win;
3530   windowPosition = *pPosition;
3531   {
3532     try {
3533       Dali_Signal_Window_Move_Completed_Signal_Emit(moveCompletedSignal, window, windowPosition);
3534     } CALL_CATCH_EXCEPTION();
3535   }
3536
3537 }
3538
3539
3540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Move_Completed_Signal() {
3541   void * result ;
3542   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = 0 ;
3543
3544   {
3545     try {
3546       moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)new Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) >();
3547     } CALL_CATCH_EXCEPTION(0);
3548   }
3549
3550   result = (void *)moveCompletedSignal;
3551   return result;
3552 }
3553
3554
3555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Move_Completed_Signal(void * signal) {
3556   Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ;
3557
3558   moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal;
3559   {
3560     try {
3561       delete moveCompletedSignal;
3562     } CALL_CATCH_EXCEPTION();
3563   }
3564
3565 }
3566
3567 /* Resized Completed signal binding */
3568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Resize_Completed_Signal(void* winHandle)
3569 {
3570   void *result;
3571   Dali::Window window;
3572   Dali::Window *win;
3573   Dali::DevelWindow::ResizeCompletedSignalType* resizeCompletedSignal;
3574
3575   win = (Dali::Window *)winHandle;
3576   if (!win) {
3577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
3578     return 0;
3579   }
3580   window = *win;
3581   {
3582     try {
3583       resizeCompletedSignal = (Dali::DevelWindow::ResizeCompletedSignalType *) &Dali::DevelWindow::ResizeCompletedSignal(window);
3584     } CALL_CATCH_EXCEPTION(0);
3585   }
3586
3587   result = (void *)resizeCompletedSignal;
3588   return result;
3589 }
3590
3591
3592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Resize_Completed_Signal_Empty(void * signal)
3593 {
3594   unsigned int result;
3595   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
3596   bool flag;
3597
3598   resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal;
3599   {
3600     try {
3601       flag = (bool)Dali_Signal_Window_Resize_Completed_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *)resizeCompletedSignal);
3602     } CALL_CATCH_EXCEPTION(0);
3603   }
3604
3605   result = (unsigned int)flag;
3606   return result;
3607 }
3608
3609
3610 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Resize_Completed_Signal_GetConnectionCount(void * signal) {
3611   unsigned long result;
3612   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
3613   std::size_t count;
3614
3615   resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal;
3616   {
3617     try {
3618       count = Dali_Signal_Window_Resize_Completed_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *)resizeCompletedSignal);
3619     } CALL_CATCH_EXCEPTION(0);
3620   }
3621
3622   result = (unsigned long)count;
3623   return result;
3624 }
3625
3626
3627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Resize_Completed_Signal_Connect(void * signal, void * func) {
3628   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
3629   void (*functionPtr)(Dali::Window, Dali::Window::WindowSize) = (void (*)(Dali::Window, Dali::Window::WindowSize)) 0 ;
3630
3631   resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal;
3632   functionPtr = (void (*)(Dali::Window, Dali::Window::WindowSize))func;
3633   {
3634     try {
3635       Dali_Signal_Window_Resize_Completed_Signal_Connect(resizeCompletedSignal, functionPtr);
3636     } CALL_CATCH_EXCEPTION();
3637   }
3638
3639 }
3640
3641
3642 SWIGEXPORT void SWIGSTDCALL CSharp_Resize_Completed_Signal_Disconnect(void * signal, void * func) {
3643   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
3644   void (*functionPtr)(Dali::Window, Dali::Window::WindowSize) = (void (*)(Dali::Window, Dali::Window::WindowSize)) 0 ;
3645
3646   resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal;
3647   functionPtr = (void (*)(Dali::Window, Dali::Window::WindowSize))func;
3648   {
3649     try {
3650       Dali_Signal_Window_Resize_Completed_Signal_Disconnect(resizeCompletedSignal, functionPtr);
3651     } CALL_CATCH_EXCEPTION();
3652   }
3653
3654 }
3655
3656
3657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Resize_Completed_Signal_Emit(void * signal, void* winHandle, void * size) {
3658   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
3659   Dali::Window* win = (Dali::Window*)winHandle;
3660   Dali::Window window;
3661   Dali::Window::WindowSize windowSize;
3662   Dali::Window::WindowSize *pSize;
3663
3664   resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal;
3665   if (resizeCompletedSignal == nullptr || window == nullptr) {
3666     DALI_LOG_ERROR("[ERR] resizeCompletedSignal == nullptr or window == nullptr");
3667     return;
3668   }
3669
3670   pSize = (Dali::Window::WindowSize *)size;
3671   if (!pSize) {
3672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
3673     return ;
3674   }
3675   window = *win;
3676   windowSize = *pSize;
3677   {
3678     try {
3679       Dali_Signal_Window_Resize_Completed_Signal_Emit(resizeCompletedSignal, window, windowSize);
3680     } CALL_CATCH_EXCEPTION();
3681   }
3682
3683 }
3684
3685
3686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Resize_Completed_Signal() {
3687   void * result ;
3688   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = 0 ;
3689
3690   {
3691     try {
3692       resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)new Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) >();
3693     } CALL_CATCH_EXCEPTION(0);
3694   }
3695
3696   result = (void *)resizeCompletedSignal;
3697   return result;
3698 }
3699
3700
3701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Resize_Completed_Signal(void * signal) {
3702   Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ;
3703
3704   resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal;
3705   {
3706     try {
3707       delete resizeCompletedSignal;
3708     } CALL_CATCH_EXCEPTION();
3709   }
3710
3711 }
3712
3713
3714 #ifdef __cplusplus
3715 }
3716 #endif