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

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