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

   1 /*
   2  * Copyright (c) 2024 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // EXTERNAL INCLUDES
  19 #include <dali/devel-api/adaptor-framework/application-devel.h>
  20 #include <dali/integration-api/adaptor-framework/adaptor.h>
  21 #include <dali/public-api/adaptor-framework/application.h>
  22 #include <dali/public-api/adaptor-framework/window-enumerations.h>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali-csharp-binder/common/common.h>
  26
  27 /* Callback for returning strings to C# without leaking memory */
  28 typedef char*(SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char*);
  29 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
  30
  31 namespace
  32 {
  33 // keep argcs and argv so they're always available to DALi
  34 // Note : This argments used only if argv comes externally.
  35 int    gArgC = 0;
  36 char** gArgV = nullptr;
  37
  38 void ReleaseArgVMemory()
  39 {
  40   if(gArgV)
  41   {
  42     // free string data
  43     for(int i = 0; i < gArgC + 1; ++i)
  44     {
  45       delete[] gArgV[i];
  46     }
  47     delete[] gArgV;
  48     gArgV = nullptr;
  49   }
  50   gArgC = 0;
  51 }
  52
  53 void GenerationArgV(int argc, char* argv)
  54 {
  55   // TODO : What should we do if already generated argv exist?
  56   ReleaseArgVMemory();
  57   // generate argv data from the C# args
  58   int   index  = 0;
  59   int   length = 0;
  60   char* retPtr = NULL;
  61   char* nextPtr;
  62
  63   gArgV = new char*[argc + 1];
  64
  65   for(retPtr = strtok_r(argv, " ", &nextPtr);
  66       retPtr != NULL && index < argc;
  67       retPtr = strtok_r(NULL, " ", &nextPtr))
  68   {
  69     length       = 0;
  70     length       = strlen(retPtr);
  71     gArgV[index] = new char[length + 1];
  72     strncpy(gArgV[index], retPtr, length);
  73     gArgV[index][length] = '\0';
  74     index++;
  75   }
  76
  77   while(index < argc)
  78   {
  79     //if jarg1 - index >1, maybe cause error.
  80     gArgV[index] = NULL;
  81     index++;
  82   }
  83
  84   gArgV[argc] = NULL;
  85   gArgC        = argc;
  86 }
  87
  88 } // unnamed namespace
  89
  90 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Empty(Dali::Signal<void(Dali::DeviceStatus::Battery::Status)> const* self)
  91 {
  92   return self->Empty();
  93 }
  94 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__GetConnectionCount(Dali::Signal<void(Dali::DeviceStatus::Battery::Status)> const* self)
  95 {
  96   return self->GetConnectionCount();
  97 }
  98 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Connect(Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* self, void (*func)(Dali::DeviceStatus::Battery::Status))
  99 {
 100   self->Connect(func);
 101 }
 102 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Disconnect(Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* self, void (*func)(Dali::DeviceStatus::Battery::Status))
 103 {
 104   self->Disconnect(func);
 105 }
 106 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Emit(Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* self, Dali::DeviceStatus::Battery::Status arg)
 107 {
 108   self->Emit(arg);
 109 }
 110 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Empty(Dali::Signal<void(Dali::DeviceStatus::Memory::Status)> const* self)
 111 {
 112   return self->Empty();
 113 }
 114 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__GetConnectionCount(Dali::Signal<void(Dali::DeviceStatus::Memory::Status)> const* self)
 115 {
 116   return self->GetConnectionCount();
 117 }
 118 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Connect(Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* self, void (*func)(Dali::DeviceStatus::Memory::Status))
 119 {
 120   self->Connect(func);
 121 }
 122 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Disconnect(Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* self, void (*func)(Dali::DeviceStatus::Memory::Status))
 123 {
 124   self->Disconnect(func);
 125 }
 126 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Emit(Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* self, Dali::DeviceStatus::Memory::Status arg)
 127 {
 128   self->Emit(arg);
 129 }
 130
 131 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Empty(Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)> const* self)
 132 {
 133   return self->Empty();
 134 }
 135 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__GetConnectionCount(Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)> const* self)
 136 {
 137   return self->GetConnectionCount();
 138 }
 139 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Connect(Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>* self, void (*func)(Dali::DeviceStatus::Orientation::Status))
 140 {
 141   self->Connect(func);
 142 }
 143 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Disconnect(Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>* self, void (*func)(Dali::DeviceStatus::Orientation::Status))
 144 {
 145   self->Disconnect(func);
 146 }
 147 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Emit(Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>* self, Dali::DeviceStatus::Orientation::Status arg)
 148 {
 149   self->Emit(arg);
 150 }
 151
 152 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal<void(Dali::Application&)> const* self)
 153 {
 154   return self->Empty();
 155 }
 156 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal<void(Dali::Application&)> const* self)
 157 {
 158   return self->GetConnectionCount();
 159 }
 160 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal<void(Dali::Application&)>* self, void (*func)(Dali::Application&))
 161 {
 162   self->Connect(func);
 163 }
 164 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal<void(Dali::Application&)>* self, void (*func)(Dali::Application&))
 165 {
 166   self->Disconnect(func);
 167 }
 168 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal<void(Dali::Application&)>* self, Dali::Application& arg)
 169 {
 170   self->Emit(arg);
 171 }
 172
 173 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal<void(Dali::Application&, void*)> const* self)
 174 {
 175   return self->Empty();
 176 }
 177 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount(Dali::Signal<void(Dali::Application&, void*)> const* self)
 178 {
 179   return self->GetConnectionCount();
 180 }
 181 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(Dali::Signal<void(Dali::Application&, void*)>* self, void (*func)(Dali::Application&, void*))
 182 {
 183   self->Connect(func);
 184 }
 185 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(Dali::Signal<void(Dali::Application&, void*)>* self, void (*func)(Dali::Application&, void*))
 186 {
 187   self->Disconnect(func);
 188 }
 189 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(Dali::Signal<void(Dali::Application&, void*)>* self, Dali::Application& arg1, void* arg2)
 190 {
 191   self->Emit(arg1, arg2);
 192 }
 193
 194 #ifdef __cplusplus
 195 extern "C" {
 196 #endif
 197
 198 /*Application binding*/
 199
 200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_PreInitialize()
 201 {
 202   ApplicationPreInitialize(nullptr, nullptr);
 203 }
 204
 205 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0()
 206 {
 207   void*             jresult;
 208   Dali::Application result;
 209
 210   {
 211     try
 212     {
 213       result = Dali::Application::New();
 214     }
 215     CALL_CATCH_EXCEPTION(0);
 216   }
 217
 218   jresult = new Dali::Application((const Dali::Application&)result);
 219   return jresult;
 220 }
 221
 222 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1)
 223 {
 224   void* jresult;
 225
 226   Dali::Application result;
 227   {
 228     try
 229     {
 230       result = Dali::Application::New(nullptr, nullptr);
 231     }
 232     CALL_CATCH_EXCEPTION(0);
 233   }
 234
 235   jresult = new Dali::Application((const Dali::Application&)result);
 236   return jresult;
 237 }
 238
 239 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char* jarg3)
 240 {
 241   void*        jresult;
 242   std::string* arg3 = 0;
 243
 244   Dali::Application result;
 245   if(!jarg3)
 246   {
 247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 248     return 0;
 249   }
 250   std::string arg3_str(jarg3);
 251   arg3 = &arg3_str;
 252   {
 253     try
 254     {
 255       result = Dali::Application::New(nullptr, nullptr, (std::string const&)*arg3);
 256     }
 257     CALL_CATCH_EXCEPTION(0);
 258   }
 259
 260   jresult = new Dali::Application((const Dali::Application&)result);
 261
 262   //argout typemap for const std::string&
 263
 264   return jresult;
 265 }
 266
 267 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char* jarg3, int jarg4)
 268 {
 269   void*                          jresult;
 270   Dali::Application::WINDOW_MODE arg4;
 271
 272   Dali::Application result;
 273   if(!jarg3)
 274   {
 275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 276     return 0;
 277   }
 278   std::string arg3(jarg3);
 279   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
 280   {
 281     try
 282     {
 283       result = Dali::Application::New(nullptr, nullptr, arg3, arg4);
 284     }
 285     CALL_CATCH_EXCEPTION(0);
 286   }
 287
 288   jresult = new Dali::Application((const Dali::Application&)result);
 289
 290   //argout typemap for const std::string&
 291
 292   return jresult;
 293 }
 294
 295 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__MANUAL_4(int jarg1, char* jarg2, char* jarg3, int jarg4)
 296 {
 297   void*                          jresult;
 298   int*                           argc = nullptr;
 299   char***                        argv = nullptr;
 300   Dali::Application::WINDOW_MODE arg4;
 301   Dali::Application              result;
 302
 303   {
 304     // TODO : What should we do if already generated argv exist?
 305     ReleaseArgVMemory();
 306     // generate argv data from the C# args
 307     int   index  = 0;
 308     int   length = 0;
 309     char* retPtr = NULL;
 310     char* nextPtr;
 311
 312     gArgV = new char*[jarg1 + 1];
 313
 314     for(retPtr = strtok_r(jarg2, " ", &nextPtr);
 315         retPtr != NULL && index < jarg1;
 316         retPtr = strtok_r(NULL, " ", &nextPtr))
 317     {
 318       length       = 0;
 319       length       = strlen(retPtr);
 320       gArgV[index] = new char[length + 1];
 321       strncpy(gArgV[index], retPtr, length);
 322       gArgV[index][length] = '\0';
 323       index++;
 324     }
 325
 326     while(index < jarg1)
 327     {
 328       //if jarg1 - index >1, maybe cause error.
 329       gArgV[index] = NULL;
 330       index++;
 331     }
 332
 333     gArgV[jarg1] = NULL;
 334     gArgC        = jarg1;
 335
 336     argc = &gArgC;
 337     argv = &gArgV;
 338   }
 339
 340   std::string arg3(jarg3);
 341   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
 342   {
 343     try
 344     {
 345       result = Dali::Application::New(argc, argv, arg3, arg4);
 346     }
 347     CALL_CATCH_EXCEPTION(0);
 348   }
 349   jresult = new Dali::Application((const Dali::Application&)result);
 350   return jresult;
 351 }
 352
 353 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0()
 354 {
 355   void*              jresult;
 356   Dali::Application* result = 0;
 357
 358   {
 359     try
 360     {
 361       result = (Dali::Application*)new Dali::Application();
 362     }
 363     CALL_CATCH_EXCEPTION(0);
 364   }
 365
 366   jresult = (void*)result;
 367   return jresult;
 368 }
 369
 370 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void* jarg1)
 371 {
 372   void*              jresult;
 373   Dali::Application* arg1   = 0;
 374   Dali::Application* result = 0;
 375
 376   arg1 = (Dali::Application*)jarg1;
 377   if(!arg1)
 378   {
 379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
 380     return 0;
 381   }
 382   {
 383     try
 384     {
 385       result = (Dali::Application*)new Dali::Application((Dali::Application const&)*arg1);
 386     }
 387     CALL_CATCH_EXCEPTION(0);
 388   }
 389
 390   jresult = (void*)result;
 391   return jresult;
 392 }
 393
 394 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_Assign(void* jarg1, void* jarg2)
 395 {
 396   void*              jresult;
 397   Dali::Application* arg1   = (Dali::Application*)0;
 398   Dali::Application* arg2   = 0;
 399   Dali::Application* result = 0;
 400
 401   arg1 = (Dali::Application*)jarg1;
 402   arg2 = (Dali::Application*)jarg2;
 403   if(!arg2)
 404   {
 405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
 406     return 0;
 407   }
 408   {
 409     try
 410     {
 411       result = (Dali::Application*)&(arg1)->operator=((Dali::Application const&)*arg2);
 412     }
 413     CALL_CATCH_EXCEPTION(0);
 414   }
 415
 416   jresult = (void*)result;
 417   return jresult;
 418 }
 419
 420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void* jarg1)
 421 {
 422   Dali::Application* arg1 = (Dali::Application*)0;
 423
 424   arg1 = (Dali::Application*)jarg1;
 425   {
 426     try
 427     {
 428       delete arg1;
 429       ReleaseArgVMemory();
 430     }
 431     CALL_CATCH_EXCEPTION();
 432   }
 433 }
 434
 435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void* jarg1)
 436 {
 437   Dali::Application* arg1 = (Dali::Application*)0;
 438
 439   arg1 = (Dali::Application*)jarg1;
 440   {
 441     try
 442     {
 443       (arg1)->MainLoop();
 444     }
 445     CALL_CATCH_EXCEPTION();
 446   }
 447 }
 448
 449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void* jarg1)
 450 {
 451   Dali::Application* arg1 = (Dali::Application*)0;
 452
 453   arg1 = (Dali::Application*)jarg1;
 454   {
 455     try
 456     {
 457       (arg1)->Lower();
 458     }
 459     CALL_CATCH_EXCEPTION();
 460   }
 461 }
 462
 463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void* jarg1)
 464 {
 465   Dali::Application* arg1 = (Dali::Application*)0;
 466
 467   arg1 = (Dali::Application*)jarg1;
 468   {
 469     try
 470     {
 471       (arg1)->Quit();
 472     }
 473     CALL_CATCH_EXCEPTION();
 474   }
 475 }
 476
 477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void* jarg1, void* jarg2)
 478 {
 479   unsigned int        jresult;
 480   Dali::Application*  arg1 = (Dali::Application*)0;
 481   Dali::CallbackBase* arg2 = (Dali::CallbackBase*)0;
 482   bool                result;
 483
 484   arg1 = (Dali::Application*)jarg1;
 485   arg2 = (Dali::CallbackBase*)jarg2;
 486   {
 487     try
 488     {
 489       result = (bool)(arg1)->AddIdle(arg2);
 490     }
 491     CALL_CATCH_EXCEPTION(0);
 492   }
 493
 494   jresult = result;
 495   return jresult;
 496 }
 497
 498 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_GetWindow(void* jarg1)
 499 {
 500   void*              jresult;
 501   Dali::Application* arg1 = (Dali::Application*)0;
 502   Dali::Window       result;
 503
 504   arg1 = (Dali::Application*)jarg1;
 505   {
 506     try
 507     {
 508       result = (arg1)->GetWindow();
 509     }
 510     CALL_CATCH_EXCEPTION(0);
 511   }
 512
 513   jresult = new Dali::Window((const Dali::Window&)result);
 514   return jresult;
 515 }
 516
 517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_GetWindowsListSize()
 518 {
 519   unsigned int          jresult;
 520   Dali::WindowContainer result;
 521   {
 522     try
 523     {
 524       // Note : We should not check Dali::Adaptor::IsAvailable() here. Since this API could be called at OnTerminate time.
 525       result  = Dali::Adaptor::Get().GetWindows();
 526       jresult = result.size();
 527     }
 528     CALL_CATCH_EXCEPTION(0);
 529   }
 530   return jresult;
 531 }
 532
 533 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_GetWindowsFromList(unsigned int jarg1)
 534 {
 535   void*                 jresult;
 536   unsigned int          index = jarg1;
 537   Dali::WindowContainer result;
 538
 539   {
 540     try
 541     {
 542       // Note : We should not check Dali::Adaptor::IsAvailable() here. Since this API could be called at OnTerminate time.
 543       result = Dali::Adaptor::Get().GetWindows();
 544     }
 545     CALL_CATCH_EXCEPTION(0);
 546   }
 547   jresult = new Dali::Window((const Dali::Window&)result[index]);
 548   return jresult;
 549 }
 550
 551 SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Application_GetResourcePath()
 552 {
 553   char*       jresult;
 554   std::string result;
 555
 556   {
 557     try
 558     {
 559       result = Dali::Application::GetResourcePath();
 560     }
 561     CALL_CATCH_EXCEPTION(0);
 562   }
 563
 564   jresult = SWIG_csharp_string_callback((&result)->c_str());
 565   return jresult;
 566 }
 567
 568 SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Application_GetRegion(void* jarg1)
 569 {
 570   char*              jresult;
 571   Dali::Application* arg1 = (Dali::Application*)0;
 572   std::string        result;
 573
 574   arg1 = (Dali::Application*)jarg1;
 575   {
 576     try
 577     {
 578       result = (arg1)->GetRegion();
 579     }
 580     CALL_CATCH_EXCEPTION(0);
 581   }
 582   jresult = SWIG_csharp_string_callback((&result)->c_str());
 583   return jresult;
 584 }
 585
 586 SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Application_GetLanguage(void* jarg1)
 587 {
 588   char*              jresult;
 589   Dali::Application* arg1 = (Dali::Application*)0;
 590   std::string        result;
 591
 592   arg1 = (Dali::Application*)jarg1;
 593   {
 594     try
 595     {
 596       result = (arg1)->GetLanguage();
 597     }
 598     CALL_CATCH_EXCEPTION(0);
 599   }
 600   jresult = SWIG_csharp_string_callback((&result)->c_str());
 601   return jresult;
 602 }
 603
 604 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_InitSignal(void* jarg1)
 605 {
 606   void*                             jresult;
 607   Dali::Application*                arg1   = (Dali::Application*)0;
 608   Dali::Application::AppSignalType* result = 0;
 609
 610   arg1 = (Dali::Application*)jarg1;
 611   {
 612     try
 613     {
 614       result = (Dali::Application::AppSignalType*)&(arg1)->InitSignal();
 615     }
 616     CALL_CATCH_EXCEPTION(0);
 617   }
 618
 619   jresult = (void*)result;
 620   return jresult;
 621 }
 622
 623 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void* jarg1)
 624 {
 625   void*                             jresult;
 626   Dali::Application*                arg1   = (Dali::Application*)0;
 627   Dali::Application::AppSignalType* result = 0;
 628
 629   arg1 = (Dali::Application*)jarg1;
 630   {
 631     try
 632     {
 633       result = (Dali::Application::AppSignalType*)&(arg1)->TerminateSignal();
 634     }
 635     CALL_CATCH_EXCEPTION(0);
 636   }
 637
 638   jresult = (void*)result;
 639   return jresult;
 640 }
 641
 642 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void* jarg1)
 643 {
 644   void*                             jresult;
 645   Dali::Application*                arg1   = (Dali::Application*)0;
 646   Dali::Application::AppSignalType* result = 0;
 647
 648   arg1 = (Dali::Application*)jarg1;
 649   {
 650     try
 651     {
 652       result = (Dali::Application::AppSignalType*)&(arg1)->PauseSignal();
 653     }
 654     CALL_CATCH_EXCEPTION(0);
 655   }
 656
 657   jresult = (void*)result;
 658   return jresult;
 659 }
 660
 661 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void* jarg1)
 662 {
 663   void*                             jresult;
 664   Dali::Application*                arg1   = (Dali::Application*)0;
 665   Dali::Application::AppSignalType* result = 0;
 666
 667   arg1 = (Dali::Application*)jarg1;
 668   {
 669     try
 670     {
 671       result = (Dali::Application::AppSignalType*)&(arg1)->ResumeSignal();
 672     }
 673     CALL_CATCH_EXCEPTION(0);
 674   }
 675
 676   jresult = (void*)result;
 677   return jresult;
 678 }
 679
 680 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void* jarg1)
 681 {
 682   void*                             jresult;
 683   Dali::Application*                arg1   = (Dali::Application*)0;
 684   Dali::Application::AppSignalType* result = 0;
 685
 686   arg1 = (Dali::Application*)jarg1;
 687   {
 688     try
 689     {
 690       result = (Dali::Application::AppSignalType*)&(arg1)->ResetSignal();
 691     }
 692     CALL_CATCH_EXCEPTION(0);
 693   }
 694
 695   jresult = (void*)result;
 696   return jresult;
 697 }
 698
 699 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void* jarg1)
 700 {
 701   void*                                    jresult;
 702   Dali::Application*                       arg1   = (Dali::Application*)0;
 703   Dali::Application::AppControlSignalType* result = 0;
 704
 705   arg1 = (Dali::Application*)jarg1;
 706   {
 707     try
 708     {
 709       result = (Dali::Application::AppControlSignalType*)&(arg1)->AppControlSignal();
 710     }
 711     CALL_CATCH_EXCEPTION(0);
 712   }
 713
 714   jresult = (void*)result;
 715   return jresult;
 716 }
 717
 718 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void* jarg1)
 719 {
 720   void*                             jresult;
 721   Dali::Application*                arg1   = (Dali::Application*)0;
 722   Dali::Application::AppSignalType* result = 0;
 723
 724   arg1 = (Dali::Application*)jarg1;
 725   {
 726     try
 727     {
 728       result = (Dali::Application::AppSignalType*)&(arg1)->LanguageChangedSignal();
 729     }
 730     CALL_CATCH_EXCEPTION(0);
 731   }
 732
 733   jresult = (void*)result;
 734   return jresult;
 735 }
 736
 737 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void* jarg1)
 738 {
 739   void*                             jresult;
 740   Dali::Application*                arg1   = (Dali::Application*)0;
 741   Dali::Application::AppSignalType* result = 0;
 742
 743   arg1 = (Dali::Application*)jarg1;
 744   {
 745     try
 746     {
 747       result = (Dali::Application::AppSignalType*)&(arg1)->RegionChangedSignal();
 748     }
 749     CALL_CATCH_EXCEPTION(0);
 750   }
 751
 752   jresult = (void*)result;
 753   return jresult;
 754 }
 755
 756 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_LowBatterySignal(void* jarg1)
 757 {
 758   void*                                    jresult;
 759   Dali::Application*                       arg1   = (Dali::Application*)0;
 760   Dali::Application::LowBatterySignalType* result = 0;
 761
 762   arg1 = (Dali::Application*)jarg1;
 763   {
 764     try
 765     {
 766       result = (Dali::Application::LowBatterySignalType*)&(arg1)->LowBatterySignal();
 767     }
 768     CALL_CATCH_EXCEPTION(0);
 769   }
 770
 771   jresult = (void*)result;
 772   return jresult;
 773 }
 774
 775 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_LowMemorySignal(void* jarg1)
 776 {
 777   void*                                   jresult;
 778   Dali::Application*                      arg1   = (Dali::Application*)0;
 779   Dali::Application::LowMemorySignalType* result = 0;
 780
 781   arg1 = (Dali::Application*)jarg1;
 782   {
 783     try
 784     {
 785       result = (Dali::Application::LowMemorySignalType*)&(arg1)->LowMemorySignal();
 786     }
 787     CALL_CATCH_EXCEPTION(0);
 788   }
 789   jresult = (void*)result;
 790   return jresult;
 791 }
 792
 793 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignal(void* jarg1)
 794 {
 795   void*                                   jresult;
 796   Dali::Application*                      arg1   = (Dali::Application*)0;
 797   Dali::Application::DeviceOrientationChangedSignalType* result = 0;
 798
 799   arg1 = (Dali::Application*)jarg1;
 800   {
 801     try
 802     {
 803       result = (Dali::Application::DeviceOrientationChangedSignalType*)&(arg1)->DeviceOrientationChangedSignal();
 804     }
 805     CALL_CATCH_EXCEPTION(0);
 806   }
 807   jresult = (void*)result;
 808   return jresult;
 809 }
 810
 811 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskInitSignal(void* app)
 812 {
 813   void*                             jresult;
 814   Dali::Application*                application = (Dali::Application*)0;
 815   Dali::Application::AppSignalType* result      = 0;
 816
 817   application = (Dali::Application*)app;
 818   {
 819     try
 820     {
 821       result = (Dali::Application::AppSignalType*)&(application)->TaskInitSignal();
 822     }
 823     CALL_CATCH_EXCEPTION(0);
 824   }
 825
 826   jresult = (void*)result;
 827   return jresult;
 828 }
 829
 830 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskTerminateSignal(void* app)
 831 {
 832   void*                             jresult;
 833   Dali::Application*                application = (Dali::Application*)0;
 834   Dali::Application::AppSignalType* result      = 0;
 835
 836   application = (Dali::Application*)app;
 837   {
 838     try
 839     {
 840       result = (Dali::Application::AppSignalType*)&(application)->TaskTerminateSignal();
 841     }
 842     CALL_CATCH_EXCEPTION(0);
 843   }
 844
 845   jresult = (void*)result;
 846   return jresult;
 847 }
 848
 849 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskAppControlSignal(void* app)
 850 {
 851   void*                                    jresult;
 852   Dali::Application*                       application = (Dali::Application*)0;
 853   Dali::Application::AppControlSignalType* result      = 0;
 854
 855   application = (Dali::Application*)app;
 856   {
 857     try
 858     {
 859       result = (Dali::Application::AppControlSignalType*)&(application)->TaskAppControlSignal();
 860     }
 861     CALL_CATCH_EXCEPTION(0);
 862   }
 863
 864   jresult = (void*)result;
 865   return jresult;
 866 }
 867
 868 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskLanguageChangedSignal(void* app)
 869 {
 870   void*                             jresult;
 871   Dali::Application*                application = (Dali::Application*)0;
 872   Dali::Application::AppSignalType* result      = 0;
 873
 874   application = (Dali::Application*)app;
 875   {
 876     try
 877     {
 878       result = (Dali::Application::AppSignalType*)&(application)->TaskLanguageChangedSignal();
 879     }
 880     CALL_CATCH_EXCEPTION(0);
 881   }
 882
 883   jresult = (void*)result;
 884   return jresult;
 885 }
 886
 887 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskRegionChangedSignal(void* app)
 888 {
 889   void*                             jresult;
 890   Dali::Application*                application = (Dali::Application*)0;
 891   Dali::Application::AppSignalType* result      = 0;
 892
 893   application = (Dali::Application*)app;
 894   {
 895     try
 896     {
 897       result = (Dali::Application::AppSignalType*)&(application)->TaskRegionChangedSignal();
 898     }
 899     CALL_CATCH_EXCEPTION(0);
 900   }
 901
 902   jresult = (void*)result;
 903   return jresult;
 904 }
 905
 906 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskLowBatterySignal(void* app)
 907 {
 908   void*                                    jresult;
 909   Dali::Application*                       application = (Dali::Application*)0;
 910   Dali::Application::LowBatterySignalType* result      = 0;
 911
 912   application = (Dali::Application*)app;
 913   {
 914     try
 915     {
 916       result = (Dali::Application::LowBatterySignalType*)&(application)->TaskLowBatterySignal();
 917     }
 918     CALL_CATCH_EXCEPTION(0);
 919   }
 920
 921   jresult = (void*)result;
 922   return jresult;
 923 }
 924
 925 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskLowMemorySignal(void* app)
 926 {
 927   void*                                   jresult;
 928   Dali::Application*                      application = (Dali::Application*)0;
 929   Dali::Application::LowMemorySignalType* result      = 0;
 930
 931   application = (Dali::Application*)app;
 932   {
 933     try
 934     {
 935       result = (Dali::Application::LowMemorySignalType*)&(application)->TaskLowMemorySignal();
 936     }
 937     CALL_CATCH_EXCEPTION(0);
 938   }
 939   jresult = (void*)result;
 940   return jresult;
 941 }
 942
 943 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskDeviceOrientationChangedSignal(void* app)
 944 {
 945   void*                                   jresult;
 946   Dali::Application*                      application = (Dali::Application*)0;
 947   Dali::Application::DeviceOrientationChangedSignalType* result      = 0;
 948
 949   application = (Dali::Application*)app;
 950   {
 951     try
 952     {
 953       result = (Dali::Application::DeviceOrientationChangedSignalType*)&(application)->TaskDeviceOrientationChangedSignal();
 954     }
 955     CALL_CATCH_EXCEPTION(0);
 956   }
 957   jresult = (void*)result;
 958   return jresult;
 959 }
 960
 961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Empty(void* jarg1)
 962 {
 963   unsigned int                                             jresult;
 964   Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
 965   bool                                                     result;
 966
 967   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
 968   {
 969     try
 970     {
 971       result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Empty((Dali::Signal<void(Dali::DeviceStatus::Battery::Status)> const*)arg1);
 972     }
 973     CALL_CATCH_EXCEPTION(0);
 974   }
 975
 976   jresult = result;
 977   return jresult;
 978 }
 979
 980 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_GetConnectionCount(void* jarg1)
 981 {
 982   unsigned long                                            jresult;
 983   Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
 984   std::size_t                                              result;
 985
 986   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
 987   {
 988     try
 989     {
 990       result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::DeviceStatus::Battery::Status)> const*)arg1);
 991     }
 992     CALL_CATCH_EXCEPTION(0);
 993   }
 994   jresult = (unsigned long)result;
 995   return jresult;
 996 }
 997
 998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Connect(void* jarg1, void* jarg2)
 999 {
1000   Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
1001   void (*arg2)(Dali::DeviceStatus::Battery::Status)             = (void (*)(Dali::DeviceStatus::Battery::Status))0;
1002
1003   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
1004   arg2 = (void (*)(Dali::DeviceStatus::Battery::Status))jarg2;
1005   {
1006     try
1007     {
1008       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Connect(arg1, arg2);
1009     }
1010     CALL_CATCH_EXCEPTION();
1011   }
1012 }
1013
1014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Disconnect(void* jarg1, void* jarg2)
1015 {
1016   Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
1017   void (*arg2)(Dali::DeviceStatus::Battery::Status)             = (void (*)(Dali::DeviceStatus::Battery::Status))0;
1018
1019   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
1020   arg2 = (void (*)(Dali::DeviceStatus::Battery::Status))jarg2;
1021   {
1022     try
1023     {
1024       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Disconnect(arg1, arg2);
1025     }
1026     CALL_CATCH_EXCEPTION();
1027   }
1028 }
1029
1030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Emit(void* jarg1, void* jarg2)
1031 {
1032   Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
1033   Dali::DeviceStatus::Battery::Status                      arg2;
1034   Dali::DeviceStatus::Battery::Status*                     argp2;
1035
1036   arg1  = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
1037   argp2 = (Dali::DeviceStatus::Battery::Status*)jarg2;
1038   if(!argp2)
1039   {
1040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Battery::Status", 0);
1041     return;
1042   }
1043   arg2 = *argp2;
1044   {
1045     try
1046     {
1047       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Emit(arg1, arg2);
1048     }
1049     CALL_CATCH_EXCEPTION();
1050   }
1051 }
1052
1053 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_new_LowBatterySignalType()
1054 {
1055   void*                                                    jresult;
1056   Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* result = 0;
1057
1058   {
1059     try
1060     {
1061       result = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)new Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>();
1062     }
1063     CALL_CATCH_EXCEPTION(0);
1064   }
1065
1066   jresult = (void*)result;
1067   return jresult;
1068 }
1069
1070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_LowBatterySignalType(void* jarg1)
1071 {
1072   Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
1073
1074   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
1075   {
1076     try
1077     {
1078       delete arg1;
1079     }
1080     CALL_CATCH_EXCEPTION();
1081   }
1082 }
1083
1084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Empty(void* jarg1)
1085 {
1086   unsigned int                                            jresult;
1087   Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
1088   bool                                                    result;
1089
1090   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
1091   {
1092     try
1093     {
1094       result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Empty((Dali::Signal<void(Dali::DeviceStatus::Memory::Status)> const*)arg1);
1095     }
1096     CALL_CATCH_EXCEPTION(0);
1097   }
1098   jresult = result;
1099   return jresult;
1100 }
1101
1102 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_GetConnectionCount(void* jarg1)
1103 {
1104   unsigned long                                           jresult;
1105   Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
1106   std::size_t                                             result;
1107
1108   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
1109   {
1110     try
1111     {
1112       result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::DeviceStatus::Memory::Status)> const*)arg1);
1113     }
1114     CALL_CATCH_EXCEPTION(0);
1115   }
1116   jresult = (unsigned long)result;
1117   return jresult;
1118 }
1119
1120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Connect(void* jarg1, void* jarg2)
1121 {
1122   Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
1123   void (*arg2)(Dali::DeviceStatus::Memory::Status)             = (void (*)(Dali::DeviceStatus::Memory::Status))0;
1124
1125   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
1126   arg2 = (void (*)(Dali::DeviceStatus::Memory::Status))jarg2;
1127   {
1128     try
1129     {
1130       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Connect(arg1, arg2);
1131     }
1132     CALL_CATCH_EXCEPTION();
1133   }
1134 }
1135
1136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Disconnect(void* jarg1, void* jarg2)
1137 {
1138   Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
1139   void (*arg2)(Dali::DeviceStatus::Memory::Status)             = (void (*)(Dali::DeviceStatus::Memory::Status))0;
1140
1141   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
1142   arg2 = (void (*)(Dali::DeviceStatus::Memory::Status))jarg2;
1143   {
1144     try
1145     {
1146       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Disconnect(arg1, arg2);
1147     }
1148     CALL_CATCH_EXCEPTION();
1149   }
1150 }
1151
1152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Emit(void* jarg1, void* jarg2)
1153 {
1154   Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
1155   Dali::DeviceStatus::Memory::Status                      arg2;
1156   Dali::DeviceStatus::Memory::Status*                     argp2;
1157
1158   arg1  = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
1159   argp2 = (Dali::DeviceStatus::Memory::Status*)jarg2;
1160   if(!argp2)
1161   {
1162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Memory::Status", 0);
1163     return;
1164   }
1165   arg2 = *argp2;
1166   {
1167     try
1168     {
1169       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Emit(arg1, arg2);
1170     }
1171     CALL_CATCH_EXCEPTION();
1172   }
1173 }
1174
1175 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_new_LowMemorySignalType()
1176 {
1177   void*                                                   jresult;
1178   Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* result = 0;
1179
1180   {
1181     try
1182     {
1183       result = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)new Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>();
1184     }
1185     CALL_CATCH_EXCEPTION(0);
1186   }
1187   jresult = (void*)result;
1188   return jresult;
1189 }
1190
1191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_LowMemorySignalType(void* jarg1)
1192 {
1193   Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
1194
1195   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
1196   {
1197     try
1198     {
1199       delete arg1;
1200     }
1201     CALL_CATCH_EXCEPTION();
1202   }
1203 }
1204
1205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_Empty(void* jarg1)
1206 {
1207   unsigned int                                            jresult;
1208   Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)0;
1209   bool                                                    result;
1210
1211   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)jarg1;
1212   {
1213     try
1214     {
1215       result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Empty((Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)> const*)arg1);
1216     }
1217     CALL_CATCH_EXCEPTION(0);
1218   }
1219   jresult = result;
1220   return jresult;
1221 }
1222
1223 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_GetConnectionCount(void* jarg1)
1224 {
1225   unsigned long                                           jresult;
1226   Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)0;
1227   std::size_t                                             result;
1228
1229   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)jarg1;
1230   {
1231     try
1232     {
1233       result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)> const*)arg1);
1234     }
1235     CALL_CATCH_EXCEPTION(0);
1236   }
1237   jresult = (unsigned long)result;
1238   return jresult;
1239 }
1240
1241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_Connect(void* jarg1, void* jarg2)
1242 {
1243   Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)0;
1244   void (*arg2)(Dali::DeviceStatus::Orientation::Status)             = (void (*)(Dali::DeviceStatus::Orientation::Status))0;
1245
1246   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)jarg1;
1247   arg2 = (void (*)(Dali::DeviceStatus::Orientation::Status))jarg2;
1248   {
1249     try
1250     {
1251       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Connect(arg1, arg2);
1252     }
1253     CALL_CATCH_EXCEPTION();
1254   }
1255 }
1256
1257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_Disconnect(void* jarg1, void* jarg2)
1258 {
1259   Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)0;
1260   void (*arg2)(Dali::DeviceStatus::Orientation::Status)             = (void (*)(Dali::DeviceStatus::Orientation::Status))0;
1261
1262   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)jarg1;
1263   arg2 = (void (*)(Dali::DeviceStatus::Orientation::Status))jarg2;
1264   {
1265     try
1266     {
1267       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Disconnect(arg1, arg2);
1268     }
1269     CALL_CATCH_EXCEPTION();
1270   }
1271 }
1272
1273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_Emit(void* jarg1, void* jarg2)
1274 {
1275   Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)0;
1276   Dali::DeviceStatus::Orientation::Status                      arg2;
1277   Dali::DeviceStatus::Orientation::Status*                     argp2;
1278
1279   arg1  = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)jarg1;
1280   argp2 = (Dali::DeviceStatus::Orientation::Status*)jarg2;
1281   if(!argp2)
1282   {
1283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Orientation::Status", 0);
1284     return;
1285   }
1286   arg2 = *argp2;
1287   {
1288     try
1289     {
1290       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Emit(arg1, arg2);
1291     }
1292     CALL_CATCH_EXCEPTION();
1293   }
1294 }
1295
1296 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_new_DeviceOrientationChangedSignalType()
1297 {
1298   void*                                                   jresult;
1299   Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>* result = 0;
1300
1301   {
1302     try
1303     {
1304       result = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)new Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>();
1305     }
1306     CALL_CATCH_EXCEPTION(0);
1307   }
1308   jresult = (void*)result;
1309   return jresult;
1310 }
1311
1312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_DeviceOrientationChangedSignalType(void* jarg1)
1313 {
1314   Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)0;
1315
1316   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)jarg1;
1317   {
1318     try
1319     {
1320       delete arg1;
1321     }
1322     CALL_CATCH_EXCEPTION();
1323   }
1324 }
1325
1326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void* jarg1)
1327 {
1328   unsigned int                            jresult;
1329   Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
1330   bool                                    result;
1331
1332   arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
1333   {
1334     try
1335     {
1336       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal<void(Dali::Application&)> const*)arg1);
1337     }
1338     CALL_CATCH_EXCEPTION(0);
1339   }
1340
1341   jresult = result;
1342   return jresult;
1343 }
1344
1345 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void* jarg1)
1346 {
1347   unsigned long                           jresult;
1348   Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
1349   std::size_t                             result;
1350
1351   arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
1352   {
1353     try
1354     {
1355       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::Application&)> const*)arg1);
1356     }
1357     CALL_CATCH_EXCEPTION(0);
1358   }
1359
1360   jresult = (unsigned long)result;
1361   return jresult;
1362 }
1363
1364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void* jarg1, void* jarg2)
1365 {
1366   Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
1367   void (*arg2)(Dali::Application&)             = (void (*)(Dali::Application&))0;
1368
1369   arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
1370   arg2 = (void (*)(Dali::Application&))jarg2;
1371   {
1372     try
1373     {
1374       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1, arg2);
1375     }
1376     CALL_CATCH_EXCEPTION();
1377   }
1378 }
1379
1380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void* jarg1, void* jarg2)
1381 {
1382   Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
1383   void (*arg2)(Dali::Application&)             = (void (*)(Dali::Application&))0;
1384
1385   arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
1386   arg2 = (void (*)(Dali::Application&))jarg2;
1387   {
1388     try
1389     {
1390       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1, arg2);
1391     }
1392     CALL_CATCH_EXCEPTION();
1393   }
1394 }
1395
1396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void* jarg1, void* jarg2)
1397 {
1398   Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
1399   Dali::Application*                      arg2 = 0;
1400
1401   arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
1402   arg2 = (Dali::Application*)jarg2;
1403   if(!arg2)
1404   {
1405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
1406     return;
1407   }
1408   {
1409     try
1410     {
1411       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1, *arg2);
1412     }
1413     CALL_CATCH_EXCEPTION();
1414   }
1415 }
1416
1417 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ApplicationSignal()
1418 {
1419   void*                                   jresult;
1420   Dali::Signal<void(Dali::Application&)>* result = 0;
1421
1422   {
1423     try
1424     {
1425       result = (Dali::Signal<void(Dali::Application&)>*)new Dali::Signal<void(Dali::Application&)>();
1426     }
1427     CALL_CATCH_EXCEPTION(0);
1428   }
1429
1430   jresult = (void*)result;
1431   return jresult;
1432 }
1433
1434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void* jarg1)
1435 {
1436   Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
1437
1438   arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
1439   {
1440     try
1441     {
1442       delete arg1;
1443     }
1444     CALL_CATCH_EXCEPTION();
1445   }
1446 }
1447
1448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void* jarg1)
1449 {
1450   unsigned int                                   jresult;
1451   Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
1452   bool                                           result;
1453
1454   arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
1455   {
1456     try
1457     {
1458       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal<void(Dali::Application&, void*)> const*)arg1);
1459     }
1460     CALL_CATCH_EXCEPTION(0);
1461   }
1462
1463   jresult = result;
1464   return jresult;
1465 }
1466
1467 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void* jarg1)
1468 {
1469   unsigned long                                  jresult;
1470   Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
1471   std::size_t                                    result;
1472
1473   arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
1474   {
1475     try
1476     {
1477       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::Application&, void*)> const*)arg1);
1478     }
1479     CALL_CATCH_EXCEPTION(0);
1480   }
1481
1482   jresult = (unsigned long)result;
1483   return jresult;
1484 }
1485
1486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void* jarg1, void* jarg2)
1487 {
1488   Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
1489   void (*arg2)(Dali::Application&, void*)             = (void (*)(Dali::Application&, void*))0;
1490
1491   arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
1492   arg2 = (void (*)(Dali::Application&, void*))jarg2;
1493   {
1494     try
1495     {
1496       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1, arg2);
1497     }
1498     CALL_CATCH_EXCEPTION();
1499   }
1500 }
1501
1502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void* jarg1, void* jarg2)
1503 {
1504   Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
1505   void (*arg2)(Dali::Application&, void*)             = (void (*)(Dali::Application&, void*))0;
1506
1507   arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
1508   arg2 = (void (*)(Dali::Application&, void*))jarg2;
1509   {
1510     try
1511     {
1512       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1, arg2);
1513     }
1514     CALL_CATCH_EXCEPTION();
1515   }
1516 }
1517
1518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void* jarg1, void* jarg2, void* jarg3)
1519 {
1520   Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
1521   Dali::Application*                             arg2 = 0;
1522   void*                                          arg3 = (void*)0;
1523
1524   arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
1525   arg2 = (Dali::Application*)jarg2;
1526   if(!arg2)
1527   {
1528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
1529     return;
1530   }
1531   arg3 = jarg3;
1532   {
1533     try
1534     {
1535       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1, *arg2, arg3);
1536     }
1537     CALL_CATCH_EXCEPTION();
1538   }
1539 }
1540
1541 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal()
1542 {
1543   void*                                          jresult;
1544   Dali::Signal<void(Dali::Application&, void*)>* result = 0;
1545
1546   {
1547     try
1548     {
1549       result = (Dali::Signal<void(Dali::Application&, void*)>*)new Dali::Signal<void(Dali::Application&, void*)>();
1550     }
1551     CALL_CATCH_EXCEPTION(0);
1552   }
1553
1554   jresult = (void*)result;
1555   return jresult;
1556 }
1557
1558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void* jarg1)
1559 {
1560   Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
1561
1562   arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
1563   {
1564     try
1565     {
1566       delete arg1;
1567     }
1568     CALL_CATCH_EXCEPTION();
1569   }
1570 }
1571
1572 /*application-devel binding*/
1573
1574 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_4(int jarg1, char* jarg3, int jarg4, void* jarg5)
1575 {
1576   void*                          jresult;
1577   int*                           argc = nullptr;
1578   char***                        argv = nullptr;
1579   Dali::Application::WINDOW_MODE arg4;
1580   Dali::PositionSize             arg5;
1581   Dali::PositionSize*            argp5;
1582   Dali::Application              result;
1583
1584   if(!jarg3)
1585   {
1586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1587     return 0;
1588   }
1589   std::string arg3(jarg3);
1590   arg4  = (Dali::Application::WINDOW_MODE)jarg4;
1591   argp5 = (Dali::PositionSize*)jarg5;
1592   if(!argp5)
1593   {
1594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
1595     return 0;
1596   }
1597   arg5 = *argp5;
1598   {
1599     try
1600     {
1601       result = Dali::Application::New(argc, argv, arg3, arg4, arg5);
1602     }
1603     CALL_CATCH_EXCEPTION(0);
1604   }
1605
1606   jresult = new Dali::Application((const Dali::Application&)result);
1607
1608   return jresult;
1609 }
1610
1611 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_5(int nuiArgc, char* nuiArgv, char* nuiStyleSheet, int nuiWindowMode, void* initRectangle, int nuiWindowType)
1612 {
1613   void*                          jresult;
1614   int*                           argc = nullptr;
1615   char***                        argv = nullptr;
1616   Dali::Application::WINDOW_MODE windowMode;
1617   Dali::PositionSize             rect;
1618   Dali::PositionSize*            rectp;
1619   Dali::WindowType               windowType;
1620   Dali::Application              result;
1621
1622   GenerationArgV(nuiArgc, nuiArgv);
1623   argc = &gArgC;
1624   argv = &gArgV;
1625
1626   if(!nuiStyleSheet)
1627   {
1628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1629     return 0;
1630   }
1631   std::string styleSheet(nuiStyleSheet);
1632   windowMode  = (Dali::Application::WINDOW_MODE)nuiWindowMode;
1633   rectp = (Dali::PositionSize*)initRectangle;
1634   windowType  = (Dali::WindowType)nuiWindowType;
1635
1636   if(!rectp)
1637   {
1638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
1639     return 0;
1640   }
1641   rect = *rectp;
1642   {
1643     try
1644     {
1645       result = Dali::DevelApplication::New(argc, argv, styleSheet, windowMode, rect, windowType);
1646     }
1647     CALL_CATCH_EXCEPTION(0);
1648   }
1649
1650   jresult = new Dali::Application((const Dali::Application&)result);
1651
1652   return jresult;
1653 }
1654
1655 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_6(int nuiArgc, char* nuiArgv, char* nuiStyleSheet, int nuiWindowMode, void* nuiPositionSize, bool nuiUseUiThread)
1656 {
1657   void*                          jresult;
1658   int*                           argc = nullptr;
1659   char***                        argv = nullptr;
1660   Dali::Application::WINDOW_MODE windowMode;
1661   Dali::PositionSize             positionSize;
1662   Dali::PositionSize*            positionSizeP;
1663   bool                           useUiThread;
1664   Dali::Application              result;
1665
1666   if(!nuiStyleSheet)
1667   {
1668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1669     return 0;
1670   }
1671   std::string styleSheet(nuiStyleSheet);
1672   windowMode    = (Dali::Application::WINDOW_MODE)nuiWindowMode;
1673   positionSizeP = (Dali::PositionSize*)nuiPositionSize;
1674   useUiThread   = nuiUseUiThread;
1675
1676   if(!positionSizeP)
1677   {
1678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
1679     return 0;
1680   }
1681
1682   GenerationArgV(nuiArgc, nuiArgv);
1683   argc = &gArgC;
1684   argv = &gArgV;
1685
1686   positionSize = *positionSizeP;
1687   {
1688     try
1689     {
1690       result = Dali::Application::New(argc, argv, styleSheet, windowMode, positionSize, useUiThread);
1691     }
1692     CALL_CATCH_EXCEPTION(0);
1693   }
1694
1695   jresult = new Dali::Application((const Dali::Application&)result);
1696
1697   return jresult;
1698 }
1699
1700 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New_WithWindowSizePosition(int jarg1, char* jarg2, char* jarg3, int jarg4, void* jarg5)
1701 {
1702   void*                          jresult;
1703   int*                           argc = nullptr;
1704   char***                        argv = nullptr;
1705   Dali::Application::WINDOW_MODE arg4;
1706   Dali::PositionSize             arg5;
1707   Dali::PositionSize*            argp5;
1708   Dali::Application              result;
1709
1710   {
1711     // TODO : What should we do if already generated argv exist?
1712     ReleaseArgVMemory();
1713     // generate argv data from the C# args
1714     int   index  = 0;
1715     int   length = 0;
1716     char* retPtr = NULL;
1717     char* nextPtr;
1718
1719     gArgV = new char*[jarg1 + 1];
1720
1721     for(retPtr = strtok_r(jarg2, " ", &nextPtr);
1722         retPtr != NULL && index < jarg1;
1723         retPtr = strtok_r(NULL, " ", &nextPtr))
1724     {
1725       length       = 0;
1726       length       = strlen(retPtr);
1727       gArgV[index] = new char[length + 1];
1728       strncpy(gArgV[index], retPtr, length);
1729       gArgV[index][length] = '\0';
1730       index++;
1731     }
1732
1733     while(index < jarg1)
1734     {
1735       //if jarg1 - index >1, maybe cause error.
1736       gArgV[index] = NULL;
1737       index++;
1738     }
1739
1740     gArgV[jarg1] = NULL;
1741     gArgC        = jarg1;
1742
1743     argc = &gArgC;
1744     argv = &gArgV;
1745   }
1746
1747   std::string arg3(jarg3);
1748   arg4  = (Dali::Application::WINDOW_MODE)jarg4;
1749   argp5 = (Dali::PositionSize*)jarg5;
1750   if(!argp5)
1751   {
1752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
1753     return 0;
1754   }
1755   arg5 = *argp5;
1756   {
1757     try
1758     {
1759       result = Dali::Application::New(argc, argv, arg3, arg4, arg5);
1760     }
1761     CALL_CATCH_EXCEPTION(0);
1762   }
1763   jresult = new Dali::Application((const Dali::Application&)result);
1764   return jresult;
1765 }
1766
1767 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New_WithWindowData(int nuiArgc, char* nuiArgv, char* nuiStyleSheet, bool nuiUIThread, void* nuiWindowData)
1768 {
1769   void*             jresult;
1770   int*              argc = nullptr;
1771   char***           argv = nullptr;
1772   Dali::WindowData* pWindowData;
1773   Dali::Application result;
1774
1775   {
1776     // TODO : What should we do if already generated argv exist?
1777     ReleaseArgVMemory();
1778     // generate argv data from the C# args
1779     int   index  = 0;
1780     int   length = 0;
1781     char* retPtr = NULL;
1782     char* nextPtr;
1783
1784     gArgV = new char*[nuiArgc + 1];
1785
1786     for(retPtr = strtok_r(nuiArgv, " ", &nextPtr);
1787         retPtr != NULL && index < nuiArgc;
1788         retPtr = strtok_r(NULL, " ", &nextPtr))
1789     {
1790       length       = 0;
1791       length       = strlen(retPtr);
1792       gArgV[index] = new char[length + 1];
1793       strncpy(gArgV[index], retPtr, length);
1794       gArgV[index][length] = '\0';
1795       index++;
1796     }
1797
1798     while(index < nuiArgc)
1799     {
1800       // if nuiArgc - index >1, maybe cause error.
1801       gArgV[index] = NULL;
1802       index++;
1803     }
1804
1805     gArgV[nuiArgc] = NULL;
1806     gArgC          = nuiArgc;
1807
1808     argc = &gArgC;
1809     argv = &gArgV;
1810   }
1811
1812   std::string styleSheet(nuiStyleSheet);
1813   pWindowData = (Dali::WindowData*)nuiWindowData;
1814   if(!pWindowData)
1815   {
1816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
1817     return 0;
1818   }
1819
1820   {
1821     try
1822     {
1823       result = Dali::Application::New(argc, argv, styleSheet, nuiUIThread, *pWindowData);
1824     }
1825     CALL_CATCH_EXCEPTION(0);
1826   }
1827   jresult = new Dali::Application((const Dali::Application&)result);
1828   return jresult;
1829 }
1830
1831
1832 SWIGEXPORT int32_t SWIGSTDCALL CSharp_Dali_Application_GetRenderThreadId(void* jarg1)
1833 {
1834   Dali::Application* arg1 = (Dali::Application*)jarg1;
1835
1836   int32_t result;
1837   try
1838   {
1839     result = Dali::DevelApplication::GetRenderThreadId(*arg1);
1840   }
1841   CALL_CATCH_EXCEPTION(0);
1842   return result;
1843 }
1844
1845
1846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_FlushUpdateMessages(void* jarg1)
1847 {
1848   Dali::Application* arg1 = (Dali::Application*)jarg1;
1849
1850   try
1851   {
1852     Dali::DevelApplication::FlushUpdateMessages(*arg1);
1853   }
1854   CALL_CATCH_EXCEPTION();
1855 }
1856
1857 #ifdef __cplusplus
1858 }
1859 #endif