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
 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       result  = Dali::Adaptor::Get().GetWindows();
 525       jresult = result.size();
 526     }
 527     CALL_CATCH_EXCEPTION(0);
 528   }
 529   return jresult;
 530 }
 531
 532 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_GetWindowsFromList(unsigned int jarg1)
 533 {
 534   void*                 jresult;
 535   unsigned int          index = jarg1;
 536   Dali::WindowContainer result;
 537
 538   {
 539     try
 540     {
 541       result = Dali::Adaptor::Get().GetWindows();
 542     }
 543     CALL_CATCH_EXCEPTION(0);
 544   }
 545   jresult = new Dali::Window((const Dali::Window&)result[index]);
 546   return jresult;
 547 }
 548
 549 SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Application_GetResourcePath()
 550 {
 551   char*       jresult;
 552   std::string result;
 553
 554   {
 555     try
 556     {
 557       result = Dali::Application::GetResourcePath();
 558     }
 559     CALL_CATCH_EXCEPTION(0);
 560   }
 561
 562   jresult = SWIG_csharp_string_callback((&result)->c_str());
 563   return jresult;
 564 }
 565
 566 SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Application_GetRegion(void* jarg1)
 567 {
 568   char*              jresult;
 569   Dali::Application* arg1 = (Dali::Application*)0;
 570   std::string        result;
 571
 572   arg1 = (Dali::Application*)jarg1;
 573   {
 574     try
 575     {
 576       result = (arg1)->GetRegion();
 577     }
 578     CALL_CATCH_EXCEPTION(0);
 579   }
 580   jresult = SWIG_csharp_string_callback((&result)->c_str());
 581   return jresult;
 582 }
 583
 584 SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Application_GetLanguage(void* jarg1)
 585 {
 586   char*              jresult;
 587   Dali::Application* arg1 = (Dali::Application*)0;
 588   std::string        result;
 589
 590   arg1 = (Dali::Application*)jarg1;
 591   {
 592     try
 593     {
 594       result = (arg1)->GetLanguage();
 595     }
 596     CALL_CATCH_EXCEPTION(0);
 597   }
 598   jresult = SWIG_csharp_string_callback((&result)->c_str());
 599   return jresult;
 600 }
 601
 602 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_InitSignal(void* jarg1)
 603 {
 604   void*                             jresult;
 605   Dali::Application*                arg1   = (Dali::Application*)0;
 606   Dali::Application::AppSignalType* result = 0;
 607
 608   arg1 = (Dali::Application*)jarg1;
 609   {
 610     try
 611     {
 612       result = (Dali::Application::AppSignalType*)&(arg1)->InitSignal();
 613     }
 614     CALL_CATCH_EXCEPTION(0);
 615   }
 616
 617   jresult = (void*)result;
 618   return jresult;
 619 }
 620
 621 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void* jarg1)
 622 {
 623   void*                             jresult;
 624   Dali::Application*                arg1   = (Dali::Application*)0;
 625   Dali::Application::AppSignalType* result = 0;
 626
 627   arg1 = (Dali::Application*)jarg1;
 628   {
 629     try
 630     {
 631       result = (Dali::Application::AppSignalType*)&(arg1)->TerminateSignal();
 632     }
 633     CALL_CATCH_EXCEPTION(0);
 634   }
 635
 636   jresult = (void*)result;
 637   return jresult;
 638 }
 639
 640 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void* jarg1)
 641 {
 642   void*                             jresult;
 643   Dali::Application*                arg1   = (Dali::Application*)0;
 644   Dali::Application::AppSignalType* result = 0;
 645
 646   arg1 = (Dali::Application*)jarg1;
 647   {
 648     try
 649     {
 650       result = (Dali::Application::AppSignalType*)&(arg1)->PauseSignal();
 651     }
 652     CALL_CATCH_EXCEPTION(0);
 653   }
 654
 655   jresult = (void*)result;
 656   return jresult;
 657 }
 658
 659 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void* jarg1)
 660 {
 661   void*                             jresult;
 662   Dali::Application*                arg1   = (Dali::Application*)0;
 663   Dali::Application::AppSignalType* result = 0;
 664
 665   arg1 = (Dali::Application*)jarg1;
 666   {
 667     try
 668     {
 669       result = (Dali::Application::AppSignalType*)&(arg1)->ResumeSignal();
 670     }
 671     CALL_CATCH_EXCEPTION(0);
 672   }
 673
 674   jresult = (void*)result;
 675   return jresult;
 676 }
 677
 678 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void* jarg1)
 679 {
 680   void*                             jresult;
 681   Dali::Application*                arg1   = (Dali::Application*)0;
 682   Dali::Application::AppSignalType* result = 0;
 683
 684   arg1 = (Dali::Application*)jarg1;
 685   {
 686     try
 687     {
 688       result = (Dali::Application::AppSignalType*)&(arg1)->ResetSignal();
 689     }
 690     CALL_CATCH_EXCEPTION(0);
 691   }
 692
 693   jresult = (void*)result;
 694   return jresult;
 695 }
 696
 697 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void* jarg1)
 698 {
 699   void*                                    jresult;
 700   Dali::Application*                       arg1   = (Dali::Application*)0;
 701   Dali::Application::AppControlSignalType* result = 0;
 702
 703   arg1 = (Dali::Application*)jarg1;
 704   {
 705     try
 706     {
 707       result = (Dali::Application::AppControlSignalType*)&(arg1)->AppControlSignal();
 708     }
 709     CALL_CATCH_EXCEPTION(0);
 710   }
 711
 712   jresult = (void*)result;
 713   return jresult;
 714 }
 715
 716 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void* jarg1)
 717 {
 718   void*                             jresult;
 719   Dali::Application*                arg1   = (Dali::Application*)0;
 720   Dali::Application::AppSignalType* result = 0;
 721
 722   arg1 = (Dali::Application*)jarg1;
 723   {
 724     try
 725     {
 726       result = (Dali::Application::AppSignalType*)&(arg1)->LanguageChangedSignal();
 727     }
 728     CALL_CATCH_EXCEPTION(0);
 729   }
 730
 731   jresult = (void*)result;
 732   return jresult;
 733 }
 734
 735 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void* jarg1)
 736 {
 737   void*                             jresult;
 738   Dali::Application*                arg1   = (Dali::Application*)0;
 739   Dali::Application::AppSignalType* result = 0;
 740
 741   arg1 = (Dali::Application*)jarg1;
 742   {
 743     try
 744     {
 745       result = (Dali::Application::AppSignalType*)&(arg1)->RegionChangedSignal();
 746     }
 747     CALL_CATCH_EXCEPTION(0);
 748   }
 749
 750   jresult = (void*)result;
 751   return jresult;
 752 }
 753
 754 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_LowBatterySignal(void* jarg1)
 755 {
 756   void*                                    jresult;
 757   Dali::Application*                       arg1   = (Dali::Application*)0;
 758   Dali::Application::LowBatterySignalType* result = 0;
 759
 760   arg1 = (Dali::Application*)jarg1;
 761   {
 762     try
 763     {
 764       result = (Dali::Application::LowBatterySignalType*)&(arg1)->LowBatterySignal();
 765     }
 766     CALL_CATCH_EXCEPTION(0);
 767   }
 768
 769   jresult = (void*)result;
 770   return jresult;
 771 }
 772
 773 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_LowMemorySignal(void* jarg1)
 774 {
 775   void*                                   jresult;
 776   Dali::Application*                      arg1   = (Dali::Application*)0;
 777   Dali::Application::LowMemorySignalType* result = 0;
 778
 779   arg1 = (Dali::Application*)jarg1;
 780   {
 781     try
 782     {
 783       result = (Dali::Application::LowMemorySignalType*)&(arg1)->LowMemorySignal();
 784     }
 785     CALL_CATCH_EXCEPTION(0);
 786   }
 787   jresult = (void*)result;
 788   return jresult;
 789 }
 790
 791 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignal(void* jarg1)
 792 {
 793   void*                                   jresult;
 794   Dali::Application*                      arg1   = (Dali::Application*)0;
 795   Dali::Application::DeviceOrientationChangedSignalType* result = 0;
 796
 797   arg1 = (Dali::Application*)jarg1;
 798   {
 799     try
 800     {
 801       result = (Dali::Application::DeviceOrientationChangedSignalType*)&(arg1)->DeviceOrientationChangedSignal();
 802     }
 803     CALL_CATCH_EXCEPTION(0);
 804   }
 805   jresult = (void*)result;
 806   return jresult;
 807 }
 808
 809 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskInitSignal(void* app)
 810 {
 811   void*                             jresult;
 812   Dali::Application*                application = (Dali::Application*)0;
 813   Dali::Application::AppSignalType* result      = 0;
 814
 815   application = (Dali::Application*)app;
 816   {
 817     try
 818     {
 819       result = (Dali::Application::AppSignalType*)&(application)->TaskInitSignal();
 820     }
 821     CALL_CATCH_EXCEPTION(0);
 822   }
 823
 824   jresult = (void*)result;
 825   return jresult;
 826 }
 827
 828 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskTerminateSignal(void* app)
 829 {
 830   void*                             jresult;
 831   Dali::Application*                application = (Dali::Application*)0;
 832   Dali::Application::AppSignalType* result      = 0;
 833
 834   application = (Dali::Application*)app;
 835   {
 836     try
 837     {
 838       result = (Dali::Application::AppSignalType*)&(application)->TaskTerminateSignal();
 839     }
 840     CALL_CATCH_EXCEPTION(0);
 841   }
 842
 843   jresult = (void*)result;
 844   return jresult;
 845 }
 846
 847 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskAppControlSignal(void* app)
 848 {
 849   void*                                    jresult;
 850   Dali::Application*                       application = (Dali::Application*)0;
 851   Dali::Application::AppControlSignalType* result      = 0;
 852
 853   application = (Dali::Application*)app;
 854   {
 855     try
 856     {
 857       result = (Dali::Application::AppControlSignalType*)&(application)->TaskAppControlSignal();
 858     }
 859     CALL_CATCH_EXCEPTION(0);
 860   }
 861
 862   jresult = (void*)result;
 863   return jresult;
 864 }
 865
 866 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskLanguageChangedSignal(void* app)
 867 {
 868   void*                             jresult;
 869   Dali::Application*                application = (Dali::Application*)0;
 870   Dali::Application::AppSignalType* result      = 0;
 871
 872   application = (Dali::Application*)app;
 873   {
 874     try
 875     {
 876       result = (Dali::Application::AppSignalType*)&(application)->TaskLanguageChangedSignal();
 877     }
 878     CALL_CATCH_EXCEPTION(0);
 879   }
 880
 881   jresult = (void*)result;
 882   return jresult;
 883 }
 884
 885 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskRegionChangedSignal(void* app)
 886 {
 887   void*                             jresult;
 888   Dali::Application*                application = (Dali::Application*)0;
 889   Dali::Application::AppSignalType* result      = 0;
 890
 891   application = (Dali::Application*)app;
 892   {
 893     try
 894     {
 895       result = (Dali::Application::AppSignalType*)&(application)->TaskRegionChangedSignal();
 896     }
 897     CALL_CATCH_EXCEPTION(0);
 898   }
 899
 900   jresult = (void*)result;
 901   return jresult;
 902 }
 903
 904 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskLowBatterySignal(void* app)
 905 {
 906   void*                                    jresult;
 907   Dali::Application*                       application = (Dali::Application*)0;
 908   Dali::Application::LowBatterySignalType* result      = 0;
 909
 910   application = (Dali::Application*)app;
 911   {
 912     try
 913     {
 914       result = (Dali::Application::LowBatterySignalType*)&(application)->TaskLowBatterySignal();
 915     }
 916     CALL_CATCH_EXCEPTION(0);
 917   }
 918
 919   jresult = (void*)result;
 920   return jresult;
 921 }
 922
 923 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskLowMemorySignal(void* app)
 924 {
 925   void*                                   jresult;
 926   Dali::Application*                      application = (Dali::Application*)0;
 927   Dali::Application::LowMemorySignalType* result      = 0;
 928
 929   application = (Dali::Application*)app;
 930   {
 931     try
 932     {
 933       result = (Dali::Application::LowMemorySignalType*)&(application)->TaskLowMemorySignal();
 934     }
 935     CALL_CATCH_EXCEPTION(0);
 936   }
 937   jresult = (void*)result;
 938   return jresult;
 939 }
 940
 941 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskDeviceOrientationChangedSignal(void* app)
 942 {
 943   void*                                   jresult;
 944   Dali::Application*                      application = (Dali::Application*)0;
 945   Dali::Application::DeviceOrientationChangedSignalType* result      = 0;
 946
 947   application = (Dali::Application*)app;
 948   {
 949     try
 950     {
 951       result = (Dali::Application::DeviceOrientationChangedSignalType*)&(application)->TaskDeviceOrientationChangedSignal();
 952     }
 953     CALL_CATCH_EXCEPTION(0);
 954   }
 955   jresult = (void*)result;
 956   return jresult;
 957 }
 958
 959 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Empty(void* jarg1)
 960 {
 961   unsigned int                                             jresult;
 962   Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
 963   bool                                                     result;
 964
 965   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
 966   {
 967     try
 968     {
 969       result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Empty((Dali::Signal<void(Dali::DeviceStatus::Battery::Status)> const*)arg1);
 970     }
 971     CALL_CATCH_EXCEPTION(0);
 972   }
 973
 974   jresult = result;
 975   return jresult;
 976 }
 977
 978 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_GetConnectionCount(void* jarg1)
 979 {
 980   unsigned long                                            jresult;
 981   Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
 982   std::size_t                                              result;
 983
 984   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
 985   {
 986     try
 987     {
 988       result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::DeviceStatus::Battery::Status)> const*)arg1);
 989     }
 990     CALL_CATCH_EXCEPTION(0);
 991   }
 992   jresult = (unsigned long)result;
 993   return jresult;
 994 }
 995
 996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Connect(void* jarg1, void* jarg2)
 997 {
 998   Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
 999   void (*arg2)(Dali::DeviceStatus::Battery::Status)             = (void (*)(Dali::DeviceStatus::Battery::Status))0;
1000
1001   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
1002   arg2 = (void (*)(Dali::DeviceStatus::Battery::Status))jarg2;
1003   {
1004     try
1005     {
1006       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Connect(arg1, arg2);
1007     }
1008     CALL_CATCH_EXCEPTION();
1009   }
1010 }
1011
1012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Disconnect(void* jarg1, void* jarg2)
1013 {
1014   Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
1015   void (*arg2)(Dali::DeviceStatus::Battery::Status)             = (void (*)(Dali::DeviceStatus::Battery::Status))0;
1016
1017   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
1018   arg2 = (void (*)(Dali::DeviceStatus::Battery::Status))jarg2;
1019   {
1020     try
1021     {
1022       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Disconnect(arg1, arg2);
1023     }
1024     CALL_CATCH_EXCEPTION();
1025   }
1026 }
1027
1028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Emit(void* jarg1, void* jarg2)
1029 {
1030   Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
1031   Dali::DeviceStatus::Battery::Status                      arg2;
1032   Dali::DeviceStatus::Battery::Status*                     argp2;
1033
1034   arg1  = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
1035   argp2 = (Dali::DeviceStatus::Battery::Status*)jarg2;
1036   if(!argp2)
1037   {
1038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Battery::Status", 0);
1039     return;
1040   }
1041   arg2 = *argp2;
1042   {
1043     try
1044     {
1045       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Emit(arg1, arg2);
1046     }
1047     CALL_CATCH_EXCEPTION();
1048   }
1049 }
1050
1051 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_new_LowBatterySignalType()
1052 {
1053   void*                                                    jresult;
1054   Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* result = 0;
1055
1056   {
1057     try
1058     {
1059       result = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)new Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>();
1060     }
1061     CALL_CATCH_EXCEPTION(0);
1062   }
1063
1064   jresult = (void*)result;
1065   return jresult;
1066 }
1067
1068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_LowBatterySignalType(void* jarg1)
1069 {
1070   Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
1071
1072   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
1073   {
1074     try
1075     {
1076       delete arg1;
1077     }
1078     CALL_CATCH_EXCEPTION();
1079   }
1080 }
1081
1082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Empty(void* jarg1)
1083 {
1084   unsigned int                                            jresult;
1085   Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
1086   bool                                                    result;
1087
1088   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
1089   {
1090     try
1091     {
1092       result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Empty((Dali::Signal<void(Dali::DeviceStatus::Memory::Status)> const*)arg1);
1093     }
1094     CALL_CATCH_EXCEPTION(0);
1095   }
1096   jresult = result;
1097   return jresult;
1098 }
1099
1100 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_GetConnectionCount(void* jarg1)
1101 {
1102   unsigned long                                           jresult;
1103   Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
1104   std::size_t                                             result;
1105
1106   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
1107   {
1108     try
1109     {
1110       result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::DeviceStatus::Memory::Status)> const*)arg1);
1111     }
1112     CALL_CATCH_EXCEPTION(0);
1113   }
1114   jresult = (unsigned long)result;
1115   return jresult;
1116 }
1117
1118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Connect(void* jarg1, void* jarg2)
1119 {
1120   Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
1121   void (*arg2)(Dali::DeviceStatus::Memory::Status)             = (void (*)(Dali::DeviceStatus::Memory::Status))0;
1122
1123   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
1124   arg2 = (void (*)(Dali::DeviceStatus::Memory::Status))jarg2;
1125   {
1126     try
1127     {
1128       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Connect(arg1, arg2);
1129     }
1130     CALL_CATCH_EXCEPTION();
1131   }
1132 }
1133
1134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Disconnect(void* jarg1, void* jarg2)
1135 {
1136   Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
1137   void (*arg2)(Dali::DeviceStatus::Memory::Status)             = (void (*)(Dali::DeviceStatus::Memory::Status))0;
1138
1139   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
1140   arg2 = (void (*)(Dali::DeviceStatus::Memory::Status))jarg2;
1141   {
1142     try
1143     {
1144       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Disconnect(arg1, arg2);
1145     }
1146     CALL_CATCH_EXCEPTION();
1147   }
1148 }
1149
1150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Emit(void* jarg1, void* jarg2)
1151 {
1152   Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
1153   Dali::DeviceStatus::Memory::Status                      arg2;
1154   Dali::DeviceStatus::Memory::Status*                     argp2;
1155
1156   arg1  = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
1157   argp2 = (Dali::DeviceStatus::Memory::Status*)jarg2;
1158   if(!argp2)
1159   {
1160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Memory::Status", 0);
1161     return;
1162   }
1163   arg2 = *argp2;
1164   {
1165     try
1166     {
1167       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Emit(arg1, arg2);
1168     }
1169     CALL_CATCH_EXCEPTION();
1170   }
1171 }
1172
1173 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_new_LowMemorySignalType()
1174 {
1175   void*                                                   jresult;
1176   Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* result = 0;
1177
1178   {
1179     try
1180     {
1181       result = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)new Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>();
1182     }
1183     CALL_CATCH_EXCEPTION(0);
1184   }
1185   jresult = (void*)result;
1186   return jresult;
1187 }
1188
1189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_LowMemorySignalType(void* jarg1)
1190 {
1191   Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
1192
1193   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
1194   {
1195     try
1196     {
1197       delete arg1;
1198     }
1199     CALL_CATCH_EXCEPTION();
1200   }
1201 }
1202
1203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_Empty(void* jarg1)
1204 {
1205   unsigned int                                            jresult;
1206   Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)0;
1207   bool                                                    result;
1208
1209   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)jarg1;
1210   {
1211     try
1212     {
1213       result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Empty((Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)> const*)arg1);
1214     }
1215     CALL_CATCH_EXCEPTION(0);
1216   }
1217   jresult = result;
1218   return jresult;
1219 }
1220
1221 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_GetConnectionCount(void* jarg1)
1222 {
1223   unsigned long                                           jresult;
1224   Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)0;
1225   std::size_t                                             result;
1226
1227   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)jarg1;
1228   {
1229     try
1230     {
1231       result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)> const*)arg1);
1232     }
1233     CALL_CATCH_EXCEPTION(0);
1234   }
1235   jresult = (unsigned long)result;
1236   return jresult;
1237 }
1238
1239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_Connect(void* jarg1, void* jarg2)
1240 {
1241   Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)0;
1242   void (*arg2)(Dali::DeviceStatus::Orientation::Status)             = (void (*)(Dali::DeviceStatus::Orientation::Status))0;
1243
1244   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)jarg1;
1245   arg2 = (void (*)(Dali::DeviceStatus::Orientation::Status))jarg2;
1246   {
1247     try
1248     {
1249       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Connect(arg1, arg2);
1250     }
1251     CALL_CATCH_EXCEPTION();
1252   }
1253 }
1254
1255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_Disconnect(void* jarg1, void* jarg2)
1256 {
1257   Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)0;
1258   void (*arg2)(Dali::DeviceStatus::Orientation::Status)             = (void (*)(Dali::DeviceStatus::Orientation::Status))0;
1259
1260   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)jarg1;
1261   arg2 = (void (*)(Dali::DeviceStatus::Orientation::Status))jarg2;
1262   {
1263     try
1264     {
1265       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Disconnect(arg1, arg2);
1266     }
1267     CALL_CATCH_EXCEPTION();
1268   }
1269 }
1270
1271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_Emit(void* jarg1, void* jarg2)
1272 {
1273   Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)0;
1274   Dali::DeviceStatus::Orientation::Status                      arg2;
1275   Dali::DeviceStatus::Orientation::Status*                     argp2;
1276
1277   arg1  = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)jarg1;
1278   argp2 = (Dali::DeviceStatus::Orientation::Status*)jarg2;
1279   if(!argp2)
1280   {
1281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Orientation::Status", 0);
1282     return;
1283   }
1284   arg2 = *argp2;
1285   {
1286     try
1287     {
1288       Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Emit(arg1, arg2);
1289     }
1290     CALL_CATCH_EXCEPTION();
1291   }
1292 }
1293
1294 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_new_DeviceOrientationChangedSignalType()
1295 {
1296   void*                                                   jresult;
1297   Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>* result = 0;
1298
1299   {
1300     try
1301     {
1302       result = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)new Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>();
1303     }
1304     CALL_CATCH_EXCEPTION(0);
1305   }
1306   jresult = (void*)result;
1307   return jresult;
1308 }
1309
1310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_DeviceOrientationChangedSignalType(void* jarg1)
1311 {
1312   Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)0;
1313
1314   arg1 = (Dali::Signal<void(Dali::DeviceStatus::Orientation::Status)>*)jarg1;
1315   {
1316     try
1317     {
1318       delete arg1;
1319     }
1320     CALL_CATCH_EXCEPTION();
1321   }
1322 }
1323
1324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void* jarg1)
1325 {
1326   unsigned int                            jresult;
1327   Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
1328   bool                                    result;
1329
1330   arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
1331   {
1332     try
1333     {
1334       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal<void(Dali::Application&)> const*)arg1);
1335     }
1336     CALL_CATCH_EXCEPTION(0);
1337   }
1338
1339   jresult = result;
1340   return jresult;
1341 }
1342
1343 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void* jarg1)
1344 {
1345   unsigned long                           jresult;
1346   Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
1347   std::size_t                             result;
1348
1349   arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
1350   {
1351     try
1352     {
1353       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::Application&)> const*)arg1);
1354     }
1355     CALL_CATCH_EXCEPTION(0);
1356   }
1357
1358   jresult = (unsigned long)result;
1359   return jresult;
1360 }
1361
1362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void* jarg1, void* jarg2)
1363 {
1364   Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
1365   void (*arg2)(Dali::Application&)             = (void (*)(Dali::Application&))0;
1366
1367   arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
1368   arg2 = (void (*)(Dali::Application&))jarg2;
1369   {
1370     try
1371     {
1372       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1, arg2);
1373     }
1374     CALL_CATCH_EXCEPTION();
1375   }
1376 }
1377
1378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void* jarg1, void* jarg2)
1379 {
1380   Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
1381   void (*arg2)(Dali::Application&)             = (void (*)(Dali::Application&))0;
1382
1383   arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
1384   arg2 = (void (*)(Dali::Application&))jarg2;
1385   {
1386     try
1387     {
1388       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1, arg2);
1389     }
1390     CALL_CATCH_EXCEPTION();
1391   }
1392 }
1393
1394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void* jarg1, void* jarg2)
1395 {
1396   Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
1397   Dali::Application*                      arg2 = 0;
1398
1399   arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
1400   arg2 = (Dali::Application*)jarg2;
1401   if(!arg2)
1402   {
1403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
1404     return;
1405   }
1406   {
1407     try
1408     {
1409       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1, *arg2);
1410     }
1411     CALL_CATCH_EXCEPTION();
1412   }
1413 }
1414
1415 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ApplicationSignal()
1416 {
1417   void*                                   jresult;
1418   Dali::Signal<void(Dali::Application&)>* result = 0;
1419
1420   {
1421     try
1422     {
1423       result = (Dali::Signal<void(Dali::Application&)>*)new Dali::Signal<void(Dali::Application&)>();
1424     }
1425     CALL_CATCH_EXCEPTION(0);
1426   }
1427
1428   jresult = (void*)result;
1429   return jresult;
1430 }
1431
1432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void* jarg1)
1433 {
1434   Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
1435
1436   arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
1437   {
1438     try
1439     {
1440       delete arg1;
1441     }
1442     CALL_CATCH_EXCEPTION();
1443   }
1444 }
1445
1446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void* jarg1)
1447 {
1448   unsigned int                                   jresult;
1449   Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
1450   bool                                           result;
1451
1452   arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
1453   {
1454     try
1455     {
1456       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal<void(Dali::Application&, void*)> const*)arg1);
1457     }
1458     CALL_CATCH_EXCEPTION(0);
1459   }
1460
1461   jresult = result;
1462   return jresult;
1463 }
1464
1465 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void* jarg1)
1466 {
1467   unsigned long                                  jresult;
1468   Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
1469   std::size_t                                    result;
1470
1471   arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
1472   {
1473     try
1474     {
1475       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::Application&, void*)> const*)arg1);
1476     }
1477     CALL_CATCH_EXCEPTION(0);
1478   }
1479
1480   jresult = (unsigned long)result;
1481   return jresult;
1482 }
1483
1484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void* jarg1, void* jarg2)
1485 {
1486   Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
1487   void (*arg2)(Dali::Application&, void*)             = (void (*)(Dali::Application&, void*))0;
1488
1489   arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
1490   arg2 = (void (*)(Dali::Application&, void*))jarg2;
1491   {
1492     try
1493     {
1494       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1, arg2);
1495     }
1496     CALL_CATCH_EXCEPTION();
1497   }
1498 }
1499
1500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void* jarg1, void* jarg2)
1501 {
1502   Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
1503   void (*arg2)(Dali::Application&, void*)             = (void (*)(Dali::Application&, void*))0;
1504
1505   arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
1506   arg2 = (void (*)(Dali::Application&, void*))jarg2;
1507   {
1508     try
1509     {
1510       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1, arg2);
1511     }
1512     CALL_CATCH_EXCEPTION();
1513   }
1514 }
1515
1516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void* jarg1, void* jarg2, void* jarg3)
1517 {
1518   Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
1519   Dali::Application*                             arg2 = 0;
1520   void*                                          arg3 = (void*)0;
1521
1522   arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
1523   arg2 = (Dali::Application*)jarg2;
1524   if(!arg2)
1525   {
1526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
1527     return;
1528   }
1529   arg3 = jarg3;
1530   {
1531     try
1532     {
1533       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1, *arg2, arg3);
1534     }
1535     CALL_CATCH_EXCEPTION();
1536   }
1537 }
1538
1539 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal()
1540 {
1541   void*                                          jresult;
1542   Dali::Signal<void(Dali::Application&, void*)>* result = 0;
1543
1544   {
1545     try
1546     {
1547       result = (Dali::Signal<void(Dali::Application&, void*)>*)new Dali::Signal<void(Dali::Application&, void*)>();
1548     }
1549     CALL_CATCH_EXCEPTION(0);
1550   }
1551
1552   jresult = (void*)result;
1553   return jresult;
1554 }
1555
1556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void* jarg1)
1557 {
1558   Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
1559
1560   arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
1561   {
1562     try
1563     {
1564       delete arg1;
1565     }
1566     CALL_CATCH_EXCEPTION();
1567   }
1568 }
1569
1570 /*application-devel binding*/
1571
1572 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_4(int jarg1, char* jarg3, int jarg4, void* jarg5)
1573 {
1574   void*                          jresult;
1575   int*                           argc = nullptr;
1576   char***                        argv = nullptr;
1577   Dali::Application::WINDOW_MODE arg4;
1578   Dali::PositionSize             arg5;
1579   Dali::PositionSize*            argp5;
1580   Dali::Application              result;
1581
1582   if(!jarg3)
1583   {
1584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1585     return 0;
1586   }
1587   std::string arg3(jarg3);
1588   arg4  = (Dali::Application::WINDOW_MODE)jarg4;
1589   argp5 = (Dali::PositionSize*)jarg5;
1590   if(!argp5)
1591   {
1592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
1593     return 0;
1594   }
1595   arg5 = *argp5;
1596   {
1597     try
1598     {
1599       result = Dali::Application::New(argc, argv, arg3, arg4, arg5);
1600     }
1601     CALL_CATCH_EXCEPTION(0);
1602   }
1603
1604   jresult = new Dali::Application((const Dali::Application&)result);
1605
1606   return jresult;
1607 }
1608
1609 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_5(int nuiArgc, char* nuiArgv, char* nuiStyleSheet, int nuiWindowMode, void* initRectangle, int nuiWindowType)
1610 {
1611   void*                          jresult;
1612   int*                           argc = nullptr;
1613   char***                        argv = nullptr;
1614   Dali::Application::WINDOW_MODE windowMode;
1615   Dali::PositionSize             rect;
1616   Dali::PositionSize*            rectp;
1617   Dali::WindowType               windowType;
1618   Dali::Application              result;
1619
1620   GenerationArgV(nuiArgc, nuiArgv);
1621   argc = &gArgC;
1622   argv = &gArgV;
1623
1624   if(!nuiStyleSheet)
1625   {
1626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1627     return 0;
1628   }
1629   std::string styleSheet(nuiStyleSheet);
1630   windowMode  = (Dali::Application::WINDOW_MODE)nuiWindowMode;
1631   rectp = (Dali::PositionSize*)initRectangle;
1632   windowType  = (Dali::WindowType)nuiWindowType;
1633
1634   if(!rectp)
1635   {
1636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
1637     return 0;
1638   }
1639   rect = *rectp;
1640   {
1641     try
1642     {
1643       result = Dali::DevelApplication::New(argc, argv, styleSheet, windowMode, rect, windowType);
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
1830 SWIGEXPORT int32_t SWIGSTDCALL CSharp_Dali_Application_GetRenderThreadId(void* jarg1)
1831 {
1832   Dali::Application* arg1 = (Dali::Application*)jarg1;
1833
1834   int32_t result;
1835   try
1836   {
1837     result = Dali::DevelApplication::GetRenderThreadId(*arg1);
1838   }
1839   CALL_CATCH_EXCEPTION(0);
1840   return result;
1841 }
1842
1843
1844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_FlushUpdateMessages(void* jarg1)
1845 {
1846   Dali::Application* arg1 = (Dali::Application*)jarg1;
1847
1848   try
1849   {
1850     Dali::DevelApplication::FlushUpdateMessages(*arg1);
1851   }
1852   CALL_CATCH_EXCEPTION();
1853 }
1854
1855 #ifdef __cplusplus
1856 }
1857 #endif