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

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