dali-csharp-binder/dali-adaptor/dali-adaptor-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/dali.h>
  20 #include <dali/devel-api/adaptor-framework/image-loading.h>
  21 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
  22 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
  23 #include <dali/devel-api/adaptor-framework/window-system-devel.h>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali-csharp-binder/common/common.h>
  27
  28 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
  29
  30 // SWIGINTERN - the relevant parts of the generated code can be seen the below.
  31
  32 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self)
  33 {
  34   return self->Empty();
  35 }
  36 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self)
  37 {
  38   return self->GetConnectionCount();
  39 }
  40 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)())
  41 {
  42   self->Connect( func );
  43 }
  44 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)())
  45 {
  46   self->Disconnect( func );
  47 }
  48 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self)
  49 {
  50   return self->Emit();
  51 }
  52
  53 using namespace Dali;
  54
  55 // keep argWidgetCs and argWidgetV so they're always available to DALi
  56 int argWidgetC = 1;
  57 char **argWidgetV = NULL;
  58
  59
  60 #ifdef __cplusplus
  61 extern "C" {
  62 #endif
  63
  64
  65 // Method
  66
  67
  68 // WindowSystem
  69
  70 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetScreenSize() {
  71   void * jresult ;
  72   int width, height;
  73
  74   try {
  75     Dali::DevelWindowSystem::GetScreenSize(width, height);
  76   } CALL_CATCH_EXCEPTION(0);
  77
  78   jresult = new Dali::Size(width, height);
  79   return jresult;
  80 }
  81
  82 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetGeometryHittestEnabled(bool enable) {
  83
  84   try {
  85     Dali::DevelWindowSystem::SetGeometryHittestEnabled(enable);
  86   } CALL_CATCH_EXCEPTION();
  87
  88 }
  89
  90
  91 // Timer
  92
  93 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
  94   void * jresult ;
  95   Dali::Timer *result = 0 ;
  96
  97   {
  98     try {
  99       result = (Dali::Timer *)new Dali::Timer();
 100     } CALL_CATCH_EXCEPTION(0);
 101   }
 102
 103   jresult = (void *)result;
 104   return jresult;
 105 }
 106
 107
 108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
 109   void * jresult ;
 110   unsigned int arg1 ;
 111   Dali::Timer result;
 112
 113   arg1 = (unsigned int)jarg1;
 114   {
 115     try {
 116       result = Dali::Timer::New(arg1);
 117     } CALL_CATCH_EXCEPTION(0);
 118   }
 119
 120   jresult = new Dali::Timer((const Dali::Timer &)result);
 121   return jresult;
 122 }
 123
 124
 125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
 126   void * jresult ;
 127   Dali::Timer *arg1 = 0 ;
 128   Dali::Timer *result = 0 ;
 129
 130   arg1 = (Dali::Timer *)jarg1;
 131   if (!arg1) {
 132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
 133     return 0;
 134   }
 135   {
 136     try {
 137       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
 138     } CALL_CATCH_EXCEPTION(0);
 139   }
 140
 141   jresult = (void *)result;
 142   return jresult;
 143 }
 144
 145
 146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
 147   void * jresult ;
 148   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
 149   Dali::Timer *arg2 = 0 ;
 150   Dali::Timer *result = 0 ;
 151
 152   arg1 = (Dali::Timer *)jarg1;
 153   arg2 = (Dali::Timer *)jarg2;
 154   if (!arg2) {
 155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
 156     return 0;
 157   }
 158   {
 159     try {
 160       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
 161     } CALL_CATCH_EXCEPTION(0);
 162   }
 163
 164   jresult = (void *)result;
 165   return jresult;
 166 }
 167
 168
 169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
 170   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
 171
 172   arg1 = (Dali::Timer *)jarg1;
 173   {
 174     try {
 175       delete arg1;
 176     } CALL_CATCH_EXCEPTION();
 177   }
 178
 179 }
 180
 181
 182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
 183   void * jresult ;
 184   Dali::BaseHandle arg1 ;
 185   Dali::BaseHandle *argp1 ;
 186   Dali::Timer result;
 187
 188   argp1 = (Dali::BaseHandle *)jarg1;
 189   if (!argp1) {
 190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
 191     return 0;
 192   }
 193   arg1 = *argp1;
 194   {
 195     try {
 196       result = Dali::Timer::DownCast(arg1);
 197     } CALL_CATCH_EXCEPTION(0);
 198   }
 199
 200   jresult = new Dali::Timer((const Dali::Timer &)result);
 201   return jresult;
 202 }
 203
 204
 205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
 206   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
 207
 208   arg1 = (Dali::Timer *)jarg1;
 209   {
 210     try {
 211       (arg1)->Start();
 212     } CALL_CATCH_EXCEPTION();
 213   }
 214
 215 }
 216
 217
 218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
 219   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
 220
 221   arg1 = (Dali::Timer *)jarg1;
 222   {
 223     try {
 224       (arg1)->Stop();
 225     } CALL_CATCH_EXCEPTION();
 226   }
 227
 228 }
 229
 230
 231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
 232   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
 233   unsigned int arg2 ;
 234
 235   arg1 = (Dali::Timer *)jarg1;
 236   arg2 = (unsigned int)jarg2;
 237   {
 238     try {
 239       (arg1)->SetInterval(arg2);
 240     } CALL_CATCH_EXCEPTION();
 241   }
 242
 243 }
 244
 245
 246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
 247   unsigned int jresult ;
 248   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
 249   unsigned int result;
 250
 251   arg1 = (Dali::Timer *)jarg1;
 252   {
 253     try {
 254       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
 255     } CALL_CATCH_EXCEPTION(0);
 256   }
 257
 258   jresult = result;
 259   return jresult;
 260 }
 261
 262
 263 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
 264   bool jresult ;
 265   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
 266   bool result;
 267
 268   arg1 = (Dali::Timer *)jarg1;
 269   {
 270     try {
 271       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
 272     } CALL_CATCH_EXCEPTION(0);
 273   }
 274
 275   jresult = result;
 276   return jresult;
 277 }
 278
 279
 280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
 281   void * jresult ;
 282   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
 283   Dali::Timer::TimerSignalType *result = 0 ;
 284
 285   arg1 = (Dali::Timer *)jarg1;
 286   {
 287     try {
 288       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
 289     } CALL_CATCH_EXCEPTION(0);
 290   }
 291
 292   jresult = (void *)result;
 293   return jresult;
 294 }
 295
 296
 297 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
 298   bool jresult ;
 299   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
 300   bool result;
 301
 302   arg1 = (Dali::Signal< bool () > *)jarg1;
 303   {
 304     try {
 305       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
 306     } CALL_CATCH_EXCEPTION(0);
 307   }
 308
 309   jresult = result;
 310   return jresult;
 311 }
 312
 313
 314 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
 315   unsigned long jresult ;
 316   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
 317   std::size_t result;
 318
 319   arg1 = (Dali::Signal< bool () > *)jarg1;
 320   {
 321     try {
 322       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
 323     } CALL_CATCH_EXCEPTION(0);
 324   }
 325
 326   jresult = (unsigned long)result;
 327   return jresult;
 328 }
 329
 330
 331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
 332   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
 333   bool (*arg2)() = (bool (*)()) 0 ;
 334
 335   arg1 = (Dali::Signal< bool () > *)jarg1;
 336   arg2 = (bool (*)())jarg2;
 337   {
 338     try {
 339       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
 340     } CALL_CATCH_EXCEPTION();
 341   }
 342
 343 }
 344
 345
 346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
 347   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
 348   bool (*arg2)() = (bool (*)()) 0 ;
 349
 350   arg1 = (Dali::Signal< bool () > *)jarg1;
 351   arg2 = (bool (*)())jarg2;
 352   {
 353     try {
 354       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
 355     } CALL_CATCH_EXCEPTION();
 356   }
 357
 358 }
 359
 360
 361 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
 362   bool jresult ;
 363   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
 364   bool result;
 365
 366   arg1 = (Dali::Signal< bool () > *)jarg1;
 367   {
 368     try {
 369       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
 370     } CALL_CATCH_EXCEPTION(0);
 371   }
 372
 373   jresult = result;
 374   return jresult;
 375 }
 376
 377
 378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
 379   void * jresult ;
 380   Dali::Signal< bool () > *result = 0 ;
 381
 382   {
 383     try {
 384       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
 385     } CALL_CATCH_EXCEPTION(0);
 386   }
 387
 388   jresult = (void *)result;
 389   return jresult;
 390 }
 391
 392
 393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
 394   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
 395
 396   arg1 = (Dali::Signal< bool () > *)jarg1;
 397   {
 398     try {
 399       delete arg1;
 400     } CALL_CATCH_EXCEPTION();
 401   }
 402
 403 }
 404
 405
 406 // PixelBuffer
 407
 408 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
 409     return (Dali::BaseHandle *)jarg1;
 410 }
 411
 412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
 413   void * jresult ;
 414   unsigned int arg1 ;
 415   unsigned int arg2 ;
 416   Dali::Pixel::Format arg3 ;
 417   Dali::Devel::PixelBuffer result;
 418
 419   arg1 = (unsigned int)jarg1;
 420   arg2 = (unsigned int)jarg2;
 421   arg3 = (Dali::Pixel::Format)jarg3;
 422   {
 423     try {
 424       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
 425     } CALL_CATCH_EXCEPTION(0);
 426   }
 427   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
 428   return jresult;
 429 }
 430
 431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
 432   void * jresult ;
 433   Dali::Devel::PixelBuffer *result = 0 ;
 434
 435   {
 436     try {
 437       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
 438     } CALL_CATCH_EXCEPTION(0);
 439   }
 440   jresult = (void *)result;
 441   return jresult;
 442 }
 443
 444
 445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
 446   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
 447
 448   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
 449   {
 450     try {
 451       delete arg1;
 452     } CALL_CATCH_EXCEPTION();
 453   }
 454 }
 455
 456
 457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
 458   void * jresult ;
 459   Dali::Devel::PixelBuffer *arg1 = 0 ;
 460   Dali::Devel::PixelBuffer *result = 0 ;
 461
 462   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
 463   if (!arg1) {
 464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
 465     return 0;
 466   }
 467   {
 468     try {
 469       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
 470     } CALL_CATCH_EXCEPTION(0);
 471   }
 472   jresult = (void *)result;
 473   return jresult;
 474 }
 475
 476
 477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
 478   void * jresult ;
 479   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
 480   Dali::Devel::PixelBuffer *arg2 = 0 ;
 481   Dali::Devel::PixelBuffer *result = 0 ;
 482
 483   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
 484   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
 485   if (!arg2) {
 486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
 487     return 0;
 488   }
 489   {
 490     try {
 491       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
 492     } CALL_CATCH_EXCEPTION(0);
 493   }
 494   jresult = (void *)result;
 495   return jresult;
 496 }
 497
 498
 499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
 500   void * jresult ;
 501   Dali::Devel::PixelBuffer *arg1 = 0 ;
 502   Dali::PixelData result;
 503
 504   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
 505   if (!arg1) {
 506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
 507     return 0;
 508   }
 509   {
 510     try {
 511       result = Dali::Devel::PixelBuffer::Convert(*arg1);
 512     } CALL_CATCH_EXCEPTION(0);
 513   }
 514   jresult = new Dali::PixelData((const Dali::PixelData &)result);
 515   return jresult;
 516 }
 517
 518
 519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
 520   void * jresult ;
 521   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
 522   Dali::PixelData result;
 523
 524   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
 525   {
 526     try {
 527       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
 528     } CALL_CATCH_EXCEPTION(0);
 529   }
 530   jresult = new Dali::PixelData((const Dali::PixelData &)result);
 531   return jresult;
 532 }
 533
 534
 535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
 536   void * jresult ;
 537   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
 538   unsigned char *result = 0 ;
 539
 540   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
 541   {
 542     try {
 543       result = (unsigned char *)(arg1)->GetBuffer();
 544     } CALL_CATCH_EXCEPTION(0);
 545   }
 546    jresult = (void *)result;
 547    return jresult;
 548 }
 549
 550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
 551   unsigned int jresult ;
 552   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
 553   unsigned int result;
 554
 555   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
 556   {
 557     try {
 558       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
 559     } CALL_CATCH_EXCEPTION(0);
 560   }
 561   jresult = result;
 562   return jresult;
 563 }
 564
 565
 566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
 567   unsigned int jresult ;
 568   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
 569   unsigned int result;
 570
 571   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
 572   {
 573     try {
 574       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
 575     } CALL_CATCH_EXCEPTION(0);
 576   }
 577   jresult = result;
 578   return jresult;
 579 }
 580
 581
 582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
 583   int jresult ;
 584   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
 585   Dali::Pixel::Format result;
 586
 587   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
 588   {
 589     try {
 590       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
 591     } CALL_CATCH_EXCEPTION(0);
 592   }
 593   jresult = (int)result;
 594   return jresult;
 595 }
 596
 597
 598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, bool jarg4) {
 599   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
 600   Dali::Devel::PixelBuffer arg2 ;
 601   float arg3 ;
 602   bool arg4 ;
 603   Dali::Devel::PixelBuffer *argp2 ;
 604
 605   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
 606   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
 607   if (!argp2) {
 608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
 609     return ;
 610   }
 611   arg2 = *argp2;
 612   arg3 = (float)jarg3;
 613   arg4 = jarg4 ? true : false;
 614   {
 615     try {
 616       (arg1)->ApplyMask(arg2,arg3,arg4);
 617     } CALL_CATCH_EXCEPTION();
 618   }
 619 }
 620
 621
 622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
 623   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
 624   Dali::Devel::PixelBuffer arg2 ;
 625   float arg3 ;
 626   Dali::Devel::PixelBuffer *argp2 ;
 627
 628   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
 629   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
 630   if (!argp2) {
 631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
 632     return ;
 633   }
 634   arg2 = *argp2;
 635   arg3 = (float)jarg3;
 636   {
 637     try {
 638       (arg1)->ApplyMask(arg2,arg3);
 639     } CALL_CATCH_EXCEPTION();
 640   }
 641 }
 642
 643
 644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
 645   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
 646   Dali::Devel::PixelBuffer arg2 ;
 647   Dali::Devel::PixelBuffer *argp2 ;
 648
 649   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
 650   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
 651   if (!argp2) {
 652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
 653     return ;
 654   }
 655   arg2 = *argp2;
 656   {
 657     try {
 658       (arg1)->ApplyMask(arg2);
 659     } CALL_CATCH_EXCEPTION();
 660   }
 661 }
 662
 663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
 664   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
 665   float arg2 ;
 666
 667   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
 668   arg2 = (float)jarg2;
 669   {
 670     try {
 671       (arg1)->ApplyGaussianBlur(arg2);
 672     } CALL_CATCH_EXCEPTION();
 673   }
 674 }
 675
 676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
 677   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
 678   uint16_t arg2 ;
 679   uint16_t arg3 ;
 680   uint16_t arg4 ;
 681   uint16_t arg5 ;
 682
 683   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
 684   arg2 = (uint16_t)jarg2;
 685   arg3 = (uint16_t)jarg3;
 686   arg4 = (uint16_t)jarg4;
 687   arg5 = (uint16_t)jarg5;
 688   {
 689     try {
 690       (arg1)->Crop(arg2,arg3,arg4,arg5);
 691     } CALL_CATCH_EXCEPTION();
 692   }
 693 }
 694
 695
 696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
 697   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
 698   uint16_t arg2 ;
 699   uint16_t arg3 ;
 700
 701   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
 702   arg2 = (uint16_t)jarg2;
 703   arg3 = (uint16_t)jarg3;
 704   {
 705     try {
 706       (arg1)->Resize(arg2,arg3);
 707     } CALL_CATCH_EXCEPTION();
 708   }
 709 }
 710
 711 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void* jarg2) {
 712   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
 713   Dali::Degree * arg2 ;
 714
 715   bool result = false;
 716
 717   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
 718   arg2 = (Dali::Degree *)jarg2;
 719   {
 720     try {
 721       result = (arg1)->Rotate(*arg2);
 722     } CALL_CATCH_EXCEPTION(false);
 723   }
 724   return result;
 725 }
 726
 727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBrightness(void * jarg1) {
 728   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
 729   uint32_t result = 0;
 730
 731   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
 732   {
 733     try {
 734       result = (arg1)->GetBrightness();
 735     } CALL_CATCH_EXCEPTION(0);
 736   }
 737   return result;
 738 }
 739
 740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
 741   void * jresult ;
 742   std::string *arg1 = 0 ;
 743   Dali::ImageDimensions arg2 ;
 744   Dali::FittingMode::Type arg3 ;
 745   Dali::SamplingMode::Type arg4 ;
 746   bool arg5 ;
 747   Dali::ImageDimensions *argp2 ;
 748   Dali::Devel::PixelBuffer result;
 749
 750   if (!jarg1) {
 751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 752     return 0;
 753   }
 754   std::string arg1_str(jarg1);
 755   arg1 = &arg1_str;
 756   argp2 = (Dali::ImageDimensions *)jarg2;
 757   if (!argp2) {
 758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
 759     return 0;
 760   }
 761   arg2 = *argp2;
 762   arg3 = (Dali::FittingMode::Type)jarg3;
 763   arg4 = (Dali::SamplingMode::Type)jarg4;
 764   arg5 = jarg5 ? true : false;
 765   {
 766     try {
 767       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
 768     } CALL_CATCH_EXCEPTION(0);
 769   }
 770   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
 771   return jresult;
 772 }
 773
 774
 775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
 776   void * jresult ;
 777   std::string *arg1 = 0 ;
 778   Dali::ImageDimensions arg2 ;
 779   Dali::FittingMode::Type arg3 ;
 780   Dali::SamplingMode::Type arg4 ;
 781   Dali::ImageDimensions *argp2 ;
 782   Dali::Devel::PixelBuffer result;
 783
 784   if (!jarg1) {
 785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 786     return 0;
 787   }
 788   std::string arg1_str(jarg1);
 789   arg1 = &arg1_str;
 790   argp2 = (Dali::ImageDimensions *)jarg2;
 791   if (!argp2) {
 792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
 793     return 0;
 794   }
 795   arg2 = *argp2;
 796   arg3 = (Dali::FittingMode::Type)jarg3;
 797   arg4 = (Dali::SamplingMode::Type)jarg4;
 798   {
 799     try {
 800       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
 801     } CALL_CATCH_EXCEPTION(0);
 802   }
 803   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
 804   return jresult;
 805 }
 806
 807
 808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
 809   void * jresult ;
 810   std::string *arg1 = 0 ;
 811   Dali::ImageDimensions arg2 ;
 812   Dali::FittingMode::Type arg3 ;
 813   Dali::ImageDimensions *argp2 ;
 814   Dali::Devel::PixelBuffer result;
 815
 816   if (!jarg1) {
 817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 818     return 0;
 819   }
 820   std::string arg1_str(jarg1);
 821   arg1 = &arg1_str;
 822   argp2 = (Dali::ImageDimensions *)jarg2;
 823   if (!argp2) {
 824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
 825     return 0;
 826   }
 827   arg2 = *argp2;
 828   arg3 = (Dali::FittingMode::Type)jarg3;
 829   {
 830     try {
 831       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
 832     } CALL_CATCH_EXCEPTION(0);
 833   }
 834   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
 835   return jresult;
 836 }
 837
 838
 839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
 840   void * jresult ;
 841   std::string *arg1 = 0 ;
 842   Dali::ImageDimensions arg2 ;
 843   Dali::ImageDimensions *argp2 ;
 844   Dali::Devel::PixelBuffer result;
 845
 846   if (!jarg1) {
 847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 848     return 0;
 849   }
 850   std::string arg1_str(jarg1);
 851   arg1 = &arg1_str;
 852   argp2 = (Dali::ImageDimensions *)jarg2;
 853   if (!argp2) {
 854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
 855     return 0;
 856   }
 857   arg2 = *argp2;
 858   {
 859     try {
 860       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
 861     } CALL_CATCH_EXCEPTION(0);
 862   }
 863   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
 864   return jresult;
 865 }
 866
 867
 868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
 869   void * jresult ;
 870   std::string *arg1 = 0 ;
 871   Dali::Devel::PixelBuffer result;
 872
 873   if (!jarg1) {
 874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 875     return 0;
 876   }
 877   std::string arg1_str(jarg1);
 878   arg1 = &arg1_str;
 879   {
 880     try {
 881       result = Dali::LoadImageFromFile((std::string const &)*arg1);
 882     } CALL_CATCH_EXCEPTION(0);
 883   }
 884   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
 885   return jresult;
 886 }
 887
 888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_0(void * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
 889   void * jresult ;
 890   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
 891   Dali::ImageDimensions arg2 ;
 892   Dali::FittingMode::Type arg3 ;
 893   Dali::SamplingMode::Type arg4 ;
 894   bool arg5 ;
 895   Dali::ImageDimensions *argp2 ;
 896   Dali::Devel::PixelBuffer result;
 897
 898   if (!jarg1) {
 899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
 900     return 0;
 901   }
 902   arg1 = (Dali::Vector<uint8_t> *)jarg1;
 903   argp2 = (Dali::ImageDimensions *)jarg2;
 904   if (!argp2) {
 905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
 906     return 0;
 907   }
 908   arg2 = *argp2;
 909   arg3 = (Dali::FittingMode::Type)jarg3;
 910   arg4 = (Dali::SamplingMode::Type)jarg4;
 911   arg5 = jarg5 ? true : false;
 912   {
 913     try {
 914       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3, arg4, arg5);
 915     } CALL_CATCH_EXCEPTION(0);
 916   }
 917   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
 918   return jresult;
 919 }
 920
 921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_1(void * jarg1, void * jarg2, int jarg3, int jarg4) {
 922   void * jresult ;
 923   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
 924   Dali::ImageDimensions arg2 ;
 925   Dali::FittingMode::Type arg3 ;
 926   Dali::SamplingMode::Type arg4 ;
 927   Dali::ImageDimensions *argp2 ;
 928   Dali::Devel::PixelBuffer result;
 929
 930   if (!jarg1) {
 931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
 932     return 0;
 933   }
 934   arg1 = (Dali::Vector<uint8_t> *)jarg1;
 935   argp2 = (Dali::ImageDimensions *)jarg2;
 936   if (!argp2) {
 937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
 938     return 0;
 939   }
 940   arg2 = *argp2;
 941   arg3 = (Dali::FittingMode::Type)jarg3;
 942   arg4 = (Dali::SamplingMode::Type)jarg4;
 943   {
 944     try {
 945       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3, arg4);
 946     } CALL_CATCH_EXCEPTION(0);
 947   }
 948   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
 949   return jresult;
 950 }
 951
 952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_2(void * jarg1, void * jarg2, int jarg3) {
 953   void * jresult ;
 954   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
 955   Dali::ImageDimensions arg2 ;
 956   Dali::FittingMode::Type arg3 ;
 957   Dali::ImageDimensions *argp2 ;
 958   Dali::Devel::PixelBuffer result;
 959
 960   if (!jarg1) {
 961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
 962     return 0;
 963   }
 964   arg1 = (Dali::Vector<uint8_t> *)jarg1;
 965   argp2 = (Dali::ImageDimensions *)jarg2;
 966   if (!argp2) {
 967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
 968     return 0;
 969   }
 970   arg2 = *argp2;
 971   arg3 = (Dali::FittingMode::Type)jarg3;
 972   {
 973     try {
 974       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2, arg3);
 975     } CALL_CATCH_EXCEPTION(0);
 976   }
 977   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
 978   return jresult;
 979 }
 980
 981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_3(void * jarg1, void * jarg2) {
 982   void * jresult ;
 983   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
 984   Dali::ImageDimensions arg2 ;
 985   Dali::ImageDimensions *argp2 ;
 986   Dali::Devel::PixelBuffer result;
 987
 988   if (!jarg1) {
 989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
 990     return 0;
 991   }
 992   arg1 = (Dali::Vector<uint8_t> *)jarg1;
 993   argp2 = (Dali::ImageDimensions *)jarg2;
 994   if (!argp2) {
 995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
 996     return 0;
 997   }
 998   arg2 = *argp2;
 999   {
1000     try {
1001       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1, arg2);
1002     } CALL_CATCH_EXCEPTION(0);
1003   }
1004   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
1005   return jresult;
1006 }
1007
1008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_4(void * jarg1) {
1009   void * jresult ;
1010   Dali::Vector<uint8_t> *arg1 = (Dali::Vector<uint8_t> *) 0;
1011   Dali::Devel::PixelBuffer result;
1012
1013   if (!jarg1) {
1014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
1015     return 0;
1016   }
1017   arg1 = (Dali::Vector<uint8_t> *)jarg1;
1018   {
1019     try {
1020       result = Dali::LoadImageFromBuffer((const Dali::Vector<uint8_t>&)*arg1);
1021     } CALL_CATCH_EXCEPTION(0);
1022   }
1023   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
1024   return jresult;
1025 }
1026
1027
1028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
1029   void * jresult ;
1030   std::string *arg1 = 0 ;
1031   Dali::ImageDimensions arg2 ;
1032   Dali::FittingMode::Type arg3 ;
1033   Dali::SamplingMode::Type arg4 ;
1034   bool arg5 ;
1035   Dali::ImageDimensions *argp2 ;
1036   Dali::Devel::PixelBuffer result;
1037
1038   if (!jarg1) {
1039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1040     return 0;
1041   }
1042   std::string arg1_str(jarg1);
1043   arg1 = &arg1_str;
1044   argp2 = (Dali::ImageDimensions *)jarg2;
1045   if (!argp2) {
1046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
1047     return 0;
1048   }
1049   arg2 = *argp2;
1050   arg3 = (Dali::FittingMode::Type)jarg3;
1051   arg4 = (Dali::SamplingMode::Type)jarg4;
1052   arg5 = jarg5 ? true : false;
1053   {
1054     try {
1055       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
1056     } CALL_CATCH_EXCEPTION(0);
1057   }
1058   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
1059   return jresult;
1060 }
1061
1062
1063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
1064   void * jresult ;
1065   std::string *arg1 = 0 ;
1066   Dali::ImageDimensions arg2 ;
1067   Dali::FittingMode::Type arg3 ;
1068   Dali::SamplingMode::Type arg4 ;
1069   Dali::ImageDimensions *argp2 ;
1070   Dali::Devel::PixelBuffer result;
1071
1072   if (!jarg1) {
1073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1074     return 0;
1075   }
1076   std::string arg1_str(jarg1);
1077   arg1 = &arg1_str;
1078   argp2 = (Dali::ImageDimensions *)jarg2;
1079   if (!argp2) {
1080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
1081     return 0;
1082   }
1083   arg2 = *argp2;
1084   arg3 = (Dali::FittingMode::Type)jarg3;
1085   arg4 = (Dali::SamplingMode::Type)jarg4;
1086   {
1087     try {
1088       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
1089     } CALL_CATCH_EXCEPTION(0);
1090   }
1091   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
1092   return jresult;
1093 }
1094
1095
1096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
1097   void * jresult ;
1098   std::string *arg1 = 0 ;
1099   Dali::ImageDimensions arg2 ;
1100   Dali::FittingMode::Type arg3 ;
1101   Dali::ImageDimensions *argp2 ;
1102   Dali::Devel::PixelBuffer result;
1103
1104   if (!jarg1) {
1105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1106     return 0;
1107   }
1108   std::string arg1_str(jarg1);
1109   arg1 = &arg1_str;
1110   argp2 = (Dali::ImageDimensions *)jarg2;
1111   if (!argp2) {
1112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
1113     return 0;
1114   }
1115   arg2 = *argp2;
1116   arg3 = (Dali::FittingMode::Type)jarg3;
1117   {
1118     try {
1119       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
1120     } CALL_CATCH_EXCEPTION(0);
1121   }
1122   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
1123   return jresult;
1124 }
1125
1126
1127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
1128   void * jresult ;
1129   std::string *arg1 = 0 ;
1130   Dali::ImageDimensions arg2 ;
1131   Dali::ImageDimensions *argp2 ;
1132   Dali::Devel::PixelBuffer result;
1133
1134   if (!jarg1) {
1135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1136     return 0;
1137   }
1138   std::string arg1_str(jarg1);
1139   arg1 = &arg1_str;
1140   argp2 = (Dali::ImageDimensions *)jarg2;
1141   if (!argp2) {
1142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
1143     return 0;
1144   }
1145   arg2 = *argp2;
1146   {
1147     try {
1148       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
1149     } CALL_CATCH_EXCEPTION(0);
1150   }
1151   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
1152   return jresult;
1153 }
1154
1155
1156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
1157   void * jresult ;
1158   std::string *arg1 = 0 ;
1159   Dali::Devel::PixelBuffer result;
1160
1161   if (!jarg1) {
1162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1163     return 0;
1164   }
1165   std::string arg1_str(jarg1);
1166   arg1 = &arg1_str;
1167   {
1168     try {
1169       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
1170     } CALL_CATCH_EXCEPTION(0);
1171   }
1172   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
1173   return jresult;
1174 }
1175
1176
1177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1, bool jarg2) {
1178   void * jresult ;
1179   std::string *arg1 = 0 ;
1180   bool arg2 ;
1181   Dali::ImageDimensions result;
1182
1183   if (!jarg1) {
1184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1185     return 0;
1186   }
1187   std::string arg1_str(jarg1);
1188   arg1 = &arg1_str;
1189   arg2 = jarg2 ? true : false;
1190   {
1191     try {
1192       result = Dali::GetOriginalImageSize((std::string const &)*arg1,arg2);
1193     } CALL_CATCH_EXCEPTION(0);
1194   }
1195   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
1196   return jresult;
1197 }
1198
1199
1200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) {
1201   void * jresult ;
1202   std::string *arg1 = 0 ;
1203   Dali::ImageDimensions arg2 ;
1204   Dali::FittingMode::Type arg3 ;
1205   Dali::SamplingMode::Type arg4 ;
1206   bool arg5 ;
1207   Dali::ImageDimensions *argp2 ;
1208   Dali::ImageDimensions result;
1209
1210   if (!jarg1) {
1211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1212     return 0;
1213   }
1214   std::string arg1_str(jarg1);
1215   arg1 = &arg1_str;
1216   argp2 = (Dali::ImageDimensions *)jarg2;
1217   if (!argp2) {
1218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
1219     return 0;
1220   }
1221   arg2 = *argp2;
1222   arg3 = (Dali::FittingMode::Type)jarg3;
1223   arg4 = (Dali::SamplingMode::Type)jarg4;
1224   arg5 = jarg5 ? true : false;
1225   {
1226     try {
1227       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
1228     } CALL_CATCH_EXCEPTION(0);
1229   }
1230   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
1231   return jresult;
1232 }
1233
1234
1235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
1236   void * jresult ;
1237   std::string *arg1 = 0 ;
1238   Dali::ImageDimensions arg2 ;
1239   Dali::FittingMode::Type arg3 ;
1240   Dali::SamplingMode::Type arg4 ;
1241   Dali::ImageDimensions *argp2 ;
1242   Dali::ImageDimensions result;
1243
1244   if (!jarg1) {
1245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1246     return 0;
1247   }
1248   std::string arg1_str(jarg1);
1249   arg1 = &arg1_str;
1250   argp2 = (Dali::ImageDimensions *)jarg2;
1251   if (!argp2) {
1252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
1253     return 0;
1254   }
1255   arg2 = *argp2;
1256   arg3 = (Dali::FittingMode::Type)jarg3;
1257   arg4 = (Dali::SamplingMode::Type)jarg4;
1258   {
1259     try {
1260       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
1261     } CALL_CATCH_EXCEPTION(0);
1262   }
1263   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
1264   return jresult;
1265 }
1266
1267
1268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
1269   void * jresult ;
1270   std::string *arg1 = 0 ;
1271   Dali::ImageDimensions arg2 ;
1272   Dali::FittingMode::Type arg3 ;
1273   Dali::ImageDimensions *argp2 ;
1274   Dali::ImageDimensions result;
1275
1276   if (!jarg1) {
1277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1278     return 0;
1279   }
1280   std::string arg1_str(jarg1);
1281   arg1 = &arg1_str;
1282   argp2 = (Dali::ImageDimensions *)jarg2;
1283   if (!argp2) {
1284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
1285     return 0;
1286   }
1287   arg2 = *argp2;
1288   arg3 = (Dali::FittingMode::Type)jarg3;
1289   {
1290     try {
1291       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
1292     } CALL_CATCH_EXCEPTION(0);
1293   }
1294   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
1295   return jresult;
1296 }
1297
1298
1299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
1300   void * jresult ;
1301   std::string *arg1 = 0 ;
1302   Dali::ImageDimensions arg2 ;
1303   Dali::ImageDimensions *argp2 ;
1304   Dali::ImageDimensions result;
1305
1306   if (!jarg1) {
1307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1308     return 0;
1309   }
1310   std::string arg1_str(jarg1);
1311   arg1 = &arg1_str;
1312   argp2 = (Dali::ImageDimensions *)jarg2;
1313   if (!argp2) {
1314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
1315     return 0;
1316   }
1317   arg2 = *argp2;
1318   {
1319     try {
1320       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
1321     } CALL_CATCH_EXCEPTION(0);
1322   }
1323   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
1324   return jresult;
1325 }
1326
1327
1328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
1329   void * jresult ;
1330   std::string *arg1 = 0 ;
1331   Dali::ImageDimensions result;
1332
1333   if (!jarg1) {
1334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1335     return 0;
1336   }
1337   std::string arg1_str(jarg1);
1338   arg1 = &arg1_str;
1339   {
1340     try {
1341       result = Dali::GetClosestImageSize((std::string const &)*arg1);
1342     } CALL_CATCH_EXCEPTION(0);
1343   }
1344   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
1345   return jresult;
1346 }
1347
1348
1349 // NativeImageSource
1350
1351 struct NativeImageSourcePtrHandle
1352 {
1353   NativeImageSourcePtr Ptr;
1354 };
1355
1356 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
1357 {
1358   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
1359   return (NativeImageInterface*)(arg1);
1360 }
1361
1362 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
1363 {
1364   void* jresult;
1365   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
1366   {
1367     try {
1368       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
1369     }
1370     catch (std::out_of_range & e) {
1371       {
1372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1373       };
1374     }
1375     catch (std::exception & e) {
1376       {
1377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1378       };
1379     }
1380     catch (Dali::DaliException e) {
1381       {
1382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1383       };
1384     }
1385     catch (...) {
1386       {
1387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1388       };
1389     }
1390   }
1391   jresult = (void *)handle;
1392   return jresult;
1393 }
1394
1395 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
1396 {
1397   void* jresult;
1398   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
1399   jresult = (void*)( handle->Ptr.Get() );
1400   return jresult;
1401 }
1402
1403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
1404   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
1405   {
1406     try {
1407       delete arg1;
1408     }
1409     catch (std::out_of_range & e) {
1410       {
1411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
1412       };
1413     }
1414     catch (std::exception & e) {
1415       {
1416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
1417       };
1418     }
1419     catch (Dali::DaliException e) {
1420       {
1421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
1422       };
1423     }
1424     catch (...) {
1425       {
1426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
1427       };
1428     }
1429   }
1430 }
1431
1432 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
1433 {
1434   void* jresult;
1435   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
1436   uint32_t* arg2 = (uint32_t*)(jarg2);
1437   uint32_t* arg3 = (uint32_t*)(jarg3);
1438   uint32_t* arg4 = (uint32_t*)(jarg4);
1439   {
1440     try {
1441       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
1442     }
1443     catch (std::out_of_range & e) {
1444       {
1445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1446       };
1447     }
1448     catch (std::exception & e) {
1449       {
1450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1451       };
1452     }
1453     catch (Dali::DaliException e) {
1454       {
1455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1456       };
1457     }
1458     catch (...) {
1459       {
1460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1461       };
1462     }
1463   }
1464   return jresult;
1465 }
1466
1467 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
1468 {
1469   bool jresult;
1470   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
1471
1472   {
1473     try {
1474       jresult = Dali::DevelNativeImageSource::ReleaseBuffer(*arg1, Rect<uint32_t>{});
1475     }
1476     catch (std::out_of_range & e) {
1477       {
1478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1479       };
1480     }
1481     catch (std::exception & e) {
1482       {
1483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1484       };
1485     }
1486     catch (Dali::DaliException e) {
1487       {
1488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
1489       };
1490     }
1491     catch (...) {
1492       {
1493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1494       };
1495     }
1496   }
1497   return jresult;
1498 }
1499
1500
1501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_EnableBackBuffer(void* nativeImageHandle, bool enable)
1502 {
1503   NativeImageSource* nativeImage = static_cast<NativeImageSource*>(nativeImageHandle);
1504
1505   if(!nativeImage)
1506   {
1507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "nativeImageHandle is null", 0);
1508     return;
1509   }
1510   {
1511     try
1512     {
1513       Dali::DevelNativeImageSource::EnableBackBuffer(*nativeImage, enable);
1514     }
1515     CALL_CATCH_EXCEPTION();
1516   }
1517 }
1518
1519
1520 /*
1521  * Widget binding
1522  */
1523 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
1524     return (Dali::BaseHandle *)jarg1;
1525 }
1526
1527 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
1528     return (Dali::BaseObject *)jarg1;
1529 }
1530
1531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
1532   void * jresult ;
1533   Dali::Widget result;
1534
1535   {
1536     try {
1537       result = Dali::Widget::New();
1538     } CALL_CATCH_EXCEPTION(0);
1539   }
1540
1541   jresult = new Dali::Widget((const Dali::Widget &)result);
1542   return jresult;
1543 }
1544
1545
1546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
1547   void * jresult ;
1548   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
1549   Dali::Widget result;
1550
1551   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1552
1553   if (!arg1) {
1554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
1555     return 0;
1556   }
1557   {
1558     try {
1559       jresult = new Dali::Widget(arg1);
1560     } CALL_CATCH_EXCEPTION(0);
1561   }
1562   return jresult;
1563 }
1564
1565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
1566   void * jresult ;
1567   Dali::Widget *result = 0 ;
1568
1569   {
1570     try {
1571       result = (Dali::Widget *)new Dali::Widget();
1572     } CALL_CATCH_EXCEPTION(0);
1573   }
1574   jresult = (void *)result;
1575   return jresult;
1576 }
1577
1578
1579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
1580   void * jresult ;
1581   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
1582   Dali::Widget *arg2 = 0 ;
1583   Dali::Widget *result = 0 ;
1584
1585   arg1 = (Dali::Widget *)jarg1;
1586   arg2 = (Dali::Widget *)jarg2;
1587   if (!arg2) {
1588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
1589     return 0;
1590   }
1591   {
1592     try {
1593       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
1594     } CALL_CATCH_EXCEPTION(0);
1595   }
1596   jresult = (void *)result;
1597   return jresult;
1598 }
1599
1600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
1601   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
1602
1603   arg1 = (Dali::Widget *)jarg1;
1604   {
1605     try {
1606       delete arg1;
1607     } CALL_CATCH_EXCEPTION();
1608   }
1609 }
1610
1611
1612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
1613   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1614   std::string *arg2 = 0 ;
1615   Dali::Window arg3 ;
1616   Dali::Window *argp3 ;
1617
1618   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1619   if (!jarg2) {
1620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1621     return ;
1622   }
1623   std::string arg2_str(jarg2);
1624   arg2 = &arg2_str;
1625   argp3 = (Dali::Window *)jarg3;
1626   if (!argp3) {
1627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1628     return ;
1629   }
1630   arg3 = *argp3;
1631   {
1632     try {
1633       (arg1)->OnCreate((std::string const &)*arg2,arg3);
1634     } CALL_CATCH_EXCEPTION();
1635   }
1636 }
1637
1638
1639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
1640   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1641   std::string *arg2 = 0 ;
1642   Dali::Window arg3 ;
1643   Dali::Window *argp3 ;
1644
1645   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1646   if (!jarg2) {
1647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1648     return ;
1649   }
1650   std::string arg2_str(jarg2);
1651   arg2 = &arg2_str;
1652   argp3 = (Dali::Window *)jarg3;
1653   if (!argp3) {
1654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1655     return ;
1656   }
1657   arg3 = *argp3;
1658   {
1659     try {
1660       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
1661     } CALL_CATCH_EXCEPTION();
1662   }
1663 }
1664
1665
1666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
1667   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1668   std::string *arg2 = 0 ;
1669   Dali::Widget::Termination arg3 ;
1670
1671   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1672   if (!jarg2) {
1673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1674     return ;
1675   }
1676   std::string arg2_str(jarg2);
1677   arg2 = &arg2_str;
1678   arg3 = (Dali::Widget::Termination)jarg3;
1679   {
1680     try {
1681       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
1682     } CALL_CATCH_EXCEPTION();
1683   }
1684 }
1685
1686
1687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
1688   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1689   std::string *arg2 = 0 ;
1690   Dali::Widget::Termination arg3 ;
1691
1692   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1693   if (!jarg2) {
1694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1695     return ;
1696   }
1697   std::string arg2_str(jarg2);
1698   arg2 = &arg2_str;
1699   arg3 = (Dali::Widget::Termination)jarg3;
1700   {
1701     try {
1702       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
1703     } CALL_CATCH_EXCEPTION();
1704   }
1705 }
1706
1707
1708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
1709   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1710
1711   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1712   {
1713     try {
1714       (arg1)->OnPause();
1715     } CALL_CATCH_EXCEPTION();
1716   }
1717 }
1718
1719
1720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
1721   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1722
1723   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1724   {
1725     try {
1726       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
1727     } CALL_CATCH_EXCEPTION();
1728   }
1729 }
1730
1731
1732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
1733   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1734
1735   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1736   {
1737     try {
1738       (arg1)->OnResume();
1739     } CALL_CATCH_EXCEPTION();
1740   }
1741 }
1742
1743
1744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
1745   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1746
1747   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1748   {
1749     try {
1750       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
1751     } CALL_CATCH_EXCEPTION();
1752   }
1753 }
1754
1755
1756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
1757   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1758   Dali::Window arg2 ;
1759   Dali::Window *argp2 ;
1760
1761   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1762   argp2 = (Dali::Window *)jarg2;
1763   if (!argp2) {
1764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1765     return ;
1766   }
1767   arg2 = *argp2;
1768   {
1769     try {
1770       (arg1)->OnResize(arg2);
1771     } CALL_CATCH_EXCEPTION();
1772   }
1773 }
1774
1775
1776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
1777   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1778   Dali::Window arg2 ;
1779   Dali::Window *argp2 ;
1780
1781   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1782   argp2 = (Dali::Window *)jarg2;
1783   if (!argp2) {
1784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
1785     return ;
1786   }
1787   arg2 = *argp2;
1788   {
1789     try {
1790       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
1791     } CALL_CATCH_EXCEPTION();
1792   }
1793 }
1794
1795
1796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
1797   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1798   std::string *arg2 = 0 ;
1799   int arg3 ;
1800
1801   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1802   if (!jarg2) {
1803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1804     return ;
1805   }
1806   std::string arg2_str(jarg2);
1807   arg2 = &arg2_str;
1808   arg3 = (int)jarg3;
1809   {
1810     try {
1811       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
1812     } CALL_CATCH_EXCEPTION();
1813   }
1814 }
1815
1816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
1817   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1818   std::string *arg2 = 0 ;
1819   int arg3 ;
1820
1821   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1822   if (!jarg2) {
1823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1824     return ;
1825   }
1826   std::string arg2_str(jarg2);
1827   arg2 = &arg2_str;
1828   arg3 = (int)jarg3;
1829   {
1830     try {
1831       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
1832     } CALL_CATCH_EXCEPTION();
1833   }
1834 }
1835
1836
1837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
1838   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1839   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
1840   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
1841
1842   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1843   arg2 = (Dali::SlotObserver *)jarg2;
1844   arg3 = (Dali::CallbackBase *)jarg3;
1845   {
1846     try {
1847       (arg1)->SignalConnected(arg2,arg3);
1848     } CALL_CATCH_EXCEPTION();
1849   }
1850 }
1851
1852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
1853   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1854   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
1855   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
1856
1857   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1858   arg2 = (Dali::SlotObserver *)jarg2;
1859   arg3 = (Dali::CallbackBase *)jarg3;
1860   {
1861     try {
1862       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
1863     } CALL_CATCH_EXCEPTION();
1864   }
1865 }
1866
1867
1868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
1869   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1870   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
1871   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
1872
1873   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1874   arg2 = (Dali::SlotObserver *)jarg2;
1875   arg3 = (Dali::CallbackBase *)jarg3;
1876   {
1877     try {
1878       (arg1)->SignalDisconnected(arg2,arg3);
1879     } CALL_CATCH_EXCEPTION();
1880   }
1881 }
1882
1883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
1884   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1885   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
1886   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
1887
1888   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1889   arg2 = (Dali::SlotObserver *)jarg2;
1890   arg3 = (Dali::CallbackBase *)jarg3;
1891   {
1892     try {
1893       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
1894     } CALL_CATCH_EXCEPTION();
1895   }
1896 }
1897
1898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
1899   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1900   std::string *arg2 = 0 ;
1901
1902   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1903   if (!jarg2) {
1904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1905     return ;
1906   }
1907   std::string arg2_str(jarg2);
1908   arg2 = &arg2_str;
1909   {
1910     try {
1911       (arg1)->SetContentInfo((std::string const &)*arg2);
1912     } CALL_CATCH_EXCEPTION();
1913   }
1914 }
1915
1916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetUsingKeyEvent(void * jwidget, bool jflag) {
1917   Dali::Internal::Adaptor::Widget *widget = (Dali::Internal::Adaptor::Widget *) 0 ;
1918   bool flag;
1919
1920   widget = (Dali::Internal::Adaptor::Widget *)jwidget;
1921   flag = jflag ? true : false;
1922   {
1923     try {
1924       (widget)->SetUsingKeyEvent(flag);
1925     } CALL_CATCH_EXCEPTION();
1926   }
1927 }
1928
1929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
1930   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
1931   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
1932
1933   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
1934   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
1935   {
1936     try {
1937       (arg1)->SetImpl(arg2);
1938     } CALL_CATCH_EXCEPTION();
1939   }
1940 }
1941
1942
1943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
1944   void * jresult ;
1945   int *arg1 = (int *) 0 ;
1946   char ***arg2 ;
1947   std::string *arg3 = 0 ;
1948   Dali::WidgetApplication result;
1949   {
1950     int index = 0;
1951     int length = 0;
1952     char *retPtr;
1953     char *nextPtr;
1954     argWidgetC = jarg1;
1955     argWidgetV = new char*[jarg1 + 1];
1956
1957     retPtr = strtok_r( jarg2, " ", &nextPtr);
1958     if( retPtr )
1959     {
1960       length = strlen(retPtr);
1961     }
1962     argWidgetV[index] = new char[length + 1];
1963     if( retPtr )
1964     {
1965       strncpy(argWidgetV[index], retPtr, length);
1966     }
1967     argWidgetV[index][length] = '\0';
1968     index++;
1969
1970     while (index < jarg1)
1971     {
1972       length = 0;
1973       retPtr = strtok_r(NULL, " ", &nextPtr);
1974       if( retPtr )
1975       {
1976         length = strlen(retPtr);
1977       }
1978       argWidgetV[index] = new char[length + 1];
1979       if( retPtr )
1980       {
1981         strncpy(argWidgetV[index], retPtr, length);
1982       }
1983       argWidgetV[index][length] = '\0';
1984       index++;
1985     }
1986
1987     argWidgetV[jarg1] = NULL;
1988     argWidgetC = jarg1;
1989
1990     arg1 = &argWidgetC;
1991     arg2 = &argWidgetV;
1992   }
1993
1994   if (!jarg3) {
1995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1996     return 0;
1997   }
1998   std::string arg3_str(jarg3);
1999   arg3 = &arg3_str;
2000   {
2001     try {
2002       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
2003     } CALL_CATCH_EXCEPTION(0);
2004   }
2005   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
2006   return jresult;
2007 }
2008
2009
2010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
2011   void * jresult ;
2012   Dali::WidgetApplication *result = 0 ;
2013
2014   {
2015     try {
2016       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
2017     } CALL_CATCH_EXCEPTION(0);
2018   }
2019   jresult = (void *)result;
2020   return jresult;
2021 }
2022
2023
2024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
2025   void * jresult ;
2026   Dali::WidgetApplication *arg1 = 0 ;
2027   Dali::WidgetApplication *result = 0 ;
2028
2029   arg1 = (Dali::WidgetApplication *)jarg1;
2030   if (!arg1) {
2031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
2032     return 0;
2033   }
2034   {
2035     try {
2036       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
2037     } CALL_CATCH_EXCEPTION(0);
2038   }
2039   jresult = (void *)result;
2040   return jresult;
2041 }
2042
2043
2044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
2045   void * jresult ;
2046   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
2047   Dali::WidgetApplication *arg2 = 0 ;
2048   Dali::WidgetApplication *result = 0 ;
2049
2050   arg1 = (Dali::WidgetApplication *)jarg1;
2051   arg2 = (Dali::WidgetApplication *)jarg2;
2052   if (!arg2) {
2053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
2054     return 0;
2055   }
2056   {
2057     try {
2058       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
2059     } CALL_CATCH_EXCEPTION(0);
2060   }
2061   jresult = (void *)result;
2062   return jresult;
2063 }
2064
2065
2066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
2067   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
2068
2069   arg1 = (Dali::WidgetApplication *)jarg1;
2070   {
2071     try {
2072       delete arg1;
2073       if( argWidgetV )
2074       {
2075         // free string data
2076         for( int i=0; i < argWidgetC+1; i++)
2077         {
2078           delete [] argWidgetV[i];
2079         }
2080         delete [] argWidgetV;
2081       }
2082     } CALL_CATCH_EXCEPTION();
2083   }
2084 }
2085
2086
2087 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
2088 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
2089
2090 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
2091 {
2092   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
2093   return *widget;
2094 }
2095
2096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
2097   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
2098   std::string *arg2 = 0 ;
2099
2100   arg1 = (Dali::WidgetApplication *)jarg1;
2101   if (!jarg2) {
2102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
2103     return ;
2104   }
2105   std::string arg2_str(*jarg2);
2106   arg2 = &arg2_str;
2107
2108   if(!_CSharpCreateWidgetFunction)
2109   {
2110     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
2111   }
2112
2113   {
2114     try {
2115       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
2116     } CALL_CATCH_EXCEPTION();
2117   }
2118   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
2119 }
2120
2121
2122 #ifdef __cplusplus
2123 }
2124 #endif