Remove useless argv allocation when create application.

We don't need to use the name of application name
"dali-csharp-app"

So, make most of application use nullptr.
And use gArgV only if argments comes from NUI side.

Change-Id: I2487e39b8f1a3f2adbd4e6309897b9e7f48d161e
Signed-off-by: Eunki, Hong <eunkiki.hong@samsung.com>

diff --git a/dali-csharp-binder/src/application-wrap.cpp b/dali-csharp-binder/src/application-wrap.cpp
old mode 100755 (executable)
new mode 100644 (file)
index b37d01f..034677a
--- a/dali-csharp-binder/src/application-wrap.cpp
+++ b/dali-csharp-binder/src/application-wrap.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,86 +16,122 @@
  */
 
 // EXTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/application-devel.h>
 #include <dali/integration-api/adaptor-framework/adaptor.h>
 #include <dali/public-api/adaptor-framework/application.h>
 #include <dali/public-api/adaptor-framework/window-enumerations.h>
-#include <dali/devel-api/adaptor-framework/application-devel.h>
 
 // INTERNAL INCLUDES
 #include "common.h"
 
 /* Callback for returning strings to C# without leaking memory */
-typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
+typedef char*(SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char*);
 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
 
 namespace
 {
 // keep argcs and argv so they're always available to DALi
-int gArgC = 0;
+// Note : This argments used only if argv comes externally.
+int    gArgC = 0;
 char** gArgV = nullptr;
+
+void ReleaseArgVMemory()
+{
+  if(gArgV)
+  {
+    // free string data
+    for(int i = 0; i < gArgC + 1; ++i)
+    {
+      delete[] gArgV[i];
+    }
+    delete[] gArgV;
+    gArgV = nullptr;
+  }
+  gArgC = 0;
+}
 } // unnamed namespace
 
-SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Empty(Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > const *self){
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Empty(Dali::Signal<void(Dali::DeviceStatus::Battery::Status)> const* self)
+{
   return self->Empty();
 }
-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){
+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)
+{
   return self->GetConnectionCount();
 }
-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)){
-  self->Connect( func );
+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))
+{
+  self->Connect(func);
 }
-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)){
-  self->Disconnect( func );
+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))
+{
+  self->Disconnect(func);
 }
-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){
-  self->Emit( arg );
+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)
+{
+  self->Emit(arg);
 }
-SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Empty(Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > const *self){
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Empty(Dali::Signal<void(Dali::DeviceStatus::Memory::Status)> const* self)
+{
   return self->Empty();
 }
-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){
+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)
+{
   return self->GetConnectionCount();
 }
-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)){
-  self->Connect( func );
+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))
+{
+  self->Connect(func);
 }
-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)){
-  self->Disconnect( func );
+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))
+{
+  self->Disconnect(func);
 }
-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){
-  self->Emit( arg );
+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)
+{
+  self->Emit(arg);
 }
 
-SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal<void(Dali::Application&)> const* self)
+{
   return self->Empty();
 }
-SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
-return self->GetConnectionCount();
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal<void(Dali::Application&)> const* self)
+{
+  return self->GetConnectionCount();
 }
-SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
-  self->Connect( func );
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal<void(Dali::Application&)>* self, void (*func)(Dali::Application&))
+{
+  self->Connect(func);
 }
-SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
-  self->Disconnect( func );
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal<void(Dali::Application&)>* self, void (*func)(Dali::Application&))
+{
+  self->Disconnect(func);
 }
-SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
-  self->Emit( arg );
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal<void(Dali::Application&)>* self, Dali::Application& arg)
+{
+  self->Emit(arg);
 }
 
-SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal<void(Dali::Application&, void*)> const* self)
+{
   return self->Empty();
 }
-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){
-return self->GetConnectionCount();
+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)
+{
+  return self->GetConnectionCount();
 }
-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 *)){
-self->Connect( func );
+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*))
+{
+  self->Connect(func);
 }
-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 *)){
-self->Disconnect( func );
+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*))
+{
+  self->Disconnect(func);
 }
-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){
-self->Emit( arg1, arg2 );
+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)
+{
+  self->Emit(arg1, arg2);
 }
 
 #ifdef __cplusplus
@@ -103,145 +139,122 @@ extern "C" {
 #endif
 
 /*Application binding*/
-SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
-  return (Dali::BaseHandle *)jarg1;
+SWIGEXPORT Dali::BaseHandle* SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application* jarg1)
+{
+  return (Dali::BaseHandle*)jarg1;
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_PreInitialize() {
-  ApplicationPreInitialize(&gArgC, &gArgV);
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_PreInitialize()
+{
+  ApplicationPreInitialize(nullptr, nullptr);
 }
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
-  void * jresult ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0()
+{
+  void*             jresult;
   Dali::Application result;
 
   {
-    try {
+    try
+    {
       result = Dali::Application::New();
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Application((const Dali::Application &)result);
+  jresult = new Dali::Application((const Dali::Application&)result);
   return jresult;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
-  void * jresult ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1)
+{
+  void* jresult;
 
   Dali::Application result;
   {
-    std::string app_name = "dali-csharp-app";
-    int stringLength = app_name.length();
-    gArgC = 1;
-    gArgV = new char*[gArgC + 1];
-    gArgV[0] = new char[stringLength + 1];
-
-    strncpy(gArgV[0], app_name.c_str(), stringLength);
-    gArgV[0][stringLength] = '\0';
-    gArgV[1] = NULL;
-  }
-  {
-    try {
-      result = Dali::Application::New( &gArgC, &gArgV );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = Dali::Application::New(nullptr, nullptr);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Application((const Dali::Application &)result);
+  jresult = new Dali::Application((const Dali::Application&)result);
   return jresult;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
-  void * jresult ;
-  std::string *arg3 = 0;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char* jarg3)
+{
+  void*        jresult;
+  std::string* arg3 = 0;
 
   Dali::Application result;
+  if(!jarg3)
   {
-    std::string app_name = "dali-csharp-app";
-    int stringLength = app_name.length();
-    gArgC = 1;
-    gArgV = new char*[gArgC + 1];
-    gArgV[0] = new char[stringLength + 1];
-
-    strncpy(gArgV[0], app_name.c_str(), stringLength);
-    gArgV[0][stringLength] = '\0';
-    gArgV[1] = NULL;
-  }
-  if (!jarg3) {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
-    delete []gArgV[0];
-    delete []gArgV;
-    gArgV = nullptr;
     return 0;
   }
   std::string arg3_str(jarg3);
   arg3 = &arg3_str;
   {
-    try {
-      result = Dali::Application::New( &gArgC, &gArgV, (std::string const &)*arg3 );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = Dali::Application::New(nullptr, nullptr, (std::string const&)*arg3);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Application((const Dali::Application &)result);
+  jresult = new Dali::Application((const Dali::Application&)result);
 
   //argout typemap for const std::string&
 
   return jresult;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
-  void * jresult ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char* jarg3, int jarg4)
+{
+  void*                          jresult;
   Dali::Application::WINDOW_MODE arg4;
 
   Dali::Application result;
+  if(!jarg3)
   {
-    std::string app_name = "dali-csharp-app";
-    int stringLength = app_name.length();
-    gArgC = 1;
-    gArgV = new char*[gArgC + 1];
-    gArgV[0] = new char[stringLength + 1];
-
-    strncpy(gArgV[0], app_name.c_str(), stringLength);
-    gArgV[0][stringLength] = '\0';
-    gArgV[1] = NULL;
-  }
-  if (!jarg3) {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
-    delete []gArgV[0];
-    delete []gArgV;
-    gArgV = nullptr;
     return 0;
   }
   std::string arg3(jarg3);
   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
   {
-    try {
-      result = Dali::Application::New( &gArgC, &gArgV, arg3, arg4 );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = Dali::Application::New(nullptr, nullptr, arg3, arg4);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Application((const Dali::Application &)result);
+  jresult = new Dali::Application((const Dali::Application&)result);
 
   //argout typemap for const std::string&
 
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__MANUAL_4(int jarg1, char* jarg2, char* jarg3, int jarg4)
+{
+  void*                          jresult;
+  int*                           argc = nullptr;
+  char***                        argv = nullptr;
+  Dali::Application::WINDOW_MODE arg4;
+  Dali::Application              result;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__MANUAL_4(int jarg1, char * jarg2, char * jarg3, int jarg4) {
-  void * jresult ;
-  int *arg1 = (int *) 0 ;
-  char ***arg2 ;
-  Dali::Application::WINDOW_MODE arg4 ;
-  Dali::Application result;
   {
-    // Todo generate argv data from the C# args
-    int index = 0;
-    int length = 0;
-    char *retPtr = NULL;
-    char *nextPtr;
+    // TODO : What should we do if already generated argv exist?
+    ReleaseArgVMemory();
+    // generate argv data from the C# args
+    int   index  = 0;
+    int   length = 0;
+    char* retPtr = NULL;
+    char* nextPtr;
 
     gArgV = new char*[jarg1 + 1];
 
@@ -249,15 +262,15 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__MANUAL_4(int jarg1, c
         retPtr != NULL && index < jarg1;
         retPtr = strtok_r(NULL, " ", &nextPtr))
     {
-      length = 0;
-      length = strlen(retPtr);
-      gArgV[ index ] = new char[ length + 1 ];
-      strncpy( gArgV[ index ], retPtr, length );
-      gArgV[ index ][ length ] = '\0';
+      length       = 0;
+      length       = strlen(retPtr);
+      gArgV[index] = new char[length + 1];
+      strncpy(gArgV[index], retPtr, length);
+      gArgV[index][length] = '\0';
       index++;
     }
 
-    while( index < jarg1 )
+    while(index < jarg1)
     {
       //if jarg1 - index >1, maybe cause error.
       gArgV[index] = NULL;
@@ -265,1222 +278,1272 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__MANUAL_4(int jarg1, c
     }
 
     gArgV[jarg1] = NULL;
-    gArgC = jarg1;
+    gArgC        = jarg1;
 
-    arg1 = &gArgC;
-    arg2 = &gArgV;
+    argc = &gArgC;
+    argv = &gArgV;
   }
 
   std::string arg3(jarg3);
   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
   {
-    try {
-      result = Dali::Application::New( arg1, arg2, arg3, arg4);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = Dali::Application::New(argc, argv, arg3, arg4);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
-  jresult = new Dali::Application((const Dali::Application &)result);
+  jresult = new Dali::Application((const Dali::Application&)result);
   return jresult;
 }
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
-  void * jresult ;
-  Dali::Application *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0()
+{
+  void*              jresult;
+  Dali::Application* result = 0;
 
   {
-    try {
-      result = (Dali::Application *)new Dali::Application();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application*)new Dali::Application();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void* jarg1)
+{
+  void*              jresult;
+  Dali::Application* arg1   = 0;
+  Dali::Application* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
-  void * jresult ;
-  Dali::Application *arg1 = 0 ;
-  Dali::Application *result = 0 ;
-
-  arg1 = (Dali::Application *)jarg1;
-  if (!arg1) {
+  arg1 = (Dali::Application*)jarg1;
+  if(!arg1)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
     return 0;
   }
   {
-    try {
-      result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application*)new Dali::Application((Dali::Application const&)*arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_Assign(void* jarg1, void* jarg2)
+{
+  void*              jresult;
+  Dali::Application* arg1   = (Dali::Application*)0;
+  Dali::Application* arg2   = 0;
+  Dali::Application* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
-  void * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application *arg2 = 0 ;
-  Dali::Application *result = 0 ;
-
-  arg1 = (Dali::Application *)jarg1;
-  arg2 = (Dali::Application *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Application*)jarg1;
+  arg2 = (Dali::Application*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
     return 0;
   }
   {
-    try {
-      result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application*)&(arg1)->operator=((Dali::Application const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void* jarg1)
+{
+  Dali::Application* arg1 = (Dali::Application*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-
-  arg1 = (Dali::Application *)jarg1;
+  arg1 = (Dali::Application*)jarg1;
   {
-    try {
+    try
+    {
       delete arg1;
-      if( gArgV )
-      {
-        // free string data
-        for( int i=0; i < gArgC+1; i++)
-        {
-          delete [] gArgV[i];
-        }
-        delete [] gArgV;
-      }
-    } CALL_CATCH_EXCEPTION();
+      ReleaseArgVMemory();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void* jarg1)
+{
+  Dali::Application* arg1 = (Dali::Application*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-
-  arg1 = (Dali::Application *)jarg1;
+  arg1 = (Dali::Application*)jarg1;
   {
-    try {
+    try
+    {
       (arg1)->MainLoop();
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void* jarg1)
+{
+  Dali::Application* arg1 = (Dali::Application*)0;
 
-  arg1 = (Dali::Application *)jarg1;
+  arg1 = (Dali::Application*)jarg1;
   {
-    try {
+    try
+    {
       (arg1)->Lower();
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void* jarg1)
+{
+  Dali::Application* arg1 = (Dali::Application*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-
-  arg1 = (Dali::Application *)jarg1;
+  arg1 = (Dali::Application*)jarg1;
   {
-    try {
+    try
+    {
       (arg1)->Quit();
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void* jarg1, void* jarg2)
+{
+  unsigned int        jresult;
+  Dali::Application*  arg1 = (Dali::Application*)0;
+  Dali::CallbackBase* arg2 = (Dali::CallbackBase*)0;
+  bool                result;
 
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
-  unsigned int jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
-  bool result;
-
-  arg1 = (Dali::Application *)jarg1;
-  arg2 = (Dali::CallbackBase *)jarg2;
+  arg1 = (Dali::Application*)jarg1;
+  arg2 = (Dali::CallbackBase*)jarg2;
   {
-    try {
+    try
+    {
       result = (bool)(arg1)->AddIdle(arg2);
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_GetWindow(void* jarg1)
+{
+  void*              jresult;
+  Dali::Application* arg1 = (Dali::Application*)0;
+  Dali::Window       result;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
-  void * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Window result;
-
-  arg1 = (Dali::Application *)jarg1;
+  arg1 = (Dali::Application*)jarg1;
   {
-    try {
+    try
+    {
       result = (arg1)->GetWindow();
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Window((const Dali::Window &)result);
+  jresult = new Dali::Window((const Dali::Window&)result);
   return jresult;
 }
 
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_GetWindowsListSize() {
-  unsigned int jresult ;
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_GetWindowsListSize()
+{
+  unsigned int          jresult;
   Dali::WindowContainer result;
   {
-    try {
-      result = Dali::Adaptor::Get().GetWindows();
+    try
+    {
+      result  = Dali::Adaptor::Get().GetWindows();
       jresult = result.size();
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
   return jresult;
 }
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindowsFromList(unsigned int jarg1) {
-  void * jresult ;
-  unsigned int index = jarg1;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_GetWindowsFromList(unsigned int jarg1)
+{
+  void*                 jresult;
+  unsigned int          index = jarg1;
   Dali::WindowContainer result;
 
   {
-    try {
+    try
+    {
       result = Dali::Adaptor::Get().GetWindows();
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
-  jresult = new Dali::Window((const Dali::Window &)result[index]);
+  jresult = new Dali::Window((const Dali::Window&)result[index]);
   return jresult;
 }
 
-SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
-  char * jresult ;
+SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Application_GetResourcePath()
+{
+  char*       jresult;
   std::string result;
 
   {
-    try {
+    try
+    {
       result = Dali::Application::GetResourcePath();
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = SWIG_csharp_string_callback((&result)->c_str());
   return jresult;
 }
 
-SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetRegion(void * jarg1) {
-  char * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  std::string result;
+SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Application_GetRegion(void* jarg1)
+{
+  char*              jresult;
+  Dali::Application* arg1 = (Dali::Application*)0;
+  std::string        result;
 
-  arg1 = (Dali::Application *)jarg1;
+  arg1 = (Dali::Application*)jarg1;
   {
-    try {
+    try
+    {
       result = (arg1)->GetRegion();
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
   jresult = SWIG_csharp_string_callback((&result)->c_str());
   return jresult;
 }
 
+SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Application_GetLanguage(void* jarg1)
+{
+  char*              jresult;
+  Dali::Application* arg1 = (Dali::Application*)0;
+  std::string        result;
 
-SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetLanguage(void * jarg1) {
-  char * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  std::string result;
-
-  arg1 = (Dali::Application *)jarg1;
+  arg1 = (Dali::Application*)jarg1;
   {
-    try {
+    try
+    {
       result = (arg1)->GetLanguage();
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
   jresult = SWIG_csharp_string_callback((&result)->c_str());
   return jresult;
 }
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_InitSignal(void* jarg1)
+{
+  void*                             jresult;
+  Dali::Application*                arg1   = (Dali::Application*)0;
+  Dali::Application::AppSignalType* result = 0;
 
-  arg1 = (Dali::Application *)jarg1;
+  arg1 = (Dali::Application*)jarg1;
   {
-    try {
-      result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application::AppSignalType*)&(arg1)->InitSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void* jarg1)
+{
+  void*                             jresult;
+  Dali::Application*                arg1   = (Dali::Application*)0;
+  Dali::Application::AppSignalType* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
-
-  arg1 = (Dali::Application *)jarg1;
+  arg1 = (Dali::Application*)jarg1;
   {
-    try {
-      result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application::AppSignalType*)&(arg1)->TerminateSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void* jarg1)
+{
+  void*                             jresult;
+  Dali::Application*                arg1   = (Dali::Application*)0;
+  Dali::Application::AppSignalType* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
-
-  arg1 = (Dali::Application *)jarg1;
+  arg1 = (Dali::Application*)jarg1;
   {
-    try {
-      result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application::AppSignalType*)&(arg1)->PauseSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void* jarg1)
+{
+  void*                             jresult;
+  Dali::Application*                arg1   = (Dali::Application*)0;
+  Dali::Application::AppSignalType* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
-
-  arg1 = (Dali::Application *)jarg1;
+  arg1 = (Dali::Application*)jarg1;
   {
-    try {
-      result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application::AppSignalType*)&(arg1)->ResumeSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void* jarg1)
+{
+  void*                             jresult;
+  Dali::Application*                arg1   = (Dali::Application*)0;
+  Dali::Application::AppSignalType* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
-
-  arg1 = (Dali::Application *)jarg1;
+  arg1 = (Dali::Application*)jarg1;
   {
-    try {
-      result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application::AppSignalType*)&(arg1)->ResetSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void* jarg1)
+{
+  void*                                    jresult;
+  Dali::Application*                       arg1   = (Dali::Application*)0;
+  Dali::Application::AppControlSignalType* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppControlSignalType *result = 0 ;
-
-  arg1 = (Dali::Application *)jarg1;
+  arg1 = (Dali::Application*)jarg1;
   {
-    try {
-      result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application::AppControlSignalType*)&(arg1)->AppControlSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void* jarg1)
+{
+  void*                             jresult;
+  Dali::Application*                arg1   = (Dali::Application*)0;
+  Dali::Application::AppSignalType* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
-
-  arg1 = (Dali::Application *)jarg1;
+  arg1 = (Dali::Application*)jarg1;
   {
-    try {
-      result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application::AppSignalType*)&(arg1)->LanguageChangedSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void* jarg1)
+{
+  void*                             jresult;
+  Dali::Application*                arg1   = (Dali::Application*)0;
+  Dali::Application::AppSignalType* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
-
-  arg1 = (Dali::Application *)jarg1;
+  arg1 = (Dali::Application*)jarg1;
   {
-    try {
-      result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application::AppSignalType*)&(arg1)->RegionChangedSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LowBatterySignal(void * jarg1) {
-  void * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::LowBatterySignalType *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_LowBatterySignal(void* jarg1)
+{
+  void*                                    jresult;
+  Dali::Application*                       arg1   = (Dali::Application*)0;
+  Dali::Application::LowBatterySignalType* result = 0;
 
-  arg1 = (Dali::Application *)jarg1;
+  arg1 = (Dali::Application*)jarg1;
   {
-    try {
-      result = (Dali::Application::LowBatterySignalType *) &(arg1)->LowBatterySignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application::LowBatterySignalType*)&(arg1)->LowBatterySignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_LowMemorySignal(void* jarg1)
+{
+  void*                                   jresult;
+  Dali::Application*                      arg1   = (Dali::Application*)0;
+  Dali::Application::LowMemorySignalType* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LowMemorySignal(void * jarg1) {
-  void * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::LowMemorySignalType *result = 0 ;
-
-  arg1 = (Dali::Application *)jarg1;
+  arg1 = (Dali::Application*)jarg1;
   {
-    try {
-      result = (Dali::Application::LowMemorySignalType *) &(arg1)->LowMemorySignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application::LowMemorySignalType*)&(arg1)->LowMemorySignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TaskInitSignal(void * app) {
-  void * jresult ;
-  Dali::Application *application = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskInitSignal(void* app)
+{
+  void*                             jresult;
+  Dali::Application*                application = (Dali::Application*)0;
+  Dali::Application::AppSignalType* result      = 0;
 
-  application = (Dali::Application *)app;
+  application = (Dali::Application*)app;
   {
-    try {
-      result = (Dali::Application::AppSignalType *) &(application)->TaskInitSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application::AppSignalType*)&(application)->TaskInitSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskTerminateSignal(void* app)
+{
+  void*                             jresult;
+  Dali::Application*                application = (Dali::Application*)0;
+  Dali::Application::AppSignalType* result      = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TaskTerminateSignal(void * app) {
-  void * jresult ;
-  Dali::Application *application = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
-
-  application = (Dali::Application *)app;
+  application = (Dali::Application*)app;
   {
-    try {
-      result = (Dali::Application::AppSignalType *) &(application)->TaskTerminateSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application::AppSignalType*)&(application)->TaskTerminateSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskAppControlSignal(void* app)
+{
+  void*                                    jresult;
+  Dali::Application*                       application = (Dali::Application*)0;
+  Dali::Application::AppControlSignalType* result      = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TaskAppControlSignal(void * app) {
-  void * jresult ;
-  Dali::Application *application = (Dali::Application *) 0 ;
-  Dali::Application::AppControlSignalType *result = 0 ;
-
-  application = (Dali::Application *)app;
+  application = (Dali::Application*)app;
   {
-    try {
-      result = (Dali::Application::AppControlSignalType *) &(application)->TaskAppControlSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application::AppControlSignalType*)&(application)->TaskAppControlSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskLanguageChangedSignal(void* app)
+{
+  void*                             jresult;
+  Dali::Application*                application = (Dali::Application*)0;
+  Dali::Application::AppSignalType* result      = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TaskLanguageChangedSignal(void * app) {
-  void * jresult ;
-  Dali::Application *application = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
-
-  application = (Dali::Application *)app;
+  application = (Dali::Application*)app;
   {
-    try {
-      result = (Dali::Application::AppSignalType *) &(application)->TaskLanguageChangedSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application::AppSignalType*)&(application)->TaskLanguageChangedSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskRegionChangedSignal(void* app)
+{
+  void*                             jresult;
+  Dali::Application*                application = (Dali::Application*)0;
+  Dali::Application::AppSignalType* result      = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TaskRegionChangedSignal(void * app) {
-  void * jresult ;
-  Dali::Application *application = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
-
-  application = (Dali::Application *)app;
+  application = (Dali::Application*)app;
   {
-    try {
-      result = (Dali::Application::AppSignalType *) &(application)->TaskRegionChangedSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application::AppSignalType*)&(application)->TaskRegionChangedSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TaskLowBatterySignal(void * app) {
-  void * jresult ;
-  Dali::Application *application = (Dali::Application *) 0 ;
-  Dali::Application::LowBatterySignalType *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskLowBatterySignal(void* app)
+{
+  void*                                    jresult;
+  Dali::Application*                       application = (Dali::Application*)0;
+  Dali::Application::LowBatterySignalType* result      = 0;
 
-  application = (Dali::Application *)app;
+  application = (Dali::Application*)app;
   {
-    try {
-      result = (Dali::Application::LowBatterySignalType *) &(application)->TaskLowBatterySignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application::LowBatterySignalType*)&(application)->TaskLowBatterySignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskLowMemorySignal(void* app)
+{
+  void*                                   jresult;
+  Dali::Application*                      application = (Dali::Application*)0;
+  Dali::Application::LowMemorySignalType* result      = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TaskLowMemorySignal(void * app) {
-  void * jresult ;
-  Dali::Application *application = (Dali::Application *) 0 ;
-  Dali::Application::LowMemorySignalType *result = 0 ;
-
-  application = (Dali::Application *)app;
+  application = (Dali::Application*)app;
   {
-    try {
-      result = (Dali::Application::LowMemorySignalType *) &(application)->TaskLowMemorySignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Application::LowMemorySignalType*)&(application)->TaskLowMemorySignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Empty(void * jarg1) {
-  unsigned int jresult ;
-  Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
-  bool result;
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Empty(void* jarg1)
+{
+  unsigned int                                             jresult;
+  Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
+  bool                                                     result;
 
-  arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
   {
-    try {
-      result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Empty((Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > const *)arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Empty((Dali::Signal<void(Dali::DeviceStatus::Battery::Status)> const*)arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_GetConnectionCount(void* jarg1)
+{
+  unsigned long                                            jresult;
+  Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
+  std::size_t                                              result;
 
-SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_GetConnectionCount(void * jarg1) {
-  unsigned long jresult ;
-  Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
-  std::size_t result;
-
-  arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
   {
-    try {
-      result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > const *)arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::DeviceStatus::Battery::Status)> const*)arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
   jresult = (unsigned long)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Connect(void* jarg1, void* jarg2)
+{
+  Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
+  void (*arg2)(Dali::DeviceStatus::Battery::Status)             = (void (*)(Dali::DeviceStatus::Battery::Status))0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Connect(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
-  void (*arg2)(Dali::DeviceStatus::Battery::Status) = (void (*)(Dali::DeviceStatus::Battery::Status)) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
   arg2 = (void (*)(Dali::DeviceStatus::Battery::Status))jarg2;
   {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Connect(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Connect(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Disconnect(void* jarg1, void* jarg2)
+{
+  Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
+  void (*arg2)(Dali::DeviceStatus::Battery::Status)             = (void (*)(Dali::DeviceStatus::Battery::Status))0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Disconnect(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
-  void (*arg2)(Dali::DeviceStatus::Battery::Status) = (void (*)(Dali::DeviceStatus::Battery::Status)) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
   arg2 = (void (*)(Dali::DeviceStatus::Battery::Status))jarg2;
   {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Disconnect(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Disconnect(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Emit(void* jarg1, void* jarg2)
+{
+  Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
+  Dali::DeviceStatus::Battery::Status                      arg2;
+  Dali::DeviceStatus::Battery::Status*                     argp2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Emit(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
-  Dali::DeviceStatus::Battery::Status arg2 ;
-  Dali::DeviceStatus::Battery::Status *argp2 ;
-
-  arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
-  argp2 = (Dali::DeviceStatus::Battery::Status *)jarg2;
-  if (!argp2) {
+  arg1  = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
+  argp2 = (Dali::DeviceStatus::Battery::Status*)jarg2;
+  if(!argp2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Battery::Status", 0);
-    return ;
+    return;
   }
   arg2 = *argp2;
   {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Emit(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Emit(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_new_LowBatterySignalType() {
-  void * jresult ;
-  Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_new_LowBatterySignalType()
+{
+  void*                                                    jresult;
+  Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* result = 0;
 
   {
-    try {
-      result = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)new Dali::Signal< void (Dali::DeviceStatus::Battery::Status) >();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)new Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_LowBatterySignalType(void* jarg1)
+{
+  Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_LowBatterySignalType(void * jarg1) {
-  Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::DeviceStatus::Battery::Status) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::DeviceStatus::Battery::Status)>*)jarg1;
   {
-    try {
+    try
+    {
       delete arg1;
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
 }
 
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Empty(void * jarg1) {
-  unsigned int jresult ;
-  Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
-  bool result;
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Empty(void* jarg1)
+{
+  unsigned int                                            jresult;
+  Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
+  bool                                                    result;
 
-  arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
   {
-    try {
-      result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Empty((Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > const *)arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Empty((Dali::Signal<void(Dali::DeviceStatus::Memory::Status)> const*)arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_GetConnectionCount(void* jarg1)
+{
+  unsigned long                                           jresult;
+  Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
+  std::size_t                                             result;
 
-SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_GetConnectionCount(void * jarg1) {
-  unsigned long jresult ;
-  Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
-  std::size_t result;
-
-  arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
   {
-    try {
-      result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > const *)arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::DeviceStatus::Memory::Status)> const*)arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
   jresult = (unsigned long)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Connect(void* jarg1, void* jarg2)
+{
+  Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
+  void (*arg2)(Dali::DeviceStatus::Memory::Status)             = (void (*)(Dali::DeviceStatus::Memory::Status))0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Connect(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
-  void (*arg2)(Dali::DeviceStatus::Memory::Status) = (void (*)(Dali::DeviceStatus::Memory::Status)) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
   arg2 = (void (*)(Dali::DeviceStatus::Memory::Status))jarg2;
   {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Connect(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Connect(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Disconnect(void* jarg1, void* jarg2)
+{
+  Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
+  void (*arg2)(Dali::DeviceStatus::Memory::Status)             = (void (*)(Dali::DeviceStatus::Memory::Status))0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Disconnect(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
-  void (*arg2)(Dali::DeviceStatus::Memory::Status) = (void (*)(Dali::DeviceStatus::Memory::Status)) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
   arg2 = (void (*)(Dali::DeviceStatus::Memory::Status))jarg2;
   {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Disconnect(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Disconnect(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Emit(void* jarg1, void* jarg2)
+{
+  Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
+  Dali::DeviceStatus::Memory::Status                      arg2;
+  Dali::DeviceStatus::Memory::Status*                     argp2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Emit(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
-  Dali::DeviceStatus::Memory::Status arg2 ;
-  Dali::DeviceStatus::Memory::Status *argp2 ;
-
-  arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
-  argp2 = (Dali::DeviceStatus::Memory::Status *)jarg2;
-  if (!argp2) {
+  arg1  = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
+  argp2 = (Dali::DeviceStatus::Memory::Status*)jarg2;
+  if(!argp2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Memory::Status", 0);
-    return ;
+    return;
   }
   arg2 = *argp2;
   {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Emit(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Emit(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_new_LowMemorySignalType() {
-  void * jresult ;
-  Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_new_LowMemorySignalType()
+{
+  void*                                                   jresult;
+  Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* result = 0;
 
   {
-    try {
-      result = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)new Dali::Signal< void (Dali::DeviceStatus::Memory::Status) >();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)new Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_LowMemorySignalType(void* jarg1)
+{
+  Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>* arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_LowMemorySignalType(void * jarg1) {
-  Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::DeviceStatus::Memory::Status) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::DeviceStatus::Memory::Status)>*)jarg1;
   {
-    try {
+    try
+    {
       delete arg1;
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
 }
 
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void* jarg1)
+{
+  unsigned int                            jresult;
+  Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
+  bool                                    result;
 
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
-  unsigned int jresult ;
-  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
-  bool result;
-
-  arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
   {
-    try {
-      result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal<void(Dali::Application&)> const*)arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void* jarg1)
+{
+  unsigned long                           jresult;
+  Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
+  std::size_t                             result;
 
-SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
-  unsigned long jresult ;
-  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
-  std::size_t result;
-
-  arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
   {
-    try {
-      result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::Application&)> const*)arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = (unsigned long)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void* jarg1, void* jarg2)
+{
+  Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
+  void (*arg2)(Dali::Application&)             = (void (*)(Dali::Application&))0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
-  void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
-  arg2 = (void (*)(Dali::Application &))jarg2;
+  arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
+  arg2 = (void (*)(Dali::Application&))jarg2;
   {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void* jarg1, void* jarg2)
+{
+  Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
+  void (*arg2)(Dali::Application&)             = (void (*)(Dali::Application&))0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
-  void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
-  arg2 = (void (*)(Dali::Application &))jarg2;
+  arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
+  arg2 = (void (*)(Dali::Application&))jarg2;
   {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void* jarg1, void* jarg2)
+{
+  Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
+  Dali::Application*                      arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
-  Dali::Application *arg2 = 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
-  arg2 = (Dali::Application *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
+  arg2 = (Dali::Application*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1, *arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
-  void * jresult ;
-  Dali::Signal< void (Dali::Application &) > *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ApplicationSignal()
+{
+  void*                                   jresult;
+  Dali::Signal<void(Dali::Application&)>* result = 0;
 
   {
-    try {
-      result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Signal<void(Dali::Application&)>*)new Dali::Signal<void(Dali::Application&)>();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void* jarg1)
+{
+  Dali::Signal<void(Dali::Application&)>* arg1 = (Dali::Signal<void(Dali::Application&)>*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
-  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::Application&)>*)jarg1;
   {
-    try {
+    try
+    {
       delete arg1;
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void* jarg1)
+{
+  unsigned int                                   jresult;
+  Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
+  bool                                           result;
 
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
-  unsigned int jresult ;
-  Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
-  bool result;
-
-  arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
   {
-    try {
-      result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal<void(Dali::Application&, void*)> const*)arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void* jarg1)
+{
+  unsigned long                                  jresult;
+  Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
+  std::size_t                                    result;
 
-SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
-  unsigned long jresult ;
-  Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
-  std::size_t result;
-
-  arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
   {
-    try {
-      result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::Application&, void*)> const*)arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = (unsigned long)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void* jarg1, void* jarg2)
+{
+  Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
+  void (*arg2)(Dali::Application&, void*)             = (void (*)(Dali::Application&, void*))0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
-  void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
-  arg2 = (void (*)(Dali::Application &,void *))jarg2;
+  arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
+  arg2 = (void (*)(Dali::Application&, void*))jarg2;
   {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void* jarg1, void* jarg2)
+{
+  Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
+  void (*arg2)(Dali::Application&, void*)             = (void (*)(Dali::Application&, void*))0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
-  void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
-  arg2 = (void (*)(Dali::Application &,void *))jarg2;
+  arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
+  arg2 = (void (*)(Dali::Application&, void*))jarg2;
   {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void* jarg1, void* jarg2, void* jarg3)
+{
+  Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
+  Dali::Application*                             arg2 = 0;
+  void*                                          arg3 = (void*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
-  Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
-  Dali::Application *arg2 = 0 ;
-  void *arg3 = (void *) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
-  arg2 = (Dali::Application *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
+  arg2 = (Dali::Application*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
-    return ;
+    return;
   }
   arg3 = jarg3;
   {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1, *arg2, arg3);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
-  void * jresult ;
-  Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal()
+{
+  void*                                          jresult;
+  Dali::Signal<void(Dali::Application&, void*)>* result = 0;
 
   {
-    try {
-      result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Signal<void(Dali::Application&, void*)>*)new Dali::Signal<void(Dali::Application&, void*)>();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void* jarg1)
+{
+  Dali::Signal<void(Dali::Application&, void*)>* arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
-  Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::Application&, void*)>*)jarg1;
   {
-    try {
+    try
+    {
       delete arg1;
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
 /*application-devel binding*/
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_4(int jarg1, char * jarg3, int jarg4, void * jarg5) {
-  void * jresult ;
-  int *arg1 = (int *) 0 ;
-  char ***arg2 ;
-  Dali::Application::WINDOW_MODE arg4 ;
-  Dali::PositionSize arg5 ;
-  Dali::PositionSize *argp5 ;
-  Dali::Application result;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_4(int jarg1, char* jarg3, int jarg4, void* jarg5)
+{
+  void*                          jresult;
+  int*                           argc = nullptr;
+  char***                        argv = nullptr;
+  Dali::Application::WINDOW_MODE arg4;
+  Dali::PositionSize             arg5;
+  Dali::PositionSize*            argp5;
+  Dali::Application              result;
 
+  if(!jarg3)
   {
-    // Todo generate argv data from the C# args
-    char **array;         // two dimensional array
-    int numStrings = 1;     // number of strings
-    int stringLength = 30;      // max string length.
-    array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
-    if(!array) {
-      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "array is null", 0);
-      return 0;
-    }
-    gArgV = array;
-
-    // allocate the string data
-    for( int i=0; i < numStrings; i++)
-    {
-      array[i]=(char *)malloc( stringLength * sizeof(char) );
-    }
-    array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
-
-    std::string temp = "dali-csharp-app";
-
-    if(!array[0]) {
-      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "array[0] is null", 0);
-      return 0;
-    }
-    array[0][temp.copy(array[0], strlen(array[0])-1)] = '\0';
-
-    arg1 = &gArgC;
-    arg2 = &gArgV;
-  }
-  if (!jarg3) {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
     return 0;
   }
   std::string arg3(jarg3);
-  arg4 = (Dali::Application::WINDOW_MODE)jarg4;
-  argp5 = (Dali::PositionSize *)jarg5;
-  if (!argp5) {
+  arg4  = (Dali::Application::WINDOW_MODE)jarg4;
+  argp5 = (Dali::PositionSize*)jarg5;
+  if(!argp5)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
     return 0;
   }
   arg5 = *argp5;
   {
-    try {
-      result = Dali::Application::New( arg1, arg2, arg3, arg4, arg5 );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = Dali::Application::New(argc, argv, arg3, arg4, arg5);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Application((const Dali::Application &)result);
+  jresult = new Dali::Application((const Dali::Application&)result);
 
   return jresult;
 }
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_5(int jarg1, char * jarg3, int jarg4, void * jarg5, int jarg6) {
-  void * jresult ;
-  int *arg1 = (int *) 0 ;
-  char ***arg2 ;
-  Dali::Application::WINDOW_MODE arg4 ;
-  Dali::PositionSize arg5 ;
-  Dali::PositionSize *argp5 ;
-  Dali::WindowType arg6;
-  Dali::Application result;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_5(int jarg1, char* jarg3, int jarg4, void* jarg5, int jarg6)
+{
+  void*                          jresult;
+  int*                           argc = nullptr;
+  char***                        argv = nullptr;
+  Dali::Application::WINDOW_MODE arg4;
+  Dali::PositionSize             arg5;
+  Dali::PositionSize*            argp5;
+  Dali::WindowType               arg6;
+  Dali::Application              result;
 
+  if(!jarg3)
   {
-    // Todo generate argv data from the C# args
-    char **array;         // two dimensional array
-    int numStrings = 1;     // number of strings
-    int stringLength = 30;      // max string length.
-    array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
-    if(!array) {
-      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "array is null", 0);
-      return 0;
-    }
-    gArgV = array;
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+    return 0;
+  }
+  std::string arg3(jarg3);
+  arg4  = (Dali::Application::WINDOW_MODE)jarg4;
+  argp5 = (Dali::PositionSize*)jarg5;
+  arg6  = (Dali::WindowType)jarg6;
 
-    // allocate the string data
-    for( int i=0; i < numStrings; i++)
+  if(!argp5)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
+    return 0;
+  }
+  arg5 = *argp5;
+  {
+    try
     {
-      array[i]=(char *)malloc( stringLength * sizeof(char) );
+      result = Dali::DevelApplication::New(argc, argv, arg3, arg4, arg5, arg6);
     }
-    array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
+    CALL_CATCH_EXCEPTION(0);
+  }
 
-    std::string temp = "dali-csharp-app";
+  jresult = new Dali::Application((const Dali::Application&)result);
 
-    if(!array[0]) {
-      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "array[0] is null", 0);
-      return 0;
-    }
-    array[0][temp.copy(array[0], strlen(array[0])-1)] = '\0';
+  return jresult;
+}
 
-    arg1 = &gArgC;
-    arg2 = &gArgV;
-  }
-  if (!jarg3) {
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_6(int nuiArgc, char* nuiStyleSheet, int nuiWindowMode, void* nuiPositionSize, bool nuiUseUiThread)
+{
+  void*                          jresult;
+  int*                           argc = nullptr;
+  char***                        argv = nullptr;
+  Dali::Application::WINDOW_MODE windowMode;
+  Dali::PositionSize             positionSize;
+  Dali::PositionSize*            positionSizeP;
+  bool                           useUiThread;
+  Dali::Application              result;
+
+  if(!nuiStyleSheet)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
     return 0;
   }
-  std::string arg3(jarg3);
-  arg4 = (Dali::Application::WINDOW_MODE)jarg4;
-  argp5 = (Dali::PositionSize *)jarg5;
-  arg6 = (Dali::WindowType)jarg6;
+  std::string styleSheet(nuiStyleSheet);
+  windowMode    = (Dali::Application::WINDOW_MODE)nuiWindowMode;
+  positionSizeP = (Dali::PositionSize*)nuiPositionSize;
+  useUiThread   = nuiUseUiThread;
 
-  if (!argp5) {
+  if(!positionSizeP)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
     return 0;
   }
-  arg5 = *argp5;
+
+  positionSize = *positionSizeP;
   {
-    try {
-      result = Dali::DevelApplication::New( arg1, arg2, arg3, arg4, arg5, arg6 );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = Dali::Application::New(argc, argv, styleSheet, windowMode, positionSize, useUiThread);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Application((const Dali::Application &)result);
+  jresult = new Dali::Application((const Dali::Application&)result);
 
   return jresult;
 }
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_6(int nuiArgc, char * nuiStyleSheet, int nuiWindowMode, void * nuiPositionSize, bool nuiUseUiThread) {
-  void * jresult ;
-  int *argc = (int *) 0 ;
-  char ***argv ;
-  Dali::Application::WINDOW_MODE windowMode ;
-  Dali::PositionSize positionSize ;
-  Dali::PositionSize *positionSizeP ;
-  bool useUiThread;
-  Dali::Application result;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New_WithWindowSizePosition(int jarg1, char* jarg2, char* jarg3, int jarg4, void* jarg5)
+{
+  void*                          jresult;
+  int*                           argc = nullptr;
+  char***                        argv = nullptr;
+  Dali::Application::WINDOW_MODE arg4;
+  Dali::PositionSize             arg5;
+  Dali::PositionSize*            argp5;
+  Dali::Application              result;
 
   {
-    // Todo generate argv data from the C# args
-    char **array;         // two dimensional array
-    int numStrings = 1;     // number of strings
-    int stringLength = 30;      // max string length.
-    array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
-    if(!array) {
-      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "array is null", 0);
-      return 0;
-    }
-    gArgV = array;
+    // TODO : What should we do if already generated argv exist?
+    ReleaseArgVMemory();
+    // generate argv data from the C# args
+    int   index  = 0;
+    int   length = 0;
+    char* retPtr = NULL;
+    char* nextPtr;
 
-    // allocate the string data
-    for( int i=0; i < numStrings; i++)
+    gArgV = new char*[jarg1 + 1];
+
+    for(retPtr = strtok_r(jarg2, " ", &nextPtr);
+        retPtr != NULL && index < jarg1;
+        retPtr = strtok_r(NULL, " ", &nextPtr))
     {
-      array[i]=(char *)malloc( stringLength * sizeof(char) );
+      length       = 0;
+      length       = strlen(retPtr);
+      gArgV[index] = new char[length + 1];
+      strncpy(gArgV[index], retPtr, length);
+      gArgV[index][length] = '\0';
+      index++;
     }
-    array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
 
-    std::string temp = "dali-csharp-app";
-
-    if(!array[0]) {
-      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "array[0] is null", 0);
-      return 0;
+    while(index < jarg1)
+    {
+      //if jarg1 - index >1, maybe cause error.
+      gArgV[index] = NULL;
+      index++;
     }
-    array[0][temp.copy(array[0], strlen(array[0])-1)] = '\0';
+
+    gArgV[jarg1] = NULL;
+    gArgC        = jarg1;
 
     argc = &gArgC;
     argv = &gArgV;
   }
-  if (!nuiStyleSheet) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
-    return 0;
-  }
-  std::string styleSheet(nuiStyleSheet);
-  windowMode = (Dali::Application::WINDOW_MODE)nuiWindowMode;
-  positionSizeP = (Dali::PositionSize *)nuiPositionSize;
-  useUiThread = nuiUseUiThread;
 
-  if (!positionSizeP) {
+  std::string arg3(jarg3);
+  arg4  = (Dali::Application::WINDOW_MODE)jarg4;
+  argp5 = (Dali::PositionSize*)jarg5;
+  if(!argp5)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
     return 0;
   }
-
-  positionSize = *positionSizeP;
+  arg5 = *argp5;
   {
-    try {
-      result = Dali::Application::New(argc, argv, styleSheet, windowMode, positionSize, useUiThread);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = Dali::Application::New(argc, argv, arg3, arg4, arg5);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
-
-  jresult = new Dali::Application((const Dali::Application &)result);
-
+  jresult = new Dali::Application((const Dali::Application&)result);
   return jresult;
 }
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New_WithWindowSizePosition(int jarg1, char * jarg2, char * jarg3, int jarg4, void * jarg5) {
- void * jresult ;
- int *arg1 = (int *) 0 ;
- char ***arg2 ;
- Dali::Application::WINDOW_MODE arg4 ;
- Dali::PositionSize arg5 ;
- Dali::PositionSize *argp5 ;
- Dali::Application result;
- {
-   int index = 0;
-   int length = 0;
-   char *retPtr = NULL;
-   char *nextPtr;
-
-   gArgV = new char*[jarg1 + 1];
-
-   for(retPtr = strtok_r(jarg2, " ", &nextPtr);
-       retPtr != NULL && index < jarg1;
-       retPtr = strtok_r(NULL, " ", &nextPtr))
-   {
-     length = 0;
-     length = strlen(retPtr);
-     gArgV[ index ] = new char[ length + 1 ];
-     strncpy( gArgV[ index ], retPtr, length );
-     gArgV[ index ][ length ] = '\0';
-     index++;
-   }
-
-   while( index < jarg1 )
-   {
-     //if jarg1 - index >1, maybe cause error.
-     gArgV[index] = NULL;
-     index++;
-   }
-
-   gArgV[jarg1] = NULL;
-   gArgC = jarg1;
-
-   arg1 = &gArgC;
-   arg2 = &gArgV;
- }
-
- std::string arg3(jarg3);
- arg4 = (Dali::Application::WINDOW_MODE)jarg4;
- argp5 = (Dali::PositionSize *)jarg5;
- if (!argp5) {
-   SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
-   return 0;
- }
- arg5 = *argp5;
- {
-   try {
-     result = Dali::Application::New( arg1, arg2, arg3, arg4, arg5 );
-   } CALL_CATCH_EXCEPTION(0);
- }
- jresult = new Dali::Application((const Dali::Application &)result);
- return jresult;
-}
-
-
 #ifdef __cplusplus
 }
 #endif