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