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

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