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

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