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

   1 /*
   2  * Copyright (c) 2020 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/devel-api/adaptor-framework/gl-window.h>
  20 #include <dali/integration-api/adaptor-framework/adaptor.h>
  21 #include <dali-toolkit/devel-api/controls/control-devel.h>
  22
  23 // INTERNAL INCLUDES
  24 #include <dali-csharp-binder/common/common.h>
  25
  26 /* Callback for returning strings to C# without leaking memory */
  27 typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *);
  28 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
  29
  30 /* TODO Adding signal definition */
  31 SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal<void(Dali::GlWindow, bool)> const *self)
  32 {
  33   return self->Empty();
  34 }
  35 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal<void(Dali::GlWindow, bool)> const *self)
  36 {
  37   return self->GetConnectionCount();
  38 }
  39 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal<void(Dali::GlWindow, bool)> *self, void (*func)(Dali::GlWindow, bool))
  40 {
  41   self->Connect(func);
  42 }
  43 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal<void(Dali::GlWindow, bool)> *self, void (*func)(Dali::GlWindow, bool))
  44 {
  45   self->Disconnect(func);
  46 }
  47 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal<void(Dali::GlWindow, bool)> *self, Dali::GlWindow arg, bool focusIn)
  48 {
  49   self->Emit(arg, focusIn);
  50 }
  51
  52 /*ResizeSignal*/
  53 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Empty(Dali::Signal<void(Dali::GlWindow::WindowSize)> const *self)
  54 {
  55   return self->Empty();
  56 }
  57 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__GetConnectionCount(Dali::Signal<void(Dali::GlWindow::WindowSize)> const *self)
  58 {
  59   return self->GetConnectionCount();
  60 }
  61 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Connect(Dali::Signal<void(Dali::GlWindow::WindowSize)> *self, void (*func)(Dali::GlWindow::WindowSize))
  62 {
  63   self->Connect(func);
  64 }
  65 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Disconnect(Dali::Signal<void(Dali::GlWindow::WindowSize)> *self, void (*func)(Dali::GlWindow::WindowSize))
  66 {
  67   self->Disconnect(func);
  68 }
  69 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Emit(Dali::Signal<void(Dali::GlWindow::WindowSize)> *self, Dali::GlWindow::WindowSize arg)
  70 {
  71   self->Emit(arg);
  72 }
  73
  74 #ifdef __cplusplus
  75 extern "C"
  76 {
  77 #endif
  78
  79   /*Window binding*/
  80   SWIGEXPORT Dali::BaseHandle *SWIGSTDCALL CSharp_Dali_GlWindow_SWIGUpcast(Dali::GlWindow *jarg1)
  81   {
  82     return (Dali::BaseHandle *)jarg1;
  83   }
  84
  85   SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_New__SWIG_0()
  86   {
  87     void *jresult;
  88     Dali::GlWindow result;
  89     {
  90       try
  91       {
  92
  93         result = Dali::GlWindow::New();
  94       }
  95       CALL_CATCH_EXCEPTION(0);
  96     }
  97
  98     jresult = new Dali::GlWindow((const Dali::GlWindow &)result);
  99     return jresult;
 100   }
 101
 102   SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_New__SWIG_1(void *jarg1, char *jarg2, char *jarg3, unsigned int jarg4)
 103   {
 104     void *jresult;
 105     Dali::PositionSize arg1;
 106     std::string *arg2 = 0;
 107     std::string *arg3 = 0;
 108     bool arg4;
 109     Dali::PositionSize *argp1;
 110     Dali::GlWindow result;
 111
 112     argp1 = (Dali::PositionSize *)jarg1;
 113     if (!argp1)
 114     {
 115       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
 116       return 0;
 117     }
 118     arg1 = *argp1;
 119     if (!jarg2)
 120     {
 121       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 122       return 0;
 123     }
 124     std::string arg2_str(jarg2);
 125     arg2 = &arg2_str;
 126     if (!jarg3)
 127     {
 128       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 129       return 0;
 130     }
 131     std::string arg3_str(jarg3);
 132     arg3 = &arg3_str;
 133     arg4 = jarg4 ? true : false;
 134
 135     {
 136       try
 137       {
 138         result = Dali::GlWindow::New(arg1, (std::string const &)*arg2, (std::string const &)*arg3, arg4);
 139       }
 140       CALL_CATCH_EXCEPTION(0);
 141     }
 142
 143     jresult = new Dali::GlWindow((const Dali::GlWindow &)result);
 144     return jresult;
 145   }
 146
 147   SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlWindow__SWIG_0()
 148   {
 149     void *jresult;
 150     Dali::GlWindow *result = 0;
 151
 152     {
 153       try
 154       {
 155         result = (Dali::GlWindow *)new Dali::GlWindow();
 156       }
 157       CALL_CATCH_EXCEPTION(0);
 158     }
 159
 160     jresult = (void *)result;
 161     return jresult;
 162   }
 163
 164   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GlWindow(void *jarg1)
 165   {
 166     Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
 167
 168     arg1 = (Dali::GlWindow *)jarg1;
 169     {
 170       try
 171       {
 172         delete arg1;
 173       }
 174       CALL_CATCH_EXCEPTION();
 175     }
 176   }
 177
 178   SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlWindow__SWIG_1(void *jarg1)
 179   {
 180     void *jresult;
 181     Dali::GlWindow *arg1 = 0;
 182     Dali::GlWindow *result = 0;
 183
 184     arg1 = (Dali::GlWindow *)jarg1;
 185     if (!arg1)
 186     {
 187       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GlWindow const & type is null", 0);
 188       return 0;
 189     }
 190     {
 191       try
 192       {
 193         result = (Dali::GlWindow *)new Dali::GlWindow((Dali::GlWindow const &)*arg1);
 194       }
 195       CALL_CATCH_EXCEPTION(0);
 196     }
 197
 198     jresult = (void *)result;
 199     return jresult;
 200   }
 201
 202   SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_Assign(void *jarg1, void *jarg2)
 203   {
 204     void *jresult;
 205     Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
 206     Dali::GlWindow *arg2 = 0;
 207     Dali::GlWindow *result = 0;
 208
 209     arg1 = (Dali::GlWindow *)jarg1;
 210     arg2 = (Dali::GlWindow *)jarg2;
 211     if (!arg2)
 212     {
 213       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GlWindow const & type is null", 0);
 214       return 0;
 215     }
 216     {
 217       try
 218       {
 219         result = (Dali::GlWindow *)&(arg1)->operator=((Dali::GlWindow const &)*arg2);
 220       }
 221       CALL_CATCH_EXCEPTION(0);
 222     }
 223
 224     jresult = (void *)result;
 225     return jresult;
 226   }
 227
 228   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetGraphicsConfig(void *jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, int jarg5)
 229   {
 230     Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
 231     bool arg2;
 232     bool arg3;
 233     int arg4;
 234     Dali::GlWindow::GlesVersion arg5;
 235
 236     arg1 = (Dali::GlWindow *)jarg1;
 237     arg2 = (bool)jarg2;
 238     arg3 = (bool)jarg3;
 239     arg4 = jarg4;
 240     arg5 = static_cast<Dali::GlWindow::GlesVersion>(jarg5);
 241     {
 242       try
 243       {
 244         (arg1)->SetGraphicsConfig(arg2, arg3, arg4, arg5);
 245       }
 246       CALL_CATCH_EXCEPTION();
 247     }
 248   }
 249
 250   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Raise(void *jarg1)
 251   {
 252     Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
 253
 254     arg1 = (Dali::GlWindow *)jarg1;
 255     {
 256       try
 257       {
 258         (arg1)->Raise();
 259       }
 260       CALL_CATCH_EXCEPTION();
 261     }
 262   }
 263
 264   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Lower(void *jarg1)
 265   {
 266     Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
 267
 268     arg1 = (Dali::GlWindow *)jarg1;
 269     {
 270       try
 271       {
 272         (arg1)->Lower();
 273       }
 274       CALL_CATCH_EXCEPTION();
 275     }
 276   }
 277
 278   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Activate(void *jarg1)
 279   {
 280     Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
 281
 282     arg1 = (Dali::GlWindow *)jarg1;
 283     {
 284       try
 285       {
 286         (arg1)->Activate();
 287       }
 288       CALL_CATCH_EXCEPTION();
 289     }
 290   }
 291
 292   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Show(void *jarg1)
 293   {
 294     Dali::GlWindow arg1;
 295     Dali::GlWindow *argp1;
 296
 297     argp1 = (Dali::GlWindow *)jarg1;
 298     if (!argp1)
 299     {
 300       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 301       return;
 302     }
 303     arg1 = *argp1;
 304     {
 305       try
 306       {
 307         arg1.Show();
 308       }
 309       CALL_CATCH_EXCEPTION();
 310     }
 311   }
 312
 313   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Hide(void *jarg1)
 314   {
 315     Dali::GlWindow arg1;
 316     Dali::GlWindow *argp1;
 317
 318     argp1 = (Dali::GlWindow *)jarg1;
 319     if (!argp1)
 320     {
 321       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 322       return;
 323     }
 324     arg1 = *argp1;
 325     {
 326       try
 327       {
 328         arg1.Hide();
 329       }
 330       CALL_CATCH_EXCEPTION();
 331     }
 332   }
 333
 334   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetPositionSize(void *jarg1, void *jarg2)
 335   {
 336     Dali::GlWindow arg1;
 337     Dali::GlWindow *argp1 = (Dali::GlWindow *)jarg1;
 338     if (!argp1)
 339     {
 340       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 341       return;
 342     }
 343     arg1 = *argp1;
 344     Dali::Rect<int> *positionSize = (Dali::Rect<int> *)jarg2;
 345     if (!positionSize)
 346     {
 347       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
 348       return;
 349     }
 350     {
 351       try
 352       {
 353         arg1.SetPositionSize(*positionSize);
 354       }
 355       CALL_CATCH_EXCEPTION();
 356     }
 357   }
 358
 359   SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_GetPositionSize(void *jarg1)
 360   {
 361     void *jresult;
 362     Dali::GlWindow arg1;
 363     Dali::GlWindow *argp1;
 364     Dali::PositionSize result;
 365
 366     argp1 = (Dali::GlWindow *)jarg1;
 367     if (!argp1)
 368     {
 369       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 370       return 0;
 371     }
 372     arg1 = *argp1;
 373     {
 374       try
 375       {
 376         result = arg1.GetPositionSize();
 377       }
 378       CALL_CATCH_EXCEPTION(0);
 379     }
 380
 381     jresult = new Dali::PositionSize((const Dali::PositionSize &)result);
 382     return jresult;
 383   }
 384
 385   SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_GetSupportedAuxiliaryHintCount(void *jarg1)
 386   {
 387     unsigned int jresult;
 388     Dali::GlWindow arg1;
 389     Dali::GlWindow *argp1;
 390     unsigned int result;
 391
 392     argp1 = (Dali::GlWindow *)jarg1;
 393     if (!argp1)
 394     {
 395       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 396       return 0;
 397     }
 398     arg1 = *argp1;
 399     {
 400       try
 401       {
 402         result = (unsigned int)arg1.GetSupportedAuxiliaryHintCount();
 403       }
 404       CALL_CATCH_EXCEPTION(0);
 405     }
 406
 407     jresult = result;
 408     return jresult;
 409   }
 410
 411   SWIGEXPORT char *SWIGSTDCALL CSharp_Dali_GlWindow_GetSupportedAuxiliaryHint(void *jarg1, unsigned int jarg2)
 412   {
 413     char *jresult;
 414     Dali::GlWindow arg1;
 415     unsigned int arg2;
 416     Dali::GlWindow *argp1;
 417     std::string result;
 418
 419     argp1 = (Dali::GlWindow *)jarg1;
 420     if (!argp1)
 421     {
 422       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 423       return 0;
 424     }
 425     arg1 = *argp1;
 426     arg2 = (unsigned int)jarg2;
 427     {
 428       try
 429       {
 430         result = arg1.GetSupportedAuxiliaryHint(arg2);
 431       }
 432       CALL_CATCH_EXCEPTION(0);
 433     }
 434
 435     jresult = SWIG_csharp_string_callback((&result)->c_str());
 436     return jresult;
 437   }
 438
 439   SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_AddAuxiliaryHint(void *jarg1, char *jarg2, char *jarg3)
 440   {
 441     unsigned int jresult;
 442     Dali::GlWindow arg1;
 443     std::string *arg2 = 0;
 444     std::string *arg3 = 0;
 445     Dali::GlWindow *argp1;
 446     unsigned int result;
 447
 448     argp1 = (Dali::GlWindow *)jarg1;
 449     if (!argp1)
 450     {
 451       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 452       return 0;
 453     }
 454     arg1 = *argp1;
 455     if (!jarg2)
 456     {
 457       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 458       return 0;
 459     }
 460     std::string arg2_str(jarg2);
 461     arg2 = &arg2_str;
 462     if (!jarg3)
 463     {
 464       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 465       return 0;
 466     }
 467     std::string arg3_str(jarg3);
 468     arg3 = &arg3_str;
 469     {
 470       try
 471       {
 472         result = (unsigned int)arg1.AddAuxiliaryHint((std::string const &)*arg2, (std::string const &)*arg3);
 473       }
 474       CALL_CATCH_EXCEPTION(0);
 475     }
 476
 477     jresult = result;
 478
 479     return jresult;
 480   }
 481
 482   SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_RemoveAuxiliaryHint(void *jarg1, unsigned int jarg2)
 483   {
 484     unsigned int jresult;
 485     Dali::GlWindow arg1;
 486     unsigned int arg2;
 487     Dali::GlWindow *argp1;
 488     bool result;
 489
 490     argp1 = (Dali::GlWindow *)jarg1;
 491     if (!argp1)
 492     {
 493       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 494       return 0;
 495     }
 496     arg1 = *argp1;
 497     arg2 = (unsigned int)jarg2;
 498     {
 499       try
 500       {
 501         result = (bool)arg1.RemoveAuxiliaryHint(arg2);
 502       }
 503       CALL_CATCH_EXCEPTION(0);
 504     }
 505
 506     jresult = result;
 507     return jresult;
 508   }
 509
 510   SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_SetAuxiliaryHintValue(void *jarg1, unsigned int jarg2, char *jarg3)
 511   {
 512     unsigned int jresult;
 513     Dali::GlWindow arg1;
 514     unsigned int arg2;
 515     std::string *arg3 = 0;
 516     Dali::GlWindow *argp1;
 517     bool result;
 518
 519     argp1 = (Dali::GlWindow *)jarg1;
 520     if (!argp1)
 521     {
 522       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 523       return 0;
 524     }
 525     arg1 = *argp1;
 526     arg2 = (unsigned int)jarg2;
 527     if (!jarg3)
 528     {
 529       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 530       return 0;
 531     }
 532     std::string arg3_str(jarg3);
 533     arg3 = &arg3_str;
 534     {
 535       try
 536       {
 537         result = (bool)arg1.SetAuxiliaryHintValue(arg2, (std::string const &)*arg3);
 538       }
 539       CALL_CATCH_EXCEPTION(0);
 540     }
 541
 542     jresult = result;
 543
 544     //argout typemap for const std::string&
 545
 546     return jresult;
 547   }
 548
 549   SWIGEXPORT char *SWIGSTDCALL CSharp_Dali_GlWindow_GetAuxiliaryHintValue(void *jarg1, unsigned int jarg2)
 550   {
 551     char *jresult;
 552     Dali::GlWindow arg1;
 553     unsigned int arg2;
 554     Dali::GlWindow *argp1;
 555     std::string result;
 556
 557     argp1 = (Dali::GlWindow *)jarg1;
 558     if (!argp1)
 559     {
 560       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 561       return 0;
 562     }
 563     arg1 = *argp1;
 564     arg2 = (unsigned int)jarg2;
 565     {
 566       try
 567       {
 568         result = arg1.GetAuxiliaryHintValue(arg2);
 569       }
 570       CALL_CATCH_EXCEPTION(0);
 571     }
 572
 573     jresult = SWIG_csharp_string_callback((&result)->c_str());
 574     return jresult;
 575   }
 576
 577   SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_GetAuxiliaryHintId(void *jarg1, char *jarg2)
 578   {
 579     unsigned int jresult;
 580     Dali::GlWindow arg1;
 581     std::string *arg2 = 0;
 582     Dali::GlWindow *argp1;
 583     unsigned int result;
 584
 585     argp1 = (Dali::GlWindow *)jarg1;
 586     if (!argp1)
 587     {
 588       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 589       return 0;
 590     }
 591     arg1 = *argp1;
 592     if (!jarg2)
 593     {
 594       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 595       return 0;
 596     }
 597     std::string arg2_str(jarg2);
 598     arg2 = &arg2_str;
 599     {
 600       try
 601       {
 602         result = (unsigned int)arg1.GetAuxiliaryHintId((std::string const &)*arg2);
 603       }
 604       CALL_CATCH_EXCEPTION(0);
 605     }
 606
 607     jresult = result;
 608
 609     //argout typemap for const std::string&
 610
 611     return jresult;
 612   }
 613
 614   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetInputRegion(void *jarg1, void *jarg2)
 615   {
 616     Dali::GlWindow arg1;
 617     Dali::Rect<int> *arg2 = 0;
 618     Dali::GlWindow *argp1;
 619
 620     argp1 = (Dali::GlWindow *)jarg1;
 621     if (!argp1)
 622     {
 623       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 624       return;
 625     }
 626     arg1 = *argp1;
 627     arg2 = (Dali::Rect<int> *)jarg2;
 628     if (!arg2)
 629     {
 630       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
 631       return;
 632     }
 633     {
 634       try
 635       {
 636         arg1.SetInputRegion((Dali::Rect<int> const &)*arg2);
 637       }
 638       CALL_CATCH_EXCEPTION();
 639     }
 640   }
 641
 642   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetOpaqueState(void *jarg1, unsigned int jarg2)
 643   {
 644     Dali::GlWindow arg1;
 645     bool arg2;
 646     Dali::GlWindow *argp1;
 647
 648     argp1 = (Dali::GlWindow *)jarg1;
 649     if (!argp1)
 650     {
 651       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 652       return;
 653     }
 654     arg1 = *argp1;
 655     arg2 = jarg2 ? true : false;
 656     {
 657       try
 658       {
 659         arg1.SetOpaqueState(arg2);
 660       }
 661       CALL_CATCH_EXCEPTION();
 662     }
 663   }
 664
 665   SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_IsOpaqueState(void *jarg1)
 666   {
 667     unsigned int jresult;
 668     Dali::GlWindow arg1;
 669     Dali::GlWindow *argp1;
 670     bool result;
 671
 672     argp1 = (Dali::GlWindow *)jarg1;
 673     if (!argp1)
 674     {
 675       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 676       return 0;
 677     }
 678     arg1 = *argp1;
 679     {
 680       try
 681       {
 682         result = (bool)arg1.IsOpaqueState();
 683       }
 684       CALL_CATCH_EXCEPTION(0);
 685     }
 686
 687     jresult = result;
 688     return jresult;
 689   }
 690
 691   SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GlWindow_GetCurrentOrientation(void *jarg1)
 692   {
 693     int jresult;
 694     Dali::WindowOrientation result;
 695     Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
 696     arg1 = (Dali::GlWindow *)jarg1;
 697     if (!arg1)
 698     {
 699       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 700       return 0;
 701     }
 702     {
 703       try
 704       {
 705         result = (arg1)->GetCurrentOrientation();
 706       }
 707       CALL_CATCH_EXCEPTION(0);
 708     }
 709
 710     jresult = (int)result;
 711     return jresult;
 712   }
 713
 714   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetAvailableOrientations(void *jarg1, void *jarg2, int jarg3)
 715   {
 716     Dali::GlWindow *arg1 = (Dali::GlWindow *)jarg1;
 717     if (!arg1)
 718     {
 719       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 720       return;
 721     }
 722     Dali::Property::Array *arg2 = (static_cast<Dali::Property::Array *>(jarg2));
 723     unsigned int count = static_cast<unsigned int>(jarg3);
 724
 725     Dali::Vector<Dali::WindowOrientation> angles;
 726     angles.Resize(count);
 727     for (Dali::Property::Array::SizeType i = 0; i < count; ++i)
 728     {
 729       int angle = arg2->GetElementAt(i).Get<int>();
 730       angles[i] = static_cast<Dali::WindowOrientation>(angle);
 731     }
 732     {
 733       try
 734       {
 735         arg1->SetAvailableOrientations(angles);
 736       }
 737       CALL_CATCH_EXCEPTION();
 738     }
 739   }
 740
 741   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetPreferredOrientation(void *jarg1, int jarg2)
 742   {
 743     Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
 744     Dali::WindowOrientation arg2;
 745     int angle = jarg2;
 746
 747     arg1 = (Dali::GlWindow *)jarg1;
 748     arg2 = (Dali::WindowOrientation)angle;
 749     {
 750       try
 751       {
 752         (arg1)->SetPreferredOrientation(arg2);
 753       }
 754       CALL_CATCH_EXCEPTION();
 755     }
 756   }
 757
 758   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_RegisterGlCallbacks(void *jarg1, void *initCallback, int *RenderFrameCallback, void *terminateCallback)
 759   {
 760     Dali::GlWindow *argp1 = (Dali::GlWindow *)jarg1;
 761     void (*initCB)() = (void (*)())initCallback;
 762     int (*renderFrameCB)() = (int (*)())RenderFrameCallback;
 763     void (*terminateCB)() = (void (*)())terminateCallback;
 764
 765     if (!argp1 || !initCB || !renderFrameCB || !terminateCB)
 766     {
 767       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null", 0);
 768       return;
 769     }
 770     Dali::GlWindow arg1 = *argp1;
 771     try
 772     {
 773       arg1.RegisterGlCallbacks(Dali::MakeCallback(initCB), Dali::MakeCallback(renderFrameCB), Dali::MakeCallback(terminateCB));
 774     }
 775     CALL_CATCH_EXCEPTION();
 776   }
 777
 778   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_RenderOnce(void *jarg1)
 779   {
 780     Dali::GlWindow *argp1 = (Dali::GlWindow *)jarg1;
 781     Dali::GlWindow arg1;
 782     if (!argp1)
 783     {
 784       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 785       return;
 786     }
 787     arg1 = *argp1;
 788     {
 789       try
 790       {
 791         arg1.RenderOnce();
 792       }
 793       CALL_CATCH_EXCEPTION();
 794     }
 795   }
 796
 797   SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GlWindow_GetRenderingMode(void *jarg1)
 798   {
 799     int jresult;
 800     Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
 801     Dali::GlWindow::RenderingMode result;
 802
 803     arg1 = (Dali::GlWindow *)jarg1;
 804     if (!arg1)
 805     {
 806       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 807       return 0;
 808     }
 809
 810     {
 811       try
 812       {
 813         result = (Dali::GlWindow::RenderingMode)(arg1)->GetRenderingMode();
 814       }
 815       CALL_CATCH_EXCEPTION(0);
 816     }
 817
 818     jresult = (int)result;
 819     return jresult;
 820   }
 821
 822   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetRenderingMode(void *jarg1, int jarg2)
 823   {
 824     Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
 825     Dali::GlWindow::RenderingMode arg2;
 826
 827     arg1 = (Dali::GlWindow *)jarg1;
 828     if (!arg1)
 829     {
 830       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 831       return;
 832     }
 833     arg2 = (Dali::GlWindow::RenderingMode)jarg2;
 834     {
 835       try
 836       {
 837         (arg1)->SetRenderingMode(arg2);
 838       }
 839       CALL_CATCH_EXCEPTION();
 840     }
 841   }
 842
 843   /* Signals binding*/
 844
 845   /* Focus change binding */
 846   SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_FocusChangedSignal(void *jarg1)
 847   {
 848     void *jresult;
 849     Dali::GlWindow arg1;
 850     Dali::GlWindow *argp1;
 851     Dali::GlWindow::FocusChangeSignalType *result = 0;
 852
 853     argp1 = (Dali::GlWindow *)jarg1;
 854     if (!argp1)
 855     {
 856       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
 857       return 0;
 858     }
 859     arg1 = *argp1;
 860     {
 861       try
 862       {
 863         result = (Dali::GlWindow::FocusChangeSignalType *)&arg1.FocusChangeSignal();
 864       }
 865       CALL_CATCH_EXCEPTION(0);
 866     }
 867
 868     jresult = (void *)result;
 869     return jresult;
 870   }
 871
 872   SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Empty(void *jarg1)
 873   {
 874     unsigned int jresult;
 875     Dali::Signal<void(Dali::GlWindow, bool)> *arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)0;
 876     bool result;
 877
 878     arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)jarg1;
 879     {
 880       try
 881       {
 882         result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal<void(Dali::GlWindow, bool)> const *)arg1);
 883       }
 884       CALL_CATCH_EXCEPTION(0);
 885     }
 886
 887     jresult = result;
 888     return jresult;
 889   }
 890
 891   SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_GetConnectionCount(void *jarg1)
 892   {
 893     unsigned long jresult;
 894     Dali::Signal<void(Dali::GlWindow, bool)> *arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)0;
 895     std::size_t result;
 896
 897     arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)jarg1;
 898     {
 899       try
 900       {
 901         result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::GlWindow, bool)> const *)arg1);
 902       }
 903       CALL_CATCH_EXCEPTION(0);
 904     }
 905
 906     jresult = (unsigned long)result;
 907     return jresult;
 908   }
 909
 910   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Connect(void *jarg1, void *jarg2)
 911   {
 912     Dali::Signal<void(Dali::GlWindow, bool)> *arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)0;
 913     void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool))0;
 914
 915     arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)jarg1;
 916     arg2 = (void (*)(Dali::GlWindow, bool))jarg2;
 917     {
 918       try
 919       {
 920         Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1, arg2);
 921       }
 922       CALL_CATCH_EXCEPTION();
 923     }
 924   }
 925
 926   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Disconnect(void *jarg1, void *jarg2)
 927   {
 928     Dali::Signal<void(Dali::GlWindow, bool)> *arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)0;
 929     void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool))0;
 930
 931     arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)jarg1;
 932     arg2 = (void (*)(Dali::GlWindow, bool))jarg2;
 933     {
 934       try
 935       {
 936         Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1, arg2);
 937       }
 938       CALL_CATCH_EXCEPTION();
 939     }
 940   }
 941
 942   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Emit(void *jarg1, void *jarg2, unsigned int jarg3)
 943   {
 944     Dali::Signal<void(Dali::GlWindow, bool)> *arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)jarg1;
 945     Dali::GlWindow *arg2 = (Dali::GlWindow *)jarg2;
 946     bool arg3 = jarg3 ? true : false;
 947     ;
 948
 949     if (arg1 == nullptr || arg2 == nullptr)
 950     {
 951       DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr");
 952       return;
 953     }
 954
 955     {
 956       try
 957       {
 958         Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1, *arg2, arg3);
 959       }
 960       CALL_CATCH_EXCEPTION();
 961     }
 962   }
 963
 964   SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlWindow_FocusSignalType()
 965   {
 966     void *jresult;
 967     Dali::Signal<void(Dali::GlWindow, bool)> *result = 0;
 968
 969     {
 970       try
 971       {
 972         result = (Dali::Signal<void(Dali::GlWindow, bool)> *)new Dali::Signal<void(Dali::GlWindow, bool)>();
 973       }
 974       CALL_CATCH_EXCEPTION(0);
 975     }
 976
 977     jresult = (void *)result;
 978     return jresult;
 979   }
 980
 981   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GlWindow_FocusSignalType(void *jarg1)
 982   {
 983     Dali::Signal<void(Dali::GlWindow, bool)> *arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)0;
 984
 985     arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)jarg1;
 986     {
 987       try
 988       {
 989         delete arg1;
 990       }
 991       CALL_CATCH_EXCEPTION();
 992     }
 993   }
 994
 995   /* Touch Event Binding */
 996   GENERATE_SIGNAL(Dali::GlWindow*, void(*)(Dali::TouchEvent const&), Dali_GlWindow, TouchedSignal)
 997   // CSharp_Dali_GLWindow_TouchedSignal_Connect
 998   // CSharp_Dali_GLWindow_TouchedSignal_Disconnect
 999
1000   /*Key Event Binding */
1001
1002   SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_KeyEventSignal(void *jarg1)
1003   {
1004     void *jresult;
1005     Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
1006     Dali::GlWindow::KeyEventSignalType *result = 0;
1007
1008     arg1 = (Dali::GlWindow *)jarg1;
1009     {
1010       try
1011       {
1012         result = (Dali::GlWindow::KeyEventSignalType *)&(arg1->KeyEventSignal());
1013       }
1014       CALL_CATCH_EXCEPTION(0);
1015     }
1016
1017     jresult = (void *)result;
1018     return jresult;
1019   }
1020
1021   /* visibility change */
1022
1023   SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal(void *jarg1)
1024   {
1025     Dali::GlWindow *arg1 = (Dali::GlWindow *)jarg1;
1026     Dali::GlWindow::VisibilityChangedSignalType *result = 0;
1027
1028     {
1029       try
1030       {
1031         result = (Dali::GlWindow::VisibilityChangedSignalType *)&(arg1->VisibilityChangedSignal());
1032       }
1033       CALL_CATCH_EXCEPTION(0);
1034     }
1035     return (void *)result;
1036   }
1037
1038   SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_GetConnectionCount(void *jarg1)
1039   {
1040     unsigned int result;
1041     Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1;
1042
1043     if (arg1 == nullptr)
1044     {
1045       DALI_LOG_ERROR("[ERR] arg1 == nullptr");
1046       return 0;
1047     }
1048
1049     {
1050       try
1051       {
1052         result = arg1->GetConnectionCount();
1053       }
1054       CALL_CATCH_EXCEPTION(0);
1055     }
1056     return result;
1057   }
1058
1059   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_Connect(void *jarg1, void *jarg2)
1060   {
1061     Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1;
1062     void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool))jarg2;
1063
1064     if (arg1 == nullptr)
1065     {
1066       DALI_LOG_ERROR("[ERR] arg1 == nullptr");
1067       return;
1068     }
1069
1070     {
1071       try
1072       {
1073         arg1->Connect(arg2);
1074       }
1075       CALL_CATCH_EXCEPTION();
1076     }
1077     return;
1078   }
1079
1080   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_Disconnect(void *jarg1, void *jarg2)
1081   {
1082     Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1;
1083     void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool))jarg2;
1084
1085     if (arg1 == nullptr)
1086     {
1087       DALI_LOG_ERROR("[ERR] arg1 == nullptr");
1088       return;
1089     }
1090
1091     {
1092       try
1093       {
1094         arg1->Disconnect(arg2);
1095       }
1096       CALL_CATCH_EXCEPTION();
1097     }
1098     return;
1099   }
1100
1101   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_Emit(void *jarg1, void *jarg2, bool jarg3)
1102   {
1103     Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1;
1104     Dali::GlWindow *arg2 = (Dali::GlWindow *)jarg2;
1105     bool arg3 = jarg3;
1106
1107     if (arg1 == nullptr || arg2 == nullptr)
1108     {
1109       DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr");
1110       return;
1111     }
1112
1113     {
1114       try
1115       {
1116         arg1->Emit(*arg2, arg3);
1117       }
1118       CALL_CATCH_EXCEPTION();
1119     }
1120     return;
1121   }
1122
1123   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_delete(void *jarg1)
1124   {
1125     Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1;
1126
1127     {
1128       try
1129       {
1130         delete arg1;
1131       }
1132       CALL_CATCH_EXCEPTION();
1133     }
1134     return;
1135   }
1136
1137   /*ResizeSignal binding*/
1138   SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal(void *jarg1)
1139   {
1140     void *jresult;
1141     Dali::GlWindow arg1;
1142     Dali::GlWindow *argp1;
1143     Dali::GlWindow::ResizeSignalType *result = 0;
1144
1145     argp1 = (Dali::GlWindow *)jarg1;
1146     if (!argp1)
1147     {
1148       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
1149       return 0;
1150     }
1151     arg1 = *argp1;
1152     {
1153       try
1154       {
1155         result = (Dali::GlWindow::ResizeSignalType *)&arg1.ResizeSignal();
1156       }
1157       CALL_CATCH_EXCEPTION(0);
1158     }
1159
1160     jresult = (void *)result;
1161     return jresult;
1162   }
1163
1164   SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Empty(void *jarg1)
1165   {
1166     unsigned int jresult;
1167     Dali::Signal<void(Dali::GlWindow::WindowSize)> *arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)0;
1168     bool result;
1169
1170     arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)jarg1;
1171     {
1172       try
1173       {
1174         result = (bool)Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Empty((Dali::Signal<void(Dali::GlWindow::WindowSize)> const *)arg1);
1175       }
1176       CALL_CATCH_EXCEPTION(0);
1177     }
1178
1179     jresult = result;
1180     return jresult;
1181   }
1182
1183   SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_GetConnectionCount(void *jarg1)
1184   {
1185     unsigned long jresult;
1186     Dali::Signal<void(Dali::GlWindow::WindowSize)> *arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)0;
1187     std::size_t result;
1188
1189     arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)jarg1;
1190     {
1191       try
1192       {
1193         result = Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::GlWindow::WindowSize)> const *)arg1);
1194       }
1195       CALL_CATCH_EXCEPTION(0);
1196     }
1197
1198     jresult = (unsigned long)result;
1199     return jresult;
1200   }
1201
1202   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Connect(void *jarg1, void *jarg2)
1203   {
1204     Dali::Signal<void(Dali::GlWindow::WindowSize)> *arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)0;
1205     void (*arg2)(Dali::GlWindow::WindowSize) = (void (*)(Dali::GlWindow::WindowSize))0;
1206
1207     arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)jarg1;
1208     arg2 = (void (*)(Dali::GlWindow::WindowSize))jarg2;
1209     {
1210       try
1211       {
1212         Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Connect(arg1, arg2);
1213       }
1214       CALL_CATCH_EXCEPTION();
1215     }
1216   }
1217
1218   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Disconnect(void *jarg1, void *jarg2)
1219   {
1220     Dali::Signal<void(Dali::GlWindow::WindowSize)> *arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)0;
1221     void (*arg2)(Dali::GlWindow::WindowSize) = (void (*)(Dali::GlWindow::WindowSize))0;
1222
1223     arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)jarg1;
1224     arg2 = (void (*)(Dali::GlWindow::WindowSize))jarg2;
1225     {
1226       try
1227       {
1228         Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Disconnect(arg1, arg2);
1229       }
1230       CALL_CATCH_EXCEPTION();
1231     }
1232   }
1233
1234   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Emit(void *jarg1, void *jarg2)
1235   {
1236     Dali::Signal<void(Dali::GlWindow::WindowSize)> *arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)0;
1237     Dali::GlWindow::WindowSize arg2;
1238     Dali::GlWindow::WindowSize *argp2;
1239
1240     arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)jarg1;
1241     if (arg1 == nullptr)
1242     {
1243       DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr");
1244       return;
1245     }
1246     argp2 = (Dali::GlWindow::WindowSize *)jarg2;
1247     if (!argp2)
1248     {
1249       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow::WindowSize", 0);
1250       return;
1251     }
1252     arg2 = *argp2;
1253     {
1254       try
1255       {
1256         Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Emit(arg1, arg2);
1257       }
1258       CALL_CATCH_EXCEPTION();
1259     }
1260   }
1261
1262   SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlWindow_ResizedSignal()
1263   {
1264     void *jresult;
1265     Dali::Signal<void(Dali::GlWindow::WindowSize)> *result = 0;
1266
1267     {
1268       try
1269       {
1270         result = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)new Dali::Signal<void(Dali::GlWindow::WindowSize)>();
1271       }
1272       CALL_CATCH_EXCEPTION(0);
1273     }
1274
1275     jresult = (void *)result;
1276     return jresult;
1277   }
1278
1279   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_delete_ResizedSignal(void *jarg1)
1280   {
1281     Dali::Signal<void(Dali::GlWindow::WindowSize)> *arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)0;
1282
1283     arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)jarg1;
1284     {
1285       try
1286       {
1287         delete arg1;
1288       }
1289       CALL_CATCH_EXCEPTION();
1290     }
1291   }
1292
1293 #ifdef __cplusplus
1294 }
1295 #endif