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

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