Add the get/set rendering mode APIs wrapper in GlWindow

Add the get/set rendering mode APIs wrapper in GlWindow.
It is used to set/get rendering mode that is contnuous or render once.

Change-Id: I7fcebfcc1d47a8f9a248650590bba367037fd5b0

diff --git a/dali-csharp-binder/src/gl-window.cpp b/dali-csharp-binder/src/gl-window.cpp
index 5e8ac9e..4f1127b 100644 (file)
--- a/dali-csharp-binder/src/gl-window.cpp
+++ b/dali-csharp-binder/src/gl-window.cpp
@@ -25,1978 +25,2764 @@
 #include <dali/integration-api/debug.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;
 
 /* TODO Adding signal definition */
-SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (Dali::GlWindow, bool) > const *self){
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal<void(Dali::GlWindow, bool)> const *self)
+{
   return self->Empty();
 }
-SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::GlWindow, bool) > const *self){
-return self->GetConnectionCount();
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal<void(Dali::GlWindow, bool)> const *self)
+{
+  return self->GetConnectionCount();
 }
-SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (Dali::GlWindow, bool) > *self,void (*func)(Dali::GlWindow, bool)){
-  self->Connect( func );
+SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal<void(Dali::GlWindow, bool)> *self, void (*func)(Dali::GlWindow, bool))
+{
+  self->Connect(func);
 }
-SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::GlWindow, bool) > *self,void (*func)(Dali::GlWindow, bool)){
-  self->Disconnect( func );
+SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal<void(Dali::GlWindow, bool)> *self, void (*func)(Dali::GlWindow, bool))
+{
+  self->Disconnect(func);
 }
-SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (Dali::GlWindow, bool) > *self, Dali::GlWindow arg, bool focusIn){
-  self->Emit( arg, focusIn );
+SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal<void(Dali::GlWindow, bool)> *self, Dali::GlWindow arg, bool focusIn)
+{
+  self->Emit(arg, focusIn);
 }
 
 /*ResizeSignal*/
-SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Empty(Dali::Signal< void (Dali::GlWindow::WindowSize) > const *self){
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Empty(Dali::Signal<void(Dali::GlWindow::WindowSize)> const *self)
+{
   return self->Empty();
 }
-SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::GlWindow::WindowSize) > const *self){
-return self->GetConnectionCount();
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__GetConnectionCount(Dali::Signal<void(Dali::GlWindow::WindowSize)> const *self)
+{
+  return self->GetConnectionCount();
 }
-SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Connect(Dali::Signal< void (Dali::GlWindow::WindowSize) > *self,void (*func)(Dali::GlWindow::WindowSize)){
-  self->Connect( func );
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Connect(Dali::Signal<void(Dali::GlWindow::WindowSize)> *self, void (*func)(Dali::GlWindow::WindowSize))
+{
+  self->Connect(func);
 }
-SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Disconnect(Dali::Signal< void (Dali::GlWindow::WindowSize) > *self,void (*func)(Dali::GlWindow::WindowSize)){
-  self->Disconnect( func );
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Disconnect(Dali::Signal<void(Dali::GlWindow::WindowSize)> *self, void (*func)(Dali::GlWindow::WindowSize))
+{
+  self->Disconnect(func);
 }
-SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Emit(Dali::Signal< void (Dali::GlWindow::WindowSize) > *self, Dali::GlWindow::WindowSize arg){
-  self->Emit( arg );
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Emit(Dali::Signal<void(Dali::GlWindow::WindowSize)> *self, Dali::GlWindow::WindowSize arg)
+{
+  self->Emit(arg);
 }
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/*Window binding*/
-SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_GlWindow_SWIGUpcast(Dali::GlWindow *jarg1) {
-  return (Dali::BaseHandle *)jarg1;
-}
-
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GlWindow_New__SWIG_0() {
-  void * jresult ;
-  Dali::GlWindow result ;
+  /*Window binding*/
+  SWIGEXPORT Dali::BaseHandle *SWIGSTDCALL CSharp_Dali_GlWindow_SWIGUpcast(Dali::GlWindow *jarg1)
   {
-    try {
-
-      result = Dali::GlWindow::New();
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-
-  jresult = new Dali::GlWindow((const Dali::GlWindow &)result);
-  return jresult;
-}
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GlWindow_New__SWIG_1( void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4 ) {
-  void * jresult ;
-  Dali::PositionSize arg1 ;
-  std::string *arg2 = 0 ;
-  std::string *arg3 = 0 ;
-  bool arg4 ;
-  Dali::PositionSize *argp1 ;
-  Dali::GlWindow result;
-
-  argp1 = (Dali::PositionSize *)jarg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
-    return 0;
+    return (Dali::BaseHandle *)jarg1;
   }
-  arg1 = *argp1;
-  if (!jarg2) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
-    return 0;
-  }
-  std::string arg2_str(jarg2);
-  arg2 = &arg2_str;
-  if (!jarg3) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
-    return 0;
-  }
-  std::string arg3_str(jarg3);
-  arg3 = &arg3_str;
-  arg4 = jarg4 ? true : false;
 
+  SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_New__SWIG_0()
   {
-    try {
-      result = Dali::GlWindow::New( arg1, (std::string const &)*arg2, (std::string const &)*arg3, arg4 );
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
+    void *jresult;
+    Dali::GlWindow result;
+    {
+      try
       {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-
-  jresult = new Dali::GlWindow((const Dali::GlWindow &)result);
-  return jresult;
-}
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GlWindow__SWIG_0() {
-  void * jresult ;
-  Dali::GlWindow *result = 0 ;
 
-  {
-    try {
-      result = (Dali::GlWindow *)new Dali::GlWindow();
-    } catch (std::out_of_range& e) {
+        result = Dali::GlWindow::New();
+      }
+      catch (std::out_of_range &e)
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
       {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
     }
-  }
 
-  jresult = (void *)result;
-  return jresult;
-}
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GlWindow(void * jarg1) {
-  Dali::GlWindow *arg1 = (Dali::GlWindow *) 0 ;
-
-  arg1 = (Dali::GlWindow *)jarg1;
-  {
-    try {
-      delete arg1;
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
-    }
+    jresult = new Dali::GlWindow((const Dali::GlWindow &)result);
+    return jresult;
   }
 
-}
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GlWindow__SWIG_1(void * jarg1) {
-  void * jresult ;
-  Dali::GlWindow *arg1 = 0 ;
-  Dali::GlWindow *result = 0 ;
-
-  arg1 = (Dali::GlWindow *)jarg1;
-  if (!arg1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GlWindow const & type is null", 0);
-    return 0;
-  }
+  SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_New__SWIG_1(void *jarg1, char *jarg2, char *jarg3, unsigned int jarg4)
   {
-    try {
-      result = (Dali::GlWindow *)new Dali::GlWindow((Dali::GlWindow const &)*arg1);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-
-  jresult = (void *)result;
-  return jresult;
-}
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GlWindow_Assign(void * jarg1, void * jarg2) {
-  void * jresult ;
-  Dali::GlWindow *arg1 = (Dali::GlWindow *) 0 ;
-  Dali::GlWindow *arg2 = 0 ;
-  Dali::GlWindow *result = 0 ;
-
-  arg1 = (Dali::GlWindow *)jarg1;
-  arg2 = (Dali::GlWindow *)jarg2;
-  if (!arg2) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GlWindow const & type is null", 0);
-    return 0;
-  }
+    void *jresult;
+    Dali::PositionSize arg1;
+    std::string *arg2 = 0;
+    std::string *arg3 = 0;
+    bool arg4;
+    Dali::PositionSize *argp1;
+    Dali::GlWindow result;
+
+    argp1 = (Dali::PositionSize *)jarg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
+      return 0;
+    }
+    arg1 = *argp1;
+    if (!jarg2)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+      return 0;
+    }
+    std::string arg2_str(jarg2);
+    arg2 = &arg2_str;
+    if (!jarg3)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+      return 0;
+    }
+    std::string arg3_str(jarg3);
+    arg3 = &arg3_str;
+    arg4 = jarg4 ? true : false;
+
+    {
+      try
+      {
+        result = Dali::GlWindow::New(arg1, (std::string const &)*arg2, (std::string const &)*arg3, arg4);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = new Dali::GlWindow((const Dali::GlWindow &)result);
+    return jresult;
+  }
+
+  SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlWindow__SWIG_0()
   {
-    try {
-      result = (Dali::GlWindow *) &(arg1)->operator =((Dali::GlWindow const &)*arg2);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-
-  jresult = (void *)result;
-  return jresult;
-}
+    void *jresult;
+    Dali::GlWindow *result = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetEglConfig(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, int jarg5) {
-  Dali::GlWindow *arg1 = (Dali::GlWindow *) 0 ;
-  bool arg2;
-  bool arg3;
-  int  arg4;
-  Dali::GlWindow::GlesVersion arg5;
-
-  arg1 = (Dali::GlWindow *)jarg1;
-  arg2 = (bool)jarg2;
-  arg3 = (bool)jarg3;
-  arg4 = jarg4;
-  arg5 = static_cast< Dali::GlWindow::GlesVersion >( jarg5 );
-  {
-    try {
-      (arg1)->SetEglConfig(arg2, arg3, arg4, arg5);
-    } catch (std::out_of_range& e) {
+    {
+      try
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
-    }
-  }
-
-}
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Raise(void * jarg1) {
-  Dali::GlWindow *arg1 = (Dali::GlWindow *) 0 ;
-
-  arg1 = (Dali::GlWindow *)jarg1;
-  {
-    try {
-      (arg1)->Raise();
-    } catch (std::out_of_range& e) {
+        result = (Dali::GlWindow *)new Dali::GlWindow();
+      }
+      catch (std::out_of_range &e)
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
       {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
     }
-  }
-
-}
-
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Lower(void * jarg1) {
-  Dali::GlWindow *arg1 = (Dali::GlWindow *) 0 ;
-
-  arg1 = (Dali::GlWindow *)jarg1;
-  {
-    try {
-      (arg1)->Lower();
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
-    }
+    jresult = (void *)result;
+    return jresult;
   }
 
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Activate(void * jarg1) {
-  Dali::GlWindow *arg1 = (Dali::GlWindow *) 0 ;
-
-  arg1 = (Dali::GlWindow *)jarg1;
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GlWindow(void *jarg1)
   {
-    try {
-      (arg1)->Activate();
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
+    Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
+
+    arg1 = (Dali::GlWindow *)jarg1;
+    {
+      try
+      {
+        delete arg1;
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlWindow__SWIG_1(void *jarg1)
+  {
+    void *jresult;
+    Dali::GlWindow *arg1 = 0;
+    Dali::GlWindow *result = 0;
+
+    arg1 = (Dali::GlWindow *)jarg1;
+    if (!arg1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GlWindow const & type is null", 0);
+      return 0;
+    }
+    {
+      try
+      {
+        result = (Dali::GlWindow *)new Dali::GlWindow((Dali::GlWindow const &)*arg1);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = (void *)result;
+    return jresult;
+  }
+
+  SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_Assign(void *jarg1, void *jarg2)
+  {
+    void *jresult;
+    Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
+    Dali::GlWindow *arg2 = 0;
+    Dali::GlWindow *result = 0;
+
+    arg1 = (Dali::GlWindow *)jarg1;
+    arg2 = (Dali::GlWindow *)jarg2;
+    if (!arg2)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GlWindow const & type is null", 0);
+      return 0;
+    }
+    {
+      try
+      {
+        result = (Dali::GlWindow *)&(arg1)->operator=((Dali::GlWindow const &)*arg2);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = (void *)result;
+    return jresult;
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetEglConfig(void *jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, int jarg5)
+  {
+    Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
+    bool arg2;
+    bool arg3;
+    int arg4;
+    Dali::GlWindow::GlesVersion arg5;
+
+    arg1 = (Dali::GlWindow *)jarg1;
+    arg2 = (bool)jarg2;
+    arg3 = (bool)jarg3;
+    arg4 = jarg4;
+    arg5 = static_cast<Dali::GlWindow::GlesVersion>(jarg5);
+    {
+      try
+      {
+        (arg1)->SetEglConfig(arg2, arg3, arg4, arg5);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Raise(void *jarg1)
+  {
+    Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
+
+    arg1 = (Dali::GlWindow *)jarg1;
+    {
+      try
+      {
+        (arg1)->Raise();
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Lower(void *jarg1)
+  {
+    Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
+
+    arg1 = (Dali::GlWindow *)jarg1;
+    {
+      try
+      {
+        (arg1)->Lower();
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Activate(void *jarg1)
+  {
+    Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
+
+    arg1 = (Dali::GlWindow *)jarg1;
+    {
+      try
+      {
+        (arg1)->Activate();
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Show(void *jarg1)
+  {
+    Dali::GlWindow arg1;
+    Dali::GlWindow *argp1;
+
+    argp1 = (Dali::GlWindow *)jarg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return;
+    }
+    arg1 = *argp1;
+    {
+      try
+      {
+        arg1.Show();
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Hide(void *jarg1)
+  {
+    Dali::GlWindow arg1;
+    Dali::GlWindow *argp1;
+
+    argp1 = (Dali::GlWindow *)jarg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return;
+    }
+    arg1 = *argp1;
+    {
+      try
+      {
+        arg1.Hide();
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetPositionSize(void *jarg1, void *jarg2)
+  {
+    Dali::GlWindow arg1;
+    Dali::GlWindow *argp1 = (Dali::GlWindow *)jarg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return;
+    }
+    arg1 = *argp1;
+    Dali::Rect<int> *positionSize = (Dali::Rect<int> *)jarg2;
+    if (!positionSize)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
+      return;
+    }
+    {
+      try
+      {
+        arg1.SetPositionSize(*positionSize);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_GetPositionSize(void *jarg1)
+  {
+    void *jresult;
+    Dali::GlWindow arg1;
+    Dali::GlWindow *argp1;
+    Dali::PositionSize result;
+
+    argp1 = (Dali::GlWindow *)jarg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return 0;
+    }
+    arg1 = *argp1;
+    {
+      try
+      {
+        result = arg1.GetPositionSize();
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = new Dali::PositionSize((const Dali::PositionSize &)result);
+    return jresult;
+  }
+
+  SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_GetSupportedAuxiliaryHintCount(void *jarg1)
+  {
+    unsigned int jresult;
+    Dali::GlWindow arg1;
+    Dali::GlWindow *argp1;
+    unsigned int result;
+
+    argp1 = (Dali::GlWindow *)jarg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return 0;
+    }
+    arg1 = *argp1;
+    {
+      try
+      {
+        result = (unsigned int)arg1.GetSupportedAuxiliaryHintCount();
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = result;
+    return jresult;
+  }
+
+  SWIGEXPORT char *SWIGSTDCALL CSharp_Dali_GlWindow_GetSupportedAuxiliaryHint(void *jarg1, unsigned int jarg2)
+  {
+    char *jresult;
+    Dali::GlWindow arg1;
+    unsigned int arg2;
+    Dali::GlWindow *argp1;
+    std::string result;
+
+    argp1 = (Dali::GlWindow *)jarg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return 0;
+    }
+    arg1 = *argp1;
+    arg2 = (unsigned int)jarg2;
+    {
+      try
+      {
+        result = arg1.GetSupportedAuxiliaryHint(arg2);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = SWIG_csharp_string_callback((&result)->c_str());
+    return jresult;
+  }
+
+  SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_AddAuxiliaryHint(void *jarg1, char *jarg2, char *jarg3)
+  {
+    unsigned int jresult;
+    Dali::GlWindow arg1;
+    std::string *arg2 = 0;
+    std::string *arg3 = 0;
+    Dali::GlWindow *argp1;
+    unsigned int result;
+
+    argp1 = (Dali::GlWindow *)jarg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return 0;
+    }
+    arg1 = *argp1;
+    if (!jarg2)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+      return 0;
+    }
+    std::string arg2_str(jarg2);
+    arg2 = &arg2_str;
+    if (!jarg3)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+      return 0;
+    }
+    std::string arg3_str(jarg3);
+    arg3 = &arg3_str;
+    {
+      try
+      {
+        result = (unsigned int)arg1.AddAuxiliaryHint((std::string const &)*arg2, (std::string const &)*arg3);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = result;
+
+    return jresult;
+  }
+
+  SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_RemoveAuxiliaryHint(void *jarg1, unsigned int jarg2)
+  {
+    unsigned int jresult;
+    Dali::GlWindow arg1;
+    unsigned int arg2;
+    Dali::GlWindow *argp1;
+    bool result;
+
+    argp1 = (Dali::GlWindow *)jarg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return 0;
+    }
+    arg1 = *argp1;
+    arg2 = (unsigned int)jarg2;
+    {
+      try
+      {
+        result = (bool)arg1.RemoveAuxiliaryHint(arg2);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = result;
+    return jresult;
+  }
+
+  SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_SetAuxiliaryHintValue(void *jarg1, unsigned int jarg2, char *jarg3)
+  {
+    unsigned int jresult;
+    Dali::GlWindow arg1;
+    unsigned int arg2;
+    std::string *arg3 = 0;
+    Dali::GlWindow *argp1;
+    bool result;
+
+    argp1 = (Dali::GlWindow *)jarg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return 0;
+    }
+    arg1 = *argp1;
+    arg2 = (unsigned int)jarg2;
+    if (!jarg3)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+      return 0;
+    }
+    std::string arg3_str(jarg3);
+    arg3 = &arg3_str;
+    {
+      try
+      {
+        result = (bool)arg1.SetAuxiliaryHintValue(arg2, (std::string const &)*arg3);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = result;
+
+    //argout typemap for const std::string&
+
+    return jresult;
+  }
+
+  SWIGEXPORT char *SWIGSTDCALL CSharp_Dali_GlWindow_GetAuxiliaryHintValue(void *jarg1, unsigned int jarg2)
+  {
+    char *jresult;
+    Dali::GlWindow arg1;
+    unsigned int arg2;
+    Dali::GlWindow *argp1;
+    std::string result;
+
+    argp1 = (Dali::GlWindow *)jarg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return 0;
+    }
+    arg1 = *argp1;
+    arg2 = (unsigned int)jarg2;
+    {
+      try
+      {
+        result = arg1.GetAuxiliaryHintValue(arg2);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = SWIG_csharp_string_callback((&result)->c_str());
+    return jresult;
+  }
+
+  SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_GetAuxiliaryHintId(void *jarg1, char *jarg2)
+  {
+    unsigned int jresult;
+    Dali::GlWindow arg1;
+    std::string *arg2 = 0;
+    Dali::GlWindow *argp1;
+    unsigned int result;
+
+    argp1 = (Dali::GlWindow *)jarg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return 0;
+    }
+    arg1 = *argp1;
+    if (!jarg2)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+      return 0;
+    }
+    std::string arg2_str(jarg2);
+    arg2 = &arg2_str;
+    {
+      try
+      {
+        result = (unsigned int)arg1.GetAuxiliaryHintId((std::string const &)*arg2);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = result;
+
+    //argout typemap for const std::string&
+
+    return jresult;
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetInputRegion(void *jarg1, void *jarg2)
+  {
+    Dali::GlWindow arg1;
+    Dali::Rect<int> *arg2 = 0;
+    Dali::GlWindow *argp1;
+
+    argp1 = (Dali::GlWindow *)jarg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return;
+    }
+    arg1 = *argp1;
+    arg2 = (Dali::Rect<int> *)jarg2;
+    if (!arg2)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
+      return;
+    }
+    {
+      try
+      {
+        arg1.SetInputRegion((Dali::Rect<int> const &)*arg2);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetOpaqueState(void *jarg1, unsigned int jarg2)
+  {
+    Dali::GlWindow arg1;
+    bool arg2;
+    Dali::GlWindow *argp1;
+
+    argp1 = (Dali::GlWindow *)jarg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return;
+    }
+    arg1 = *argp1;
+    arg2 = jarg2 ? true : false;
+    {
+      try
+      {
+        arg1.SetOpaqueState(arg2);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_IsOpaqueState(void *jarg1)
+  {
+    unsigned int jresult;
+    Dali::GlWindow arg1;
+    Dali::GlWindow *argp1;
+    bool result;
+
+    argp1 = (Dali::GlWindow *)jarg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return 0;
+    }
+    arg1 = *argp1;
+    {
+      try
+      {
+        result = (bool)arg1.IsOpaqueState();
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = result;
+    return jresult;
+  }
+
+  SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GlWindow_GetCurrentOrientation(void *jarg1)
+  {
+    int jresult;
+    Dali::WindowOrientation result;
+    Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
+    arg1 = (Dali::GlWindow *)jarg1;
+    if (!arg1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return 0;
+    }
+    {
+      try
+      {
+        result = (arg1)->GetCurrentOrientation();
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = (int)result;
+    return jresult;
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetAvailableOrientations(void *jarg1, void *jarg2, int jarg3)
+  {
+    Dali::GlWindow *arg1 = (Dali::GlWindow *)jarg1;
+    if (!arg1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return;
+    }
+    Dali::Property::Array *arg2 = (static_cast<Dali::Property::Array *>(jarg2));
+    unsigned int count = static_cast<unsigned int>(jarg3);
+
+    Dali::Vector<Dali::WindowOrientation> angles;
+    angles.Resize(count);
+    for (Dali::Property::Array::SizeType i = 0; i < count; ++i)
+    {
+      int angle = arg2->GetElementAt(i).Get<int>();
+      angles[i] = static_cast<Dali::WindowOrientation>(angle);
+    }
+    {
+      try
+      {
+        arg1->SetAvailableOrientations(angles);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetPreferredOrientation(void *jarg1, int jarg2)
+  {
+    Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
+    Dali::WindowOrientation arg2;
+    int angle = jarg2;
+
+    arg1 = (Dali::GlWindow *)jarg1;
+    arg2 = (Dali::WindowOrientation)angle;
+    {
+      try
+      {
+        (arg1)->SetPreferredOrientation(arg2);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_RegisterGlCallback(void *jarg1, void *initCallback, int *RenderFrameCallback, void *terminateCallback)
+  {
+    Dali::GlWindow *argp1 = (Dali::GlWindow *)jarg1;
+    void (*initCB)() = (void (*)())initCallback;
+    int (*renderFrameCB)() = (int (*)())RenderFrameCallback;
+    void (*terminateCB)() = (void (*)())terminateCallback;
+
+    if (!argp1 || !initCB || !renderFrameCB || !terminateCB)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null", 0);
+      return;
+    }
+    Dali::GlWindow arg1 = *argp1;
+    try
+    {
+      arg1.RegisterGlCallback(Dali::MakeCallback(initCB), Dali::MakeCallback(renderFrameCB), Dali::MakeCallback(terminateCB));
+    }
+    catch (std::out_of_range &e)
+    {
+      SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+      return;
+    }
+    catch (std::exception &e)
+    {
+      SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+      return;
+    }
+    catch (Dali::DaliException e)
+    {
+      SWIG_CSharpException(SWIG_UnknownError, e.condition);
+      return;
+    }
+    catch (...)
+    {
+      SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+      return;
     }
   }
 
-}
-
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_RenderOnce(void *jarg1)
+  {
+    Dali::GlWindow *argp1 = (Dali::GlWindow *)jarg1;
+    Dali::GlWindow arg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return;
+    }
+    arg1 = *argp1;
+    {
+      try
+      {
+        arg1.RenderOnce();
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetRenderingMode(void *jarg1)
+  {
+    int jresult;
+    Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
+    Dali::GlWindow::RenderingMode result;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Show(void * jarg1) {
-  Dali::GlWindow arg1 ;
-  Dali::GlWindow *argp1 ;
+    arg1 = (Dali::GlWindow *)jarg1;
+    if (!arg1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return 0;
+    }
 
-  argp1 = (Dali::GlWindow *)jarg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return ;
-  }
-  arg1 = *argp1;
-  {
-    try {
-      arg1.Show();
-    } catch (std::out_of_range& e) {
+    {
+      try
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
+        result = (Dali::GlWindow::RenderingMode)(arg1)->GetRenderingMode();
+      }
+      catch (std::out_of_range &e)
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
       {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
     }
-  }
 
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Hide(void * jarg1) {
-  Dali::GlWindow arg1 ;
-  Dali::GlWindow *argp1 ;
-
-  argp1 = (Dali::GlWindow *)jarg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return ;
+    jresult = (int)result;
+    return jresult;
   }
-  arg1 = *argp1;
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetRenderingMode(void *jarg1, int jarg2)
+  {
+    Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
+    Dali::GlWindow::RenderingMode arg2;
+
+    arg1 = (Dali::GlWindow *)jarg1;
+    if (!arg1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return;
+    }
+    arg2 = (Dali::GlWindow::RenderingMode)jarg2;
+    {
+      try
+      {
+        (arg1)->SetRenderingMode(arg2);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  /* Signals binding*/
+
+  /* Focus change binding */
+  SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_FocusChangedSignal(void *jarg1)
+  {
+    void *jresult;
+    Dali::GlWindow arg1;
+    Dali::GlWindow *argp1;
+    Dali::GlWindow::FocusChangeSignalType *result = 0;
+
+    argp1 = (Dali::GlWindow *)jarg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return 0;
+    }
+    arg1 = *argp1;
+    {
+      try
+      {
+        result = (Dali::GlWindow::FocusChangeSignalType *)&arg1.FocusChangeSignal();
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = (void *)result;
+    return jresult;
+  }
+
+  SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Empty(void *jarg1)
+  {
+    unsigned int jresult;
+    Dali::Signal<void(Dali::GlWindow, bool)> *arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)0;
+    bool result;
+
+    arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)jarg1;
+    {
+      try
+      {
+        result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal<void(Dali::GlWindow, bool)> const *)arg1);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = result;
+    return jresult;
+  }
+
+  SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_GetConnectionCount(void *jarg1)
   {
-    try {
-      arg1.Hide();
-    } catch (std::out_of_range& e) {
+    unsigned long jresult;
+    Dali::Signal<void(Dali::GlWindow, bool)> *arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)0;
+    std::size_t result;
+
+    arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)jarg1;
+    {
+      try
+      {
+        result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::GlWindow, bool)> const *)arg1);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = (unsigned long)result;
+    return jresult;
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Connect(void *jarg1, void *jarg2)
+  {
+    Dali::Signal<void(Dali::GlWindow, bool)> *arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)0;
+    void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool))0;
+
+    arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)jarg1;
+    arg2 = (void (*)(Dali::GlWindow, bool))jarg2;
+    {
+      try
+      {
+        Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1, arg2);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Disconnect(void *jarg1, void *jarg2)
+  {
+    Dali::Signal<void(Dali::GlWindow, bool)> *arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)0;
+    void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool))0;
+
+    arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)jarg1;
+    arg2 = (void (*)(Dali::GlWindow, bool))jarg2;
+    {
+      try
+      {
+        Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1, arg2);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Emit(void *jarg1, void *jarg2, unsigned int jarg3)
+  {
+    Dali::Signal<void(Dali::GlWindow, bool)> *arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)jarg1;
+    Dali::GlWindow *arg2 = (Dali::GlWindow *)jarg2;
+    bool arg3 = jarg3 ? true : false;
+    ;
+
+    if (arg1 == nullptr || arg2 == nullptr)
+    {
+      DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr");
+      return;
+    }
+
+    {
+      try
+      {
+        Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1, *arg2, arg3);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlWindow_FocusSignalType()
+  {
+    void *jresult;
+    Dali::Signal<void(Dali::GlWindow, bool)> *result = 0;
+
+    {
+      try
+      {
+        result = (Dali::Signal<void(Dali::GlWindow, bool)> *)new Dali::Signal<void(Dali::GlWindow, bool)>();
+      }
+      catch (std::out_of_range &e)
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
       {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
     }
-  }
-
-}
-
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetPositionSize(void* jarg1, void* jarg2)
-{
-  Dali::GlWindow arg1 ;
-  Dali::GlWindow *argp1 = (Dali::GlWindow*)jarg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return ;
-  }
-  arg1 = *argp1;
-  Dali::Rect<int>* positionSize = (Dali::Rect<int>*)jarg2;
-  if (!positionSize) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
-    return ;
+    jresult = (void *)result;
+    return jresult;
   }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GlWindow_FocusSignalType(void *jarg1)
+  {
+    Dali::Signal<void(Dali::GlWindow, bool)> *arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)0;
+
+    arg1 = (Dali::Signal<void(Dali::GlWindow, bool)> *)jarg1;
+    {
+      try
+      {
+        delete arg1;
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  /* Touch Event Binding */
+  SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_TouchSignal(void *jarg1)
   {
-    try {
-      arg1.SetPositionSize(*positionSize);
-    } catch (std::out_of_range& e) {
+    void *jresult;
+    Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
+    Dali::GlWindow::TouchEventSignalType *result = 0;
+
+    arg1 = (Dali::GlWindow *)jarg1;
+    {
+      try
+      {
+        result = (Dali::GlWindow::TouchEventSignalType *)&(arg1->TouchedSignal());
+      }
+      catch (std::out_of_range &e)
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
       {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
     }
-  }
-
-}
 
+    jresult = (void *)result;
+    return jresult;
+  }
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GlWindow_GetPositionSize(void * jarg1) {
-  void * jresult ;
-  Dali::GlWindow arg1 ;
-  Dali::GlWindow *argp1 ;
-  Dali::PositionSize result;
+  /*Key Event Binding */
 
-  argp1 = (Dali::GlWindow *)jarg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return 0;
-  }
-  arg1 = *argp1;
+  SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_KeyEventSignal(void *jarg1)
   {
-    try {
-      result = arg1.GetPositionSize();
-    } catch (std::out_of_range& e) {
+    void *jresult;
+    Dali::GlWindow *arg1 = (Dali::GlWindow *)0;
+    Dali::GlWindow::KeyEventSignalType *result = 0;
+
+    arg1 = (Dali::GlWindow *)jarg1;
+    {
+      try
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
+        result = (Dali::GlWindow::KeyEventSignalType *)&(arg1->KeyEventSignal());
+      }
+      catch (std::out_of_range &e)
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
       {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
     }
+
+    jresult = (void *)result;
+    return jresult;
   }
 
-  jresult = new Dali::PositionSize((const Dali::PositionSize &)result);
-  return jresult;
-}
+  /* visibility change */
 
+  SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal(void *jarg1)
+  {
+    Dali::GlWindow *arg1 = (Dali::GlWindow *)jarg1;
+    Dali::GlWindow::VisibilityChangedSignalType *result = 0;
+
+    {
+      try
+      {
+        result = (Dali::GlWindow::VisibilityChangedSignalType *)&(arg1->VisibilityChangedSignal());
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+    return (void *)result;
+  }
+
+  SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_GetConnectionCount(void *jarg1)
+  {
+    unsigned int result;
+    Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1;
 
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_GetSupportedAuxiliaryHintCount(void * jarg1) {
-  unsigned int jresult ;
-  Dali::GlWindow arg1 ;
-  Dali::GlWindow *argp1 ;
-  unsigned int result;
+    if (arg1 == nullptr)
+    {
+      DALI_LOG_ERROR("[ERR] arg1 == nullptr");
+      return 0;
+    }
 
-  argp1 = (Dali::GlWindow *)jarg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return 0;
-  }
-  arg1 = *argp1;
-  {
-    try {
-      result = (unsigned int)arg1.GetSupportedAuxiliaryHintCount();
-    } catch (std::out_of_range& e) {
+    {
+      try
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
+        result = arg1->GetConnectionCount();
+      }
+      catch (std::out_of_range &e)
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
       {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
     }
+    return result;
   }
 
-  jresult = result;
-  return jresult;
-}
-
-
-SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GlWindow_GetSupportedAuxiliaryHint(void * jarg1, unsigned int jarg2) {
-  char * jresult ;
-  Dali::GlWindow arg1 ;
-  unsigned int arg2 ;
-  Dali::GlWindow *argp1 ;
-  std::string result;
-
-  argp1 = (Dali::GlWindow *)jarg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return 0;
-  }
-  arg1 = *argp1;
-  arg2 = (unsigned int)jarg2;
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_Connect(void *jarg1, void *jarg2)
   {
-    try {
-      result = arg1.GetSupportedAuxiliaryHint(arg2);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
+    Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1;
+    void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool))jarg2;
+
+    if (arg1 == nullptr)
+    {
+      DALI_LOG_ERROR("[ERR] arg1 == nullptr");
+      return;
+    }
+
+    {
+      try
+      {
+        arg1->Connect(arg2);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
     }
+    return;
   }
 
-  jresult = SWIG_csharp_string_callback((&result)->c_str());
-  return jresult;
-}
-
-
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_AddAuxiliaryHint(void * jarg1, char * jarg2, char * jarg3) {
-  unsigned int jresult ;
-  Dali::GlWindow arg1 ;
-  std::string *arg2 = 0 ;
-  std::string *arg3 = 0 ;
-  Dali::GlWindow *argp1 ;
-  unsigned int result;
-
-  argp1 = (Dali::GlWindow *)jarg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return 0;
-  }
-  arg1 = *argp1;
-  if (!jarg2) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
-    return 0;
-  }
-  std::string arg2_str(jarg2);
-  arg2 = &arg2_str;
-  if (!jarg3) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
-    return 0;
-  }
-  std::string arg3_str(jarg3);
-  arg3 = &arg3_str;
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_Disconnect(void *jarg1, void *jarg2)
   {
-    try {
-      result = (unsigned int)arg1.AddAuxiliaryHint((std::string const &)*arg2,(std::string const &)*arg3);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
+    Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1;
+    void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool))jarg2;
+
+    if (arg1 == nullptr)
+    {
+      DALI_LOG_ERROR("[ERR] arg1 == nullptr");
+      return;
+    }
+
+    {
+      try
+      {
+        arg1->Disconnect(arg2);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
     }
+    return;
   }
 
-  jresult = result;
-
-  return jresult;
-}
-
-
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_RemoveAuxiliaryHint(void * jarg1, unsigned int jarg2) {
-  unsigned int jresult ;
-  Dali::GlWindow arg1 ;
-  unsigned int arg2 ;
-  Dali::GlWindow *argp1 ;
-  bool result;
-
-  argp1 = (Dali::GlWindow *)jarg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return 0;
-  }
-  arg1 = *argp1;
-  arg2 = (unsigned int)jarg2;
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_Emit(void *jarg1, void *jarg2, bool jarg3)
   {
-    try {
-      result = (bool)arg1.RemoveAuxiliaryHint(arg2);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
+    Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1;
+    Dali::GlWindow *arg2 = (Dali::GlWindow *)jarg2;
+    bool arg3 = jarg3;
+
+    if (arg1 == nullptr || arg2 == nullptr)
+    {
+      DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr");
+      return;
+    }
+
+    {
+      try
+      {
+        arg1->Emit(*arg2, arg3);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
     }
+    return;
   }
 
-  jresult = result;
-  return jresult;
-}
-
-
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_SetAuxiliaryHintValue(void * jarg1, unsigned int jarg2, char * jarg3) {
-  unsigned int jresult ;
-  Dali::GlWindow arg1 ;
-  unsigned int arg2 ;
-  std::string *arg3 = 0 ;
-  Dali::GlWindow *argp1 ;
-  bool result;
-
-  argp1 = (Dali::GlWindow *)jarg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return 0;
-  }
-  arg1 = *argp1;
-  arg2 = (unsigned int)jarg2;
-  if (!jarg3) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
-    return 0;
-  }
-  std::string arg3_str(jarg3);
-  arg3 = &arg3_str;
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_delete(void *jarg1)
   {
-    try {
-      result = (bool)arg1.SetAuxiliaryHintValue(arg2,(std::string const &)*arg3);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
+    Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1;
+
+    {
+      try
+      {
+        delete arg1;
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
     }
+    return;
   }
 
-  jresult = result;
-
-  //argout typemap for const std::string&
-
-  return jresult;
-}
-
-
-SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GlWindow_GetAuxiliaryHintValue(void * jarg1, unsigned int jarg2) {
-  char * jresult ;
-  Dali::GlWindow arg1 ;
-  unsigned int arg2 ;
-  Dali::GlWindow *argp1 ;
-  std::string result;
-
-  argp1 = (Dali::GlWindow *)jarg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return 0;
-  }
-  arg1 = *argp1;
-  arg2 = (unsigned int)jarg2;
+  /*ResizeSignal binding*/
+  SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal(void *jarg1)
+  {
+    void *jresult;
+    Dali::GlWindow arg1;
+    Dali::GlWindow *argp1;
+    Dali::GlWindow::ResizeSignalType *result = 0;
+
+    argp1 = (Dali::GlWindow *)jarg1;
+    if (!argp1)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
+      return 0;
+    }
+    arg1 = *argp1;
+    {
+      try
+      {
+        result = (Dali::GlWindow::ResizeSignalType *)&arg1.ResizeSignal();
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = (void *)result;
+    return jresult;
+  }
+
+  SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Empty(void *jarg1)
+  {
+    unsigned int jresult;
+    Dali::Signal<void(Dali::GlWindow::WindowSize)> *arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)0;
+    bool result;
+
+    arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)jarg1;
+    {
+      try
+      {
+        result = (bool)Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Empty((Dali::Signal<void(Dali::GlWindow::WindowSize)> const *)arg1);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = result;
+    return jresult;
+  }
+
+  SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_GetConnectionCount(void *jarg1)
+  {
+    unsigned long jresult;
+    Dali::Signal<void(Dali::GlWindow::WindowSize)> *arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)0;
+    std::size_t result;
+
+    arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)jarg1;
+    {
+      try
+      {
+        result = Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::GlWindow::WindowSize)> const *)arg1);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
+    }
+
+    jresult = (unsigned long)result;
+    return jresult;
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Connect(void *jarg1, void *jarg2)
+  {
+    Dali::Signal<void(Dali::GlWindow::WindowSize)> *arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)0;
+    void (*arg2)(Dali::GlWindow::WindowSize) = (void (*)(Dali::GlWindow::WindowSize))0;
+
+    arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)jarg1;
+    arg2 = (void (*)(Dali::GlWindow::WindowSize))jarg2;
+    {
+      try
+      {
+        Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Connect(arg1, arg2);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Disconnect(void *jarg1, void *jarg2)
+  {
+    Dali::Signal<void(Dali::GlWindow::WindowSize)> *arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)0;
+    void (*arg2)(Dali::GlWindow::WindowSize) = (void (*)(Dali::GlWindow::WindowSize))0;
+
+    arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)jarg1;
+    arg2 = (void (*)(Dali::GlWindow::WindowSize))jarg2;
+    {
+      try
+      {
+        Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Disconnect(arg1, arg2);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Emit(void *jarg1, void *jarg2)
+  {
+    Dali::Signal<void(Dali::GlWindow::WindowSize)> *arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)0;
+    Dali::GlWindow::WindowSize arg2;
+    Dali::GlWindow::WindowSize *argp2;
+
+    arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)jarg1;
+    if (arg1 == nullptr)
+    {
+      DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr");
+      return;
+    }
+    argp2 = (Dali::GlWindow::WindowSize *)jarg2;
+    if (!argp2)
+    {
+      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow::WindowSize", 0);
+      return;
+    }
+    arg2 = *argp2;
+    {
+      try
+      {
+        Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Emit(arg1, arg2);
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
+    }
+  }
+
+  SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlWindow_ResizedSignal()
   {
-    try {
-      result = arg1.GetAuxiliaryHintValue(arg2);
-    } catch (std::out_of_range& e) {
+    void *jresult;
+    Dali::Signal<void(Dali::GlWindow::WindowSize)> *result = 0;
+
+    {
+      try
+      {
+        result = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)new Dali::Signal<void(Dali::GlWindow::WindowSize)>();
+      }
+      catch (std::out_of_range &e)
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (std::exception &e)
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return 0;
+        };
+      }
+      catch (Dali::DaliException e)
       {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return 0;
+        };
+      }
+      catch (...)
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return 0;
+        };
+      }
     }
-  }
-
-  jresult = SWIG_csharp_string_callback((&result)->c_str());
-  return jresult;
-}
-
 
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_GetAuxiliaryHintId(void * jarg1, char * jarg2) {
-  unsigned int jresult ;
-  Dali::GlWindow arg1 ;
-  std::string *arg2 = 0 ;
-  Dali::GlWindow *argp1 ;
-  unsigned int result;
-
-  argp1 = (Dali::GlWindow *)jarg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return 0;
-  }
-  arg1 = *argp1;
-  if (!jarg2) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
-    return 0;
+    jresult = (void *)result;
+    return jresult;
   }
-  std::string arg2_str(jarg2);
-  arg2 = &arg2_str;
+
+  SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_delete_ResizedSignal(void *jarg1)
   {
-    try {
-      result = (unsigned int)arg1.GetAuxiliaryHintId((std::string const &)*arg2);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
+    Dali::Signal<void(Dali::GlWindow::WindowSize)> *arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)0;
+
+    arg1 = (Dali::Signal<void(Dali::GlWindow::WindowSize)> *)jarg1;
+    {
+      try
+      {
+        delete arg1;
+      }
+      catch (std::out_of_range &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (std::exception &e)
+      {
+        {
+          SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));
+          return;
+        };
+      }
+      catch (Dali::DaliException e)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, e.condition);
+          return;
+        };
+      }
+      catch (...)
+      {
+        {
+          SWIG_CSharpException(SWIG_UnknownError, "unknown error");
+          return;
+        };
+      }
     }
   }
 
-  jresult = result;
-
-  //argout typemap for const std::string&
-
-  return jresult;
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetInputRegion(void * jarg1, void * jarg2) {
-  Dali::GlWindow arg1 ;
-  Dali::Rect< int > *arg2 = 0 ;
-  Dali::GlWindow *argp1 ;
-
-  argp1 = (Dali::GlWindow *)jarg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return ;
-  }
-  arg1 = *argp1;
-  arg2 = (Dali::Rect< int > *)jarg2;
-  if (!arg2) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
-    return ;
-  }
-  {
-    try {
-      arg1.SetInputRegion((Dali::Rect< int > const &)*arg2);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
-    }
-  }
-
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetOpaqueState(void * jarg1, unsigned int jarg2) {
-  Dali::GlWindow arg1 ;
-  bool arg2 ;
-  Dali::GlWindow *argp1 ;
-
-  argp1 = (Dali::GlWindow *)jarg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return ;
-  }
-  arg1 = *argp1;
-  arg2 = jarg2 ? true : false;
-  {
-    try {
-      arg1.SetOpaqueState(arg2);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
-    }
-  }
-
-}
-
-
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_IsOpaqueState(void * jarg1) {
-  unsigned int jresult ;
-  Dali::GlWindow arg1 ;
-  Dali::GlWindow *argp1 ;
-  bool result;
-
-  argp1 = (Dali::GlWindow *)jarg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return 0;
-  }
-  arg1 = *argp1;
-  {
-    try {
-      result = (bool)arg1.IsOpaqueState();
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-
-  jresult = result;
-  return jresult;
-}
-
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GlWindow_GetCurrentOrientation(void * jarg1) {
-  int jresult ;
-  Dali::WindowOrientation result;
-  Dali::GlWindow *arg1 = (Dali::GlWindow *) 0 ;
-  arg1 = (Dali::GlWindow *)jarg1;
-  if (!arg1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return 0;
-  }
-  {
-    try {
-      result = (arg1)->GetCurrentOrientation();
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-
-  jresult = (int)result;
-  return jresult;
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetAvailableOrientations(void * jarg1, void* jarg2, int jarg3) {
-  Dali::GlWindow* arg1 = (Dali::GlWindow*)jarg1;
-  if (!arg1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return;
-  }
-  Dali::Property::Array* arg2 = (static_cast<Dali::Property::Array *>( jarg2 ));
-  unsigned int count = static_cast< unsigned int >( jarg3 );
-
-  Dali::Vector< Dali::WindowOrientation > angles;
-  angles.Resize( count );
-  for( Dali::Property::Array::SizeType i = 0; i < count; ++i)
-  {
-    int angle = arg2->GetElementAt(i).Get<int>();
-    angles[i] = static_cast< Dali::WindowOrientation >( angle );
-  }
-  {
-    try {
-      arg1->SetAvailableOrientations( angles );
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
-      };
-    }
-  }
-
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetPreferredOrientation(void * jarg1, int jarg2) {
-  Dali::GlWindow *arg1 = (Dali::GlWindow *) 0 ;
-  Dali::WindowOrientation arg2 ;
-  int angle = jarg2;
-
-  arg1 = (Dali::GlWindow *)jarg1;
-  arg2 = (Dali::WindowOrientation)angle;
-  {
-    try {
-      (arg1)->SetPreferredOrientation(arg2);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
-    }
-  }
-
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_RegisterGlCallback( void* jarg1, void* initCallback, int* RenderFrameCallback, void* terminateCallback )
-{
-  Dali::GlWindow* argp1 = (Dali::GlWindow*)jarg1;
-  void (*initCB)() = (void (*)())initCallback;
-  int (*renderFrameCB)() = (int (*)())RenderFrameCallback;
-  void (*terminateCB)() = (void (*)())terminateCallback;
-
-  if( !argp1 || !initCB || !renderFrameCB || !terminateCB )
-  {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null", 0);
-    return;
-  }
-  Dali::GlWindow arg1 = *argp1;
-  try
-  {
-    arg1.RegisterGlCallback( Dali::MakeCallback( initCB ), Dali::MakeCallback( renderFrameCB ), Dali::MakeCallback( terminateCB ) );
-  }
-  catch( std::out_of_range& e )
-  {
-    SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
-    return;
-  }
-  catch( std::exception& e )
-  {
-    SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
-    return;
-  }
-  catch( Dali::DaliException e )
-  {
-    SWIG_CSharpException(SWIG_UnknownError, e.condition);
-    return;
-  }
-  catch(...)
-  {
-    SWIG_CSharpException(SWIG_UnknownError, "unknown error");
-    return;
-  }
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_RenderOnce(void* jarg1)
-{
-  Dali::GlWindow* argp1  = (Dali::GlWindow*)jarg1;
-  Dali::GlWindow arg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return ;
-  }
-  arg1 = *argp1;
-  {
-    try {
-      arg1.RenderOnce();
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
-    }
-  }
-
-}
-
-
-/* Signals binding*/
-
-/* Focus change binding */
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GlWindow_FocusChangedSignal(void * jarg1) {
-  void * jresult ;
-  Dali::GlWindow arg1 ;
-  Dali::GlWindow *argp1 ;
-  Dali::GlWindow::FocusChangeSignalType *result = 0 ;
-
-  argp1 = (Dali::GlWindow *)jarg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return 0;
-  }
-  arg1 = *argp1;
-  {
-    try {
-      result = (Dali::GlWindow::FocusChangeSignalType*)&arg1.FocusChangeSignal();
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-
-  jresult = (void *)result;
-  return jresult;
-}
-
-
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Empty(void * jarg1) {
-  unsigned int jresult ;
-  Dali::Signal< void (Dali::GlWindow, bool) > *arg1 = (Dali::Signal< void (Dali::GlWindow, bool) > *) 0 ;
-  bool result;
-
-  arg1 = (Dali::Signal< void (Dali::GlWindow, bool) > *)jarg1;
-  {
-    try {
-      result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (Dali::GlWindow, bool) > const *)arg1);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-
-  jresult = result;
-  return jresult;
-}
-
-
-SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_GetConnectionCount(void * jarg1) {
-  unsigned long jresult ;
-  Dali::Signal< void (Dali::GlWindow, bool) > *arg1 = (Dali::Signal< void (Dali::GlWindow, bool) > *) 0 ;
-  std::size_t result;
-
-  arg1 = (Dali::Signal< void (Dali::GlWindow, bool) > *)jarg1;
-  {
-    try {
-      result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::GlWindow, bool) > const *)arg1);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-
-  jresult = (unsigned long)result;
-  return jresult;
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Connect(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::GlWindow, bool) > *arg1 = (Dali::Signal< void (Dali::GlWindow, bool) > *) 0 ;
-  void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool)) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::GlWindow, bool) > *)jarg1;
-  arg2 = (void (*)(Dali::GlWindow, bool))jarg2;
-  {
-    try {
-      Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
-    }
-  }
-
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Disconnect(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::GlWindow, bool) > *arg1 = (Dali::Signal< void (Dali::GlWindow, bool) > *) 0 ;
-  void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool)) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::GlWindow, bool) > *)jarg1;
-  arg2 = (void (*)(Dali::GlWindow, bool))jarg2;
-  {
-    try {
-      Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
-    }
-  }
-
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Emit(void * jarg1, void* jarg2, unsigned int jarg3) {
-  Dali::Signal< void (Dali::GlWindow, bool) > *arg1 = (Dali::Signal< void (Dali::GlWindow, bool) > *)jarg1;
-  Dali::GlWindow* arg2 = (Dali::GlWindow*)jarg2;
-  bool arg3 = jarg3 ? true : false;;
-
-  if (arg1 == nullptr || arg2 == nullptr) {
-    DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr");
-    return;
-  }
-
-  {
-    try {
-      Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,*arg2,arg3);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
-    }
-  }
-
-}
-
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GlWindow_FocusSignalType() {
-  void * jresult ;
-  Dali::Signal< void (Dali::GlWindow, bool) > *result = 0 ;
-
-  {
-    try {
-      result = (Dali::Signal< void (Dali::GlWindow, bool) > *)new Dali::Signal< void (Dali::GlWindow, bool) >();
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-
-  jresult = (void *)result;
-  return jresult;
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GlWindow_FocusSignalType(void * jarg1) {
-  Dali::Signal< void (Dali::GlWindow, bool) > *arg1 = (Dali::Signal< void (Dali::GlWindow, bool) > *) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::GlWindow, bool) > *)jarg1;
-  {
-    try {
-      delete arg1;
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
-    }
-  }
-
-}
-
-/* Touch Event Binding */
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GlWindow_TouchSignal(void * jarg1) {
-  void * jresult ;
-  Dali::GlWindow *arg1 = (Dali::GlWindow *) 0 ;
-  Dali::GlWindow::TouchEventSignalType *result = 0 ;
-
-  arg1 = (Dali::GlWindow *)jarg1;
-  {
-    try {
-      result = (Dali::GlWindow::TouchEventSignalType *) &(arg1->TouchedSignal());
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-
-  jresult = (void *)result;
-  return jresult;
-}
-
-
-/*Key Event Binding */
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GlWindow_KeyEventSignal(void * jarg1) {
-  void * jresult ;
-  Dali::GlWindow *arg1 = (Dali::GlWindow *) 0 ;
-  Dali::GlWindow::KeyEventSignalType *result = 0 ;
-
-  arg1 = (Dali::GlWindow *)jarg1;
-  {
-    try {
-      result = (Dali::GlWindow::KeyEventSignalType *) &(arg1->KeyEventSignal());
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-
-  jresult = (void *)result;
-  return jresult;
-}
-
-
-
-/* visibility change */
-
-SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal(void* jarg1) {
-  Dali::GlWindow* arg1 = (Dali::GlWindow*) jarg1;
-  Dali::GlWindow::VisibilityChangedSignalType* result = 0;
-
-  {
-    try {
-      result = (Dali::GlWindow::VisibilityChangedSignalType*) &( arg1->VisibilityChangedSignal() );
-    }
-    catch (std::out_of_range & e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    }
-    catch (std::exception & e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    }
-    catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    }
-    catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-  return (void*)result;
-}
-
-
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_GetConnectionCount(void* jarg1) {
-  unsigned int result;
-  Dali::GlWindow::VisibilityChangedSignalType* arg1 = (Dali::GlWindow::VisibilityChangedSignalType *) jarg1;
-
-  if (arg1 == nullptr) {
-    DALI_LOG_ERROR("[ERR] arg1 == nullptr");
-    return 0;
-  }
-
-  {
-    try {
-      result = arg1->GetConnectionCount();
-    }
-    catch (std::out_of_range & e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    }
-    catch (std::exception & e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    }
-    catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    }
-    catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-  return result;
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_Connect(void* jarg1, void* jarg2) {
-  Dali::GlWindow::VisibilityChangedSignalType* arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1;
-  void (*arg2)(Dali::GlWindow, bool) = ( void (*)(Dali::GlWindow, bool) )jarg2;
-
-  if (arg1 == nullptr) {
-    DALI_LOG_ERROR("[ERR] arg1 == nullptr");
-    return ;
-  }
-
-  {
-    try {
-      arg1->Connect(arg2);
-    }
-    catch (std::out_of_range & e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
-      };
-    }
-    catch (std::exception & e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
-      };
-    }
-    catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
-      };
-    }
-    catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
-      };
-    }
-  }
-  return ;
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_Disconnect(void* jarg1, void* jarg2) {
-  Dali::GlWindow::VisibilityChangedSignalType* arg1 = (Dali::GlWindow::VisibilityChangedSignalType*)jarg1;
-  void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool))jarg2;
-
-  if (arg1 == nullptr) {
-    DALI_LOG_ERROR("[ERR] arg1 == nullptr");
-    return;
-  }
-
-  {
-    try {
-      arg1->Disconnect(arg2);
-    }
-    catch (std::out_of_range & e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
-      };
-    }
-    catch (std::exception & e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
-      };
-    }
-    catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
-      };
-    }
-    catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
-      };
-    }
-  }
-  return;
-}
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_Emit(void* jarg1, void* jarg2, bool jarg3) {
-  Dali::GlWindow::VisibilityChangedSignalType* arg1 = (Dali::GlWindow::VisibilityChangedSignalType*)jarg1;
-  Dali::GlWindow* arg2 = (Dali::GlWindow*)jarg2;
-  bool arg3 = jarg3;
-
-  if (arg1 == nullptr || arg2 == nullptr) {
-    DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr");
-    return;
-  }
-
-  {
-    try {
-      arg1->Emit(*arg2, arg3);
-    }
-    catch (std::out_of_range & e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
-      };
-    }
-    catch (std::exception & e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
-      };
-    }
-    catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
-      };
-    }
-    catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
-      };
-    }
-  }
-  return;
-}
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_delete(void* jarg1) {
-  Dali::GlWindow::VisibilityChangedSignalType* arg1 = (Dali::GlWindow::VisibilityChangedSignalType*)jarg1;
-
-  {
-    try {
-      delete arg1;
-    }
-    catch (std::out_of_range & e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
-      };
-    }
-    catch (std::exception & e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
-      };
-    }
-    catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
-      };
-    }
-    catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
-      };
-    }
-  }
-  return;
-}
-
-
-/*ResizeSignal binding*/
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal(void * jarg1) {
-  void * jresult ;
-  Dali::GlWindow arg1 ;
-  Dali::GlWindow *argp1 ;
-  Dali::GlWindow::ResizeSignalType *result = 0 ;
-
-  argp1 = (Dali::GlWindow *)jarg1;
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0);
-    return 0;
-  }
-  arg1 = *argp1;
-  {
-    try {
-      result = (Dali::GlWindow::ResizeSignalType *) &arg1.ResizeSignal();
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-
-  jresult = (void *)result;
-  return jresult;
-}
-
-
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Empty(void * jarg1) {
-  unsigned int jresult ;
-  Dali::Signal< void (Dali::GlWindow::WindowSize) > *arg1 = (Dali::Signal< void (Dali::GlWindow::WindowSize) > *) 0 ;
-  bool result;
-
-  arg1 = (Dali::Signal< void (Dali::GlWindow::WindowSize) > *)jarg1;
-  {
-    try {
-      result = (bool)Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Empty((Dali::Signal< void (Dali::GlWindow::WindowSize) > const *)arg1);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-
-  jresult = result;
-  return jresult;
-}
-
-
-SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_GetConnectionCount(void * jarg1) {
-  unsigned long jresult ;
-  Dali::Signal< void (Dali::GlWindow::WindowSize) > *arg1 = (Dali::Signal< void (Dali::GlWindow::WindowSize) > *) 0 ;
-  std::size_t result;
-
-  arg1 = (Dali::Signal< void (Dali::GlWindow::WindowSize) > *)jarg1;
-  {
-    try {
-      result = Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::GlWindow::WindowSize) > const *)arg1);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-
-  jresult = (unsigned long)result;
-  return jresult;
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Connect(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::GlWindow::WindowSize) > *arg1 = (Dali::Signal< void (Dali::GlWindow::WindowSize) > *) 0 ;
-  void (*arg2)(Dali::GlWindow::WindowSize) = (void (*)(Dali::GlWindow::WindowSize)) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::GlWindow::WindowSize) > *)jarg1;
-  arg2 = (void (*)(Dali::GlWindow::WindowSize))jarg2;
-  {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Connect(arg1,arg2);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
-    }
-  }
-
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Disconnect(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::GlWindow::WindowSize) > *arg1 = (Dali::Signal< void (Dali::GlWindow::WindowSize) > *) 0 ;
-  void (*arg2)(Dali::GlWindow::WindowSize) = (void (*)(Dali::GlWindow::WindowSize)) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::GlWindow::WindowSize) > *)jarg1;
-  arg2 = (void (*)(Dali::GlWindow::WindowSize))jarg2;
-  {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Disconnect(arg1,arg2);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
-    }
-  }
-
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Emit(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::GlWindow::WindowSize) > *arg1 = (Dali::Signal< void (Dali::GlWindow::WindowSize) > *) 0 ;
-  Dali::GlWindow::WindowSize arg2 ;
-  Dali::GlWindow::WindowSize *argp2 ;
-
-  arg1 = (Dali::Signal< void (Dali::GlWindow::WindowSize) > *)jarg1;
-  if (arg1 == nullptr) {
-    DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr");
-    return;
-  }
-  argp2 = (Dali::GlWindow::WindowSize *)jarg2;
-  if (!argp2) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow::WindowSize", 0);
-    return ;
-  }
-  arg2 = *argp2;
-  {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Emit(arg1, arg2);
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
-    }
-  }
-
-}
-
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GlWindow_ResizedSignal() {
-  void * jresult ;
-  Dali::Signal< void (Dali::GlWindow::WindowSize) > *result = 0 ;
-
-  {
-    try {
-      result = (Dali::Signal< void (Dali::GlWindow::WindowSize) > *)new Dali::Signal< void (Dali::GlWindow::WindowSize) >();
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
-      };
-    }
-  }
-
-  jresult = (void *)result;
-  return jresult;
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_delete_ResizedSignal(void * jarg1) {
-  Dali::Signal< void (Dali::GlWindow::WindowSize) > *arg1 = (Dali::Signal< void (Dali::GlWindow::WindowSize) > *) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::GlWindow::WindowSize) > *)jarg1;
-  {
-    try {
-      delete arg1;
-    } catch (std::out_of_range& e) {
-      {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (std::exception& e) {
-      {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
-      };
-    } catch (Dali::DaliException e) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
-      };
-    } catch (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
-      };
-    }
-  }
-
-}
-
-
 #ifdef __cplusplus
 }
 #endif