merging dali-sharp bindings with nui

[platform/core/uifw/dali-csharp-binder.git] / dali-csharp-binder / src / dali_wrap.cpp

diff --git a/dali-csharp-binder/src/dali_wrap.cpp b/dali-csharp-binder/src/dali_wrap.cpp
index aff1129..14a2a4f 100755 (executable)
--- a/dali-csharp-binder/src/dali_wrap.cpp
+++ b/dali-csharp-binder/src/dali_wrap.cpp
@@ -447,6 +447,7 @@ SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 
+#include <dali-toolkit/devel-api/controls/control-devel.h>
 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
@@ -454,6 +455,7 @@ SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
+#include <dali-toolkit/devel-api/controls/scrollable/scroll-view/scroll-view-devel.h>
 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 
 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
@@ -466,6 +468,9 @@ SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 
 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 
+#include <dali/devel-api/adaptor-framework/imf-manager.h>
+
+
 // add here SWIG version check
 
 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
@@ -1025,6 +1030,22 @@ SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Sig
           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 /*@SWIG@*/ self->Emit( arg );
       }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
+          return self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
+      }
 
   // keep argcs and argv so they're always available to DALi
   int argC = 1;
@@ -28497,25 +28518,51 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
   return jresult;
 }
 
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetDeviceName(void * jarg1, char * jarg2) {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
+  int jresult ;
   Dali::KeyEvent *arg1 = 0 ;
-  std::string *arg2 = 0 ;
+  Dali::DevelKeyEvent::DeviceClass::Type result;
   
   arg1 = (Dali::KeyEvent *)jarg1;
   if (!arg1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0);
-    return ;
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
+    return 0;
   } 
-  if (!jarg2) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+  {
+    try {
+      result = (Dali::DevelKeyEvent::DeviceClass::Type)Dali::DevelKeyEvent::GetDeviceClass((Dali::KeyEvent 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (int)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
+  Dali::Actor arg1 ;
+  Dali::Actor *argp1 ;
+  
+  argp1 = (Dali::Actor *)jarg1; 
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
     return ;
   }
-  std::string arg2_str(jarg2);
-  arg2 = &arg2_str; 
+  arg1 = *argp1; 
   {
     try {
-      Dali::DevelKeyEvent::SetDeviceName(*arg1,(std::string const &)*arg2);
+      Dali::DevelActor::Raise(arg1);
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
@@ -28530,58 +28577,158 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetDeviceName(void * jarg1, char * jarg2
       };
     }
   }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
+  Dali::Actor arg1 ;
+  Dali::Actor *argp1 ;
   
-  //argout typemap for const std::string&
+  argp1 = (Dali::Actor *)jarg1; 
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
+    return ;
+  }
+  arg1 = *argp1; 
+  {
+    try {
+      Dali::DevelActor::Lower(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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
+  Dali::Actor arg1 ;
+  Dali::Actor *argp1 ;
+  
+  argp1 = (Dali::Actor *)jarg1; 
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
+    return ;
+  }
+  arg1 = *argp1; 
+  {
+    try {
+      Dali::DevelActor::RaiseToTop(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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
+  Dali::Actor arg1 ;
+  Dali::Actor *argp1 ;
   
+  argp1 = (Dali::Actor *)jarg1; 
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
+    return ;
+  }
+  arg1 = *argp1; 
+  {
+    try {
+      Dali::DevelActor::LowerToBottom(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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
 }
 
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
-  int jresult ;
-  Dali::KeyEvent *arg1 = 0 ;
-  Dali::DevelKeyEvent::DeviceClass::Type result;
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
+  Dali::Actor arg1 ;
+  Dali::Actor arg2 ;
+  Dali::Actor *argp1 ;
+  Dali::Actor *argp2 ;
   
-  arg1 = (Dali::KeyEvent *)jarg1;
-  if (!arg1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
-    return 0;
-  } 
+  argp1 = (Dali::Actor *)jarg1; 
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
+    return ;
+  }
+  arg1 = *argp1; 
+  argp2 = (Dali::Actor *)jarg2; 
+  if (!argp2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
+    return ;
+  }
+  arg2 = *argp2; 
   {
     try {
-      result = (Dali::DevelKeyEvent::DeviceClass::Type)Dali::DevelKeyEvent::GetDeviceClass((Dali::KeyEvent const &)*arg1);
+      Dali::DevelActor::RaiseAbove(arg1,arg2);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
       };
     } catch (std::exception& e) {
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
       };
     }
   }
-  jresult = (int)result; 
-  return jresult;
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetDeviceClass(void * jarg1, int jarg2) {
-  Dali::KeyEvent *arg1 = 0 ;
-  Dali::DevelKeyEvent::DeviceClass::Type *arg2 = 0 ;
-  Dali::DevelKeyEvent::DeviceClass::Type temp2 ;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
+  Dali::Actor arg1 ;
+  Dali::Actor arg2 ;
+  Dali::Actor *argp1 ;
+  Dali::Actor *argp2 ;
   
-  arg1 = (Dali::KeyEvent *)jarg1;
-  if (!arg1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0);
+  argp1 = (Dali::Actor *)jarg1; 
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
     return ;
-  } 
-  temp2 = (Dali::DevelKeyEvent::DeviceClass::Type)jarg2; 
-  arg2 = &temp2; 
+  }
+  arg1 = *argp1; 
+  argp2 = (Dali::Actor *)jarg2; 
+  if (!argp2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
+    return ;
+  }
+  arg2 = *argp2; 
   {
     try {
-      Dali::DevelKeyEvent::SetDeviceClass(*arg1,(enum Dali::DevelKeyEvent::DeviceClass::Type const &)*arg2);
+      Dali::DevelActor::LowerBelow(arg1,arg2);
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
@@ -28598,6 +28745,40 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetDeviceClass(void * jarg1, int jarg2)
   }
 }
 
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
+  void * jresult ;
+  Dali::Actor arg1 ;
+  Dali::Actor *argp1 ;
+  Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
+  
+  argp1 = (Dali::Actor *)jarg1; 
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
+    return 0;
+  }
+  arg1 = *argp1; 
+  {
+    try {
+      result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
   int jresult ;
   int result;
@@ -32364,202 +32545,6 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
-  Dali::Actor arg1 ;
-  Dali::Actor *argp1 ;
-  
-  argp1 = (Dali::Actor *)jarg1; 
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
-    return ;
-  }
-  arg1 = *argp1; 
-  {
-    try {
-      Dali::DevelActor::Raise(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 (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
-      };
-    }
-  }
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
-  Dali::Actor arg1 ;
-  Dali::Actor *argp1 ;
-  
-  argp1 = (Dali::Actor *)jarg1; 
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
-    return ;
-  }
-  arg1 = *argp1; 
-  {
-    try {
-      Dali::DevelActor::Lower(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 (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
-      };
-    }
-  }
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
-  Dali::Actor arg1 ;
-  Dali::Actor *argp1 ;
-  
-  argp1 = (Dali::Actor *)jarg1; 
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
-    return ;
-  }
-  arg1 = *argp1; 
-  {
-    try {
-      Dali::DevelActor::RaiseToTop(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 (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
-      };
-    }
-  }
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
-  Dali::Actor arg1 ;
-  Dali::Actor *argp1 ;
-  
-  argp1 = (Dali::Actor *)jarg1; 
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
-    return ;
-  }
-  arg1 = *argp1; 
-  {
-    try {
-      Dali::DevelActor::LowerToBottom(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 (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
-      };
-    }
-  }
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
-  Dali::Actor arg1 ;
-  Dali::Actor arg2 ;
-  Dali::Actor *argp1 ;
-  Dali::Actor *argp2 ;
-  
-  argp1 = (Dali::Actor *)jarg1; 
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
-    return ;
-  }
-  arg1 = *argp1; 
-  argp2 = (Dali::Actor *)jarg2; 
-  if (!argp2) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
-    return ;
-  }
-  arg2 = *argp2; 
-  {
-    try {
-      Dali::DevelActor::RaiseAbove(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 (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
-      };
-    }
-  }
-}
-
-
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
-  Dali::Actor arg1 ;
-  Dali::Actor arg2 ;
-  Dali::Actor *argp1 ;
-  Dali::Actor *argp2 ;
-  
-  argp1 = (Dali::Actor *)jarg1; 
-  if (!argp1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
-    return ;
-  }
-  arg1 = *argp1; 
-  argp2 = (Dali::Actor *)jarg2; 
-  if (!argp2) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
-    return ;
-  }
-  arg2 = *argp2; 
-  {
-    try {
-      Dali::DevelActor::LowerBelow(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 (...) {
-      {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
-      };
-    }
-  }
-}
-
-
 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
   int jresult ;
   int result;
@@ -52630,6 +52615,200 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1)
 }
 
 
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
+  unsigned int jresult ;
+  Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
+  bool result;
+  
+  arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1; 
+  {
+    try {
+      result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
+  unsigned long jresult ;
+  Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
+  std::size_t result;
+  
+  arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1; 
+  {
+    try {
+      result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
+  Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
+  void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
+  
+  arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1; 
+  arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2; 
+  {
+    try {
+      Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
+  Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
+  void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
+  
+  arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1; 
+  arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2; 
+  {
+    try {
+      Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
+  Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
+  Dali::Actor arg2 ;
+  bool arg3 ;
+  Dali::DevelActor::VisibilityChange::Type arg4 ;
+  Dali::Actor *argp2 ;
+  
+  arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1; 
+  argp2 = (Dali::Actor *)jarg2; 
+  if (!argp2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
+    return ;
+  }
+  arg2 = *argp2; 
+  arg3 = jarg3 ? true : false; 
+  arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4; 
+  {
+    try {
+      Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
+  void * jresult ;
+  Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
+  
+  {
+    try {
+      result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
+  Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
+  
+  arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
   void * jresult ;
   Dali::Timer *result = 0 ;
@@ -54240,119 +54419,108 @@ SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
-  void * jresult ;
-  Dali::Application result;
-  
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHintCount(void * jarg1) {
+  unsigned int jresult ;
+  Dali::Window arg1 ;
+  Dali::Window *argp1 ;
+  unsigned int result;
+ 
+  argp1 = (Dali::Window *)jarg1;
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
+    return 0;
+  }
+  arg1 = *argp1;
   {
     try {
-      result = Dali::Application::New();
+      result = (unsigned int)Dali::DevelWindow::GetSupportedAuxiliaryHintCount(arg1);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+        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; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
       };
     }
   }
-  jresult = new Dali::Application((const Dali::Application &)result); 
+  jresult = result; 
   return jresult;
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
-  void * jresult ;
-  int *arg1 = (int *) 0 ;
-  char ***arg2 ;
-  Dali::Application result;
-  
-  {
-    // Todo generate argv data from the C# args
-    char **array;         // two dimensional array
-    int numStrings = 1;     // number of strings
-    int stringLength = 30;      // max string length.
-    array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
-    argV = array;
-    
-    // allocate the string data
-    for( int i=0; i < numStrings; i++)
-    {
-      array[i]=(char *)malloc( stringLength * sizeof(char *) );
-    }
-    array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
-    
-    strcpy( array[0], "dali-csharp-app");
-    
-    arg1 = &argC;
-    arg2 = &argV;
+SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHint(void * jarg1, unsigned int jarg2) {
+  char * jresult ;
+  Dali::Window arg1 ;
+  unsigned int arg2 ;
+  Dali::Window *argp1 ;
+  std::string result;
+ 
+  argp1 = (Dali::Window *)jarg1;
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
+    return 0;
   }
+  arg1 = *argp1;
+  arg2 = (unsigned int)jarg2;
   {
     try {
-      result = Dali::Application::New(arg1,arg2);
+      result = Dali::DevelWindow::GetSupportedAuxiliaryHint(arg1,arg2);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+        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; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
       };
     }
   }
-  jresult = new Dali::Application((const Dali::Application &)result); 
+  jresult = SWIG_csharp_string_callback((&result)->c_str());
   return jresult;
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
-  void * jresult ;
-  int *arg1 = (int *) 0 ;
-  char ***arg2 ;
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AddAuxiliaryHint(void * jarg1, char * jarg2, char * jarg3) {
+  unsigned int jresult ;
+  Dali::Window arg1 ;
+  std::string *arg2 = 0 ;
   std::string *arg3 = 0 ;
-  Dali::Application result;
-  
-  {
-    // Todo generate argv data from the C# args
-    char **array;         // two dimensional array
-    int numStrings = 1;     // number of strings
-    int stringLength = 30;      // max string length.
-    array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
-    argV = array;
-    
-    // allocate the string data
-    for( int i=0; i < numStrings; i++)
-    {
-      array[i]=(char *)malloc( stringLength * sizeof(char *) );
-    }
-    array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
-    
-    strcpy( array[0], "dali-csharp-app");
-    
-    arg1 = &argC;
-    arg2 = &argV;
+  Dali::Window *argp1 ;
+  unsigned int result;
+ 
+  argp1 = (Dali::Window *)jarg1;
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 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; 
+  arg3 = &arg3_str;
   {
     try {
-      result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
+      result = (unsigned int)Dali::DevelWindow::AddAuxiliaryHint(arg1,(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; 
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
       };
     } catch (std::exception& e) {
       {
@@ -54360,11 +54528,14 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, cha
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
       };
     }
   }
-  jresult = new Dali::Application((const Dali::Application &)result); 
+  jresult = result;
+ 
+  //argout typemap for const std::string&
+  
   
   //argout typemap for const std::string&
   
@@ -54372,325 +54543,423 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, cha
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
-  void * jresult ;
-  int *arg1 = (int *) 0 ;
-  char ***arg2 ;
-  std::string *arg3 = 0 ;
-  Dali::Application::WINDOW_MODE arg4 ;
-  Dali::Application result;
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RemoveAuxiliaryHint(void * jarg1, unsigned int jarg2) {
+  unsigned int jresult ;
+  Dali::Window arg1 ;
+  unsigned int arg2 ;
+  Dali::Window *argp1 ;
+  bool result;
   
+  argp1 = (Dali::Window *)jarg1;
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
+    return 0;
+  }
+  arg1 = *argp1;
+  arg2 = (unsigned int)jarg2;
   {
-    // Todo generate argv data from the C# args
-    char **array;         // two dimensional array
-    int numStrings = 1;     // number of strings
-    int stringLength = 30;      // max string length.
-    array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
-    argV = array;
-    
-    // allocate the string data
-    for( int i=0; i < numStrings; i++)
-    {
-      array[i]=(char *)malloc( stringLength * sizeof(char *) );
+    try {
+      result = (bool)Dali::DevelWindow::RemoveAuxiliaryHint(arg1,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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
     }
-    array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
-    
-    strcpy( array[0], "dali-csharp-app");
-    
-    arg1 = &argC;
-    arg2 = &argV;
   }
+  jresult = result;
+  return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetAuxiliaryHintValue(void * jarg1, unsigned int jarg2, char * jarg3) {
+  unsigned int jresult ;
+  Dali::Window arg1 ;
+  unsigned int arg2 ;
+  std::string *arg3 = 0 ;
+  Dali::Window *argp1 ;
+  bool result;
+ 
+  argp1 = (Dali::Window *)jarg1;
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 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; 
-  arg4 = (Dali::Application::WINDOW_MODE)jarg4; 
+  arg3 = &arg3_str;
   {
     try {
-      result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
+      result = (bool)Dali::DevelWindow::SetAuxiliaryHintValue(arg1,arg2,(std::string const &)*arg3);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+        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; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
       };
     }
   }
-  jresult = new Dali::Application((const Dali::Application &)result); 
-  
+  jresult = result;
+ 
   //argout typemap for const std::string&
-  
+ 
   return jresult;
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
-  void * jresult ;
-  Dali::Application *result = 0 ;
+SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintValue(void * jarg1, unsigned int jarg2) {
+  char * jresult ;
+  Dali::Window arg1 ;
+  unsigned int arg2 ;
+  Dali::Window *argp1 ;
+  std::string result;
   
+  argp1 = (Dali::Window *)jarg1;
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
+    return 0;
+  }
+  arg1 = *argp1;
+  arg2 = (unsigned int)jarg2;
   {
     try {
-      result = (Dali::Application *)new Dali::Application();
+      result = Dali::DevelWindow::GetAuxiliaryHintValue(arg1,arg2);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+        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; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
       };
     }
   }
-  jresult = (void *)result; 
+  jresult = SWIG_csharp_string_callback((&result)->c_str());
   return jresult;
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
-  void * jresult ;
-  Dali::Application *arg1 = 0 ;
-  Dali::Application *result = 0 ;
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintId(void * jarg1, char * jarg2) {
+  unsigned int jresult ;
+  Dali::Window arg1 ;
+  std::string *arg2 = 0 ;
+  Dali::Window *argp1 ;
+  unsigned int result;
   
-  arg1 = (Dali::Application *)jarg1;
-  if (!arg1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
+  argp1 = (Dali::Window *)jarg1;
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 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 = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
+      result = (unsigned int)Dali::DevelWindow::GetAuxiliaryHintId(arg1,(std::string const &)*arg2);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+        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; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
       };
     }
   }
-  jresult = (void *)result; 
+  jresult = result;
+ 
+  //argout typemap for const std::string&
+  
   return jresult;
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
-  void * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application *arg2 = 0 ;
-  Dali::Application *result = 0 ;
-  
-  arg1 = (Dali::Application *)jarg1; 
-  arg2 = (Dali::Application *)jarg2;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetInputRegion(void * jarg1, void * jarg2) {
+  Dali::Window arg1 ;
+  Dali::Rect< int > *arg2 = 0 ;
+  Dali::Window *argp1 ;
+ 
+  argp1 = (Dali::Window *)jarg1;
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
+    return ;
+  }
+  arg1 = *argp1;
+  arg2 = (Dali::Rect< int > *)jarg2;
   if (!arg2) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
-    return 0;
-  } 
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
+    return ;
+  }
   {
     try {
-      result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
+      Dali::DevelWindow::SetInputRegion(arg1,(Dali::Rect< int > const &)*arg2);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
       };
     } catch (std::exception& e) {
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
       };
     }
   }
-  jresult = (void *)result; 
-  return jresult;
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetType(void * jarg1, int jarg2) {
+  Dali::Window arg1 ;
+  Dali::DevelWindow::Type arg2 ;
+  Dali::Window *argp1 ;
   
-  arg1 = (Dali::Application *)jarg1; 
+  argp1 = (Dali::Window *)jarg1;
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
+    return ;
+  }
+  arg1 = *argp1;
+  arg2 = (Dali::DevelWindow::Type)jarg2;
   {
     try {
-      delete arg1;
+      Dali::DevelWindow::SetType(arg1,arg2);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
       };
     } catch (std::exception& e) {
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
       };
     }
   }
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetType(void * jarg1) {
+  int jresult ;
+  Dali::Window arg1 ;
+  Dali::Window *argp1 ;
+  Dali::DevelWindow::Type result;
   
-  arg1 = (Dali::Application *)jarg1; 
+  argp1 = (Dali::Window *)jarg1;
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
+    return 0;
+  }
+  arg1 = *argp1;
   {
     try {
-      (arg1)->MainLoop();
+      result = (Dali::DevelWindow::Type)Dali::DevelWindow::GetType(arg1);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+        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 ; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
       };
     }
   }
+  jresult = (int)result;
+  return jresult;
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Configuration::ContextLoss arg2 ;
-  Configuration::ContextLoss *argp2 ;
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetNotificationLevel(void * jarg1, int jarg2) {
+  unsigned int jresult ;
+  Dali::Window arg1 ;
+  Dali::DevelWindow::NotificationLevel::Type arg2 ;
+  Dali::Window *argp1 ;
+  bool result;
   
-  arg1 = (Dali::Application *)jarg1; 
-  argp2 = (Configuration::ContextLoss *)jarg2; 
-  if (!argp2) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
-    return ;
+  argp1 = (Dali::Window *)jarg1; 
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
+    return 0;
   }
-  arg2 = *argp2; 
+  arg1 = *argp1;
+  arg2 = (Dali::DevelWindow::NotificationLevel::Type)jarg2;
   {
     try {
-      (arg1)->MainLoop(arg2);
+      result = (bool)Dali::DevelWindow::SetNotificationLevel(arg1,arg2);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+        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 ; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
       };
     }
   }
+  jresult = result;
+  return jresult;
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  
-  arg1 = (Dali::Application *)jarg1; 
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetNotificationLevel(void * jarg1) {
+  int jresult ;
+  Dali::Window arg1 ;
+  Dali::Window *argp1 ;
+  Dali::DevelWindow::NotificationLevel::Type result;
+ 
+  argp1 = (Dali::Window *)jarg1;
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
+    return 0;
+  }
+  arg1 = *argp1;
   {
     try {
-      (arg1)->Lower();
+      result = (Dali::DevelWindow::NotificationLevel::Type)Dali::DevelWindow::GetNotificationLevel(arg1);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+        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 ; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
       };
     }
   }
+  jresult = (int)result;
+  return jresult;
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetOpaqueState(void * jarg1, unsigned int jarg2) {
+  Dali::Window arg1 ;
+  bool arg2 ;
+  Dali::Window *argp1 ;
   
-  arg1 = (Dali::Application *)jarg1; 
+  argp1 = (Dali::Window *)jarg1;
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
+    return ;
+  }
+  arg1 = *argp1;
+  arg2 = jarg2 ? true : false;
   {
     try {
-      (arg1)->Quit();
+      Dali::DevelWindow::SetOpaqueState(arg1,arg2);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
       };
     } catch (std::exception& e) {
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
       };
     }
   }
 }
 
 
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsOpaqueState(void * jarg1) {
   unsigned int jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
+  Dali::Window arg1 ;
+  Dali::Window *argp1 ;
   bool result;
-  
-  arg1 = (Dali::Application *)jarg1; 
-  arg2 = (Dali::CallbackBase *)jarg2; 
+ 
+  argp1 = (Dali::Window *)jarg1;
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
+    return 0;
+  }
+  arg1 = *argp1;
   {
     try {
-      result = (bool)(arg1)->AddIdle(arg2);
+      result = (bool)Dali::DevelWindow::IsOpaqueState(arg1);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+        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; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
       };
     }
   }
-  jresult = result; 
+  jresult = result;
   return jresult;
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
-  void * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Window result;
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetScreenMode(void * jarg1, int jarg2) {
+  unsigned int jresult ;
+  Dali::Window arg1 ;
+  Dali::DevelWindow::ScreenMode::Type arg2 ;
+  Dali::Window *argp1 ;
+  bool result;
   
-  arg1 = (Dali::Application *)jarg1; 
+  argp1 = (Dali::Window *)jarg1; 
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
+    return 0;
+  }
+  arg1 = *argp1; 
+  arg2 = (Dali::DevelWindow::ScreenMode::Type)jarg2; 
   {
     try {
-      result = (arg1)->GetWindow();
+      result = (bool)Dali::DevelWindow::SetScreenMode(arg1,arg2);
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
@@ -54705,60 +54974,62 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
       };
     }
   }
-  jresult = new Dali::Window((const Dali::Window &)result); 
+  jresult = result; 
   return jresult;
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::PositionSize arg2 ;
-  std::string *arg3 = 0 ;
-  Dali::PositionSize *argp2 ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetScreenMode(void * jarg1) {
+  int jresult ;
+  Dali::Window arg1 ;
+  Dali::Window *argp1 ;
+  Dali::DevelWindow::ScreenMode::Type result;
   
-  arg1 = (Dali::Application *)jarg1; 
-  argp2 = (Dali::PositionSize *)jarg2; 
-  if (!argp2) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
-    return ;
-  }
-  arg2 = *argp2; 
-  if (!jarg3) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
-    return ;
+  argp1 = (Dali::Window *)jarg1; 
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
+    return 0;
   }
-  std::string arg3_str(jarg3);
-  arg3 = &arg3_str; 
+  arg1 = *argp1; 
   {
     try {
-      (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
+      result = (Dali::DevelWindow::ScreenMode::Type)Dali::DevelWindow::GetScreenMode(arg1);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+        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 ; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
       };
     }
   }
-  
-  //argout typemap for const std::string&
-  
+  jresult = (int)result; 
+  return jresult;
 }
 
 
-SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
-  char * jresult ;
-  std::string result;
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetBrightness(void * jarg1, int jarg2) {
+  unsigned int jresult ;
+  Dali::Window arg1 ;
+  int arg2 ;
+  Dali::Window *argp1 ;
+  bool result;
   
+  argp1 = (Dali::Window *)jarg1; 
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
+    return 0;
+  }
+  arg1 = *argp1; 
+  arg2 = (int)jarg2; 
   {
     try {
-      result = Dali::Application::GetResourcePath();
+      result = (bool)Dali::DevelWindow::SetBrightness(arg1,arg2);
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
@@ -54773,46 +55044,52 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
       };
     }
   }
-  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
+  jresult = result; 
   return jresult;
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::ViewMode arg2 ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetBrightness(void * jarg1) {
+  int jresult ;
+  Dali::Window arg1 ;
+  Dali::Window *argp1 ;
+  int result;
   
-  arg1 = (Dali::Application *)jarg1; 
-  arg2 = (Dali::ViewMode)jarg2; 
+  argp1 = (Dali::Window *)jarg1; 
+  if (!argp1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
+    return 0;
+  }
+  arg1 = *argp1; 
   {
     try {
-      (arg1)->SetViewMode(arg2);
+      result = (int)Dali::DevelWindow::GetBrightness(arg1);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+        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 ; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
       };
     }
   }
+  jresult = result; 
+  return jresult;
 }
 
 
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
-  int jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::ViewMode result;
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
+  void * jresult ;
+  Dali::Application result;
   
-  arg1 = (Dali::Application *)jarg1; 
   {
     try {
-      result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
+      result = Dali::Application::New();
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
@@ -54827,46 +55104,95 @@ SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
       };
     }
   }
-  jresult = (int)result; 
+  jresult = new Dali::Application((const Dali::Application &)result); 
   return jresult;
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  float arg2 ;
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
+  void * jresult ;
+  int *arg1 = (int *) 0 ;
+  char ***arg2 ;
+  Dali::Application result;
   
-  arg1 = (Dali::Application *)jarg1; 
-  arg2 = (float)jarg2; 
+  {
+    // Todo generate argv data from the C# args
+    char **array;         // two dimensional array
+    int numStrings = 1;     // number of strings
+    int stringLength = 30;      // max string length.
+    array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
+    argV = array;
+    
+    // allocate the string data
+    for( int i=0; i < numStrings; i++)
+    {
+      array[i]=(char *)malloc( stringLength * sizeof(char *) );
+    }
+    array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
+    
+    strcpy( array[0], "dali-csharp-app");
+    
+    arg1 = &argC;
+    arg2 = &argV;
+  }
   {
     try {
-      (arg1)->SetStereoBase(arg2);
+      result = Dali::Application::New(arg1,arg2);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+        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 ; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
       };
     }
   }
+  jresult = new Dali::Application((const Dali::Application &)result); 
+  return jresult;
 }
 
 
-SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
-  float jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  float result;
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
+  void * jresult ;
+  int *arg1 = (int *) 0 ;
+  char ***arg2 ;
+  std::string *arg3 = 0 ;
+  Dali::Application result;
   
-  arg1 = (Dali::Application *)jarg1; 
+  {
+    // Todo generate argv data from the C# args
+    char **array;         // two dimensional array
+    int numStrings = 1;     // number of strings
+    int stringLength = 30;      // max string length.
+    array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
+    argV = array;
+    
+    // allocate the string data
+    for( int i=0; i < numStrings; i++)
+    {
+      array[i]=(char *)malloc( stringLength * sizeof(char *) );
+    }
+    array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
+    
+    strcpy( array[0], "dali-csharp-app");
+    
+    arg1 = &argC;
+    arg2 = &argV;
+  }
+  if (!jarg3) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+    return 0;
+  }
+  std::string arg3_str(jarg3);
+  arg3 = &arg3_str; 
   {
     try {
-      result = (float)((Dali::Application const *)arg1)->GetStereoBase();
+      result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
@@ -54881,20 +55207,52 @@ SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1)
       };
     }
   }
-  jresult = result; 
+  jresult = new Dali::Application((const Dali::Application &)result); 
+  
+  //argout typemap for const std::string&
+  
   return jresult;
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
   void * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
+  int *arg1 = (int *) 0 ;
+  char ***arg2 ;
+  std::string *arg3 = 0 ;
+  Dali::Application::WINDOW_MODE arg4 ;
+  Dali::Application result;
   
-  arg1 = (Dali::Application *)jarg1; 
+  {
+    // Todo generate argv data from the C# args
+    char **array;         // two dimensional array
+    int numStrings = 1;     // number of strings
+    int stringLength = 30;      // max string length.
+    array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
+    argV = array;
+    
+    // allocate the string data
+    for( int i=0; i < numStrings; i++)
+    {
+      array[i]=(char *)malloc( stringLength * sizeof(char *) );
+    }
+    array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
+    
+    strcpy( array[0], "dali-csharp-app");
+    
+    arg1 = &argC;
+    arg2 = &argV;
+  }
+  if (!jarg3) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+    return 0;
+  }
+  std::string arg3_str(jarg3);
+  arg3 = &arg3_str; 
+  arg4 = (Dali::Application::WINDOW_MODE)jarg4; 
   {
     try {
-      result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
+      result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
@@ -54909,20 +55267,21 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
       };
     }
   }
-  jresult = (void *)result; 
+  jresult = new Dali::Application((const Dali::Application &)result); 
+  
+  //argout typemap for const std::string&
+  
   return jresult;
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
   void * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
+  Dali::Application *result = 0 ;
   
-  arg1 = (Dali::Application *)jarg1; 
   {
     try {
-      result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
+      result = (Dali::Application *)new Dali::Application();
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
@@ -54942,15 +55301,19 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jar
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
   void * jresult ;
-  Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
+  Dali::Application *arg1 = 0 ;
+  Dali::Application *result = 0 ;
   
-  arg1 = (Dali::Application *)jarg1; 
+  arg1 = (Dali::Application *)jarg1;
+  if (!arg1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
+    return 0;
+  } 
   {
     try {
-      result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
+      result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
@@ -54970,15 +55333,21 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1)
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
   void * jresult ;
   Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
+  Dali::Application *arg2 = 0 ;
+  Dali::Application *result = 0 ;
   
   arg1 = (Dali::Application *)jarg1; 
+  arg2 = (Dali::Application *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
+    return 0;
+  } 
   {
     try {
-      result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
+      result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
@@ -54998,155 +55367,145 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1)
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
-  void * jresult ;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
   Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
   
   arg1 = (Dali::Application *)jarg1; 
   {
     try {
-      result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
+      delete arg1;
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
       };
     } catch (std::exception& e) {
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
       };
     }
   }
-  jresult = (void *)result; 
-  return jresult;
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
-  void * jresult ;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
   Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
   
   arg1 = (Dali::Application *)jarg1; 
   {
     try {
-      result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
+      (arg1)->MainLoop();
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
       };
     } catch (std::exception& e) {
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
       };
     }
   }
-  jresult = (void *)result; 
-  return jresult;
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
-  void * jresult ;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
   Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppControlSignalType *result = 0 ;
+  Configuration::ContextLoss arg2 ;
+  Configuration::ContextLoss *argp2 ;
   
   arg1 = (Dali::Application *)jarg1; 
+  argp2 = (Configuration::ContextLoss *)jarg2; 
+  if (!argp2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
+    return ;
+  }
+  arg2 = *argp2; 
   {
     try {
-      result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
+      (arg1)->MainLoop(arg2);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
       };
     } catch (std::exception& e) {
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
       };
     }
   }
-  jresult = (void *)result; 
-  return jresult;
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
-  void * jresult ;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
   Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
   
   arg1 = (Dali::Application *)jarg1; 
   {
     try {
-      result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
+      (arg1)->Lower();
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
       };
     } catch (std::exception& e) {
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
       };
     }
   }
-  jresult = (void *)result; 
-  return jresult;
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
-  void * jresult ;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
   Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
   
   arg1 = (Dali::Application *)jarg1; 
   {
     try {
-      result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
+      (arg1)->Quit();
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
       };
     } catch (std::exception& e) {
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
       };
     }
   }
-  jresult = (void *)result; 
-  return jresult;
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
-  void * jresult ;
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
+  unsigned int jresult ;
   Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
+  Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
+  bool result;
   
   arg1 = (Dali::Application *)jarg1; 
+  arg2 = (Dali::CallbackBase *)jarg2; 
   {
     try {
-      result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
+      result = (bool)(arg1)->AddIdle(arg2);
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
@@ -55161,20 +55520,20 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * ja
       };
     }
   }
-  jresult = (void *)result; 
+  jresult = result; 
   return jresult;
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
   void * jresult ;
   Dali::Application *arg1 = (Dali::Application *) 0 ;
-  Dali::Application::AppSignalType *result = 0 ;
+  Dali::Window result;
   
   arg1 = (Dali::Application *)jarg1; 
   {
     try {
-      result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
+      result = (arg1)->GetWindow();
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
@@ -55189,48 +55548,60 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jar
       };
     }
   }
-  jresult = (void *)result; 
+  jresult = new Dali::Window((const Dali::Window &)result); 
   return jresult;
 }
 
 
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
-  unsigned int jresult ;
-  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
-  bool result;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
+  Dali::Application *arg1 = (Dali::Application *) 0 ;
+  Dali::PositionSize arg2 ;
+  std::string *arg3 = 0 ;
+  Dali::PositionSize *argp2 ;
   
-  arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1; 
+  arg1 = (Dali::Application *)jarg1; 
+  argp2 = (Dali::PositionSize *)jarg2; 
+  if (!argp2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
+    return ;
+  }
+  arg2 = *argp2; 
+  if (!jarg3) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+    return ;
+  }
+  std::string arg3_str(jarg3);
+  arg3 = &arg3_str; 
   {
     try {
-      result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
+      (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
       };
     } catch (std::exception& e) {
       {
-        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
       };
     }
   }
-  jresult = result; 
-  return jresult;
+  
+  //argout typemap for const std::string&
+  
 }
 
 
-SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
-  unsigned long jresult ;
-  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
-  std::size_t result;
+SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
+  char * jresult ;
+  std::string result;
   
-  arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1; 
   {
     try {
-      result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
+      result = Dali::Application::GetResourcePath();
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
@@ -55245,20 +55616,20 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnection
       };
     }
   }
-  jresult = (unsigned long)result; 
+  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
   return jresult;
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
-  void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
+  Dali::Application *arg1 = (Dali::Application *) 0 ;
+  Dali::ViewMode arg2 ;
   
-  arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1; 
-  arg2 = (void (*)(Dali::Application &))jarg2; 
+  arg1 = (Dali::Application *)jarg1; 
+  arg2 = (Dali::ViewMode)jarg2; 
   {
     try {
-      Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
+      (arg1)->SetViewMode(arg2);
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
@@ -55276,45 +55647,43 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1,
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
-  void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
+  int jresult ;
+  Dali::Application *arg1 = (Dali::Application *) 0 ;
+  Dali::ViewMode result;
   
-  arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1; 
-  arg2 = (void (*)(Dali::Application &))jarg2; 
+  arg1 = (Dali::Application *)jarg1; 
   {
     try {
-      Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
+      result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+        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 ; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
       };
     }
   }
+  jresult = (int)result; 
+  return jresult;
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
-  Dali::Application *arg2 = 0 ;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
+  Dali::Application *arg1 = (Dali::Application *) 0 ;
+  float arg2 ;
   
-  arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1; 
-  arg2 = (Dali::Application *)jarg2;
-  if (!arg2) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
-    return ;
-  } 
+  arg1 = (Dali::Application *)jarg1; 
+  arg2 = (float)jarg2; 
   {
     try {
-      Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
+      (arg1)->SetStereoBase(arg2);
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
@@ -55332,13 +55701,15 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, voi
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
-  void * jresult ;
-  Dali::Signal< void (Dali::Application &) > *result = 0 ;
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
+  float jresult ;
+  Dali::Application *arg1 = (Dali::Application *) 0 ;
+  float result;
   
+  arg1 = (Dali::Application *)jarg1; 
   {
     try {
-      result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
+      result = (float)((Dali::Application const *)arg1)->GetStereoBase();
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
@@ -55353,44 +55724,48 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
       };
     }
   }
-  jresult = (void *)result; 
+  jresult = result; 
   return jresult;
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
-  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
+  void * jresult ;
+  Dali::Application *arg1 = (Dali::Application *) 0 ;
+  Dali::Application::AppSignalType *result = 0 ;
   
-  arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1; 
+  arg1 = (Dali::Application *)jarg1; 
   {
     try {
-      delete arg1;
+      result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
     } catch (std::out_of_range& e) {
       {
-        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+        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 ; 
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
       };
     } catch (...) {
       {
-        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
       };
     }
   }
+  jresult = (void *)result; 
+  return jresult;
 }
 
 
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
-  unsigned int jresult ;
-  Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
-  bool result;
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
+  void * jresult ;
+  Dali::Application *arg1 = (Dali::Application *) 0 ;
+  Dali::Application::AppSignalType *result = 0 ;
   
-  arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1; 
+  arg1 = (Dali::Application *)jarg1; 
   {
     try {
-      result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
+      result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
@@ -55405,20 +55780,488 @@ SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(v
       };
     }
   }
-  jresult = result; 
+  jresult = (void *)result; 
   return jresult;
 }
 
 
-SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
-  unsigned long jresult ;
-  Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
-  std::size_t result;
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
+  void * jresult ;
+  Dali::Application *arg1 = (Dali::Application *) 0 ;
+  Dali::Application::AppSignalType *result = 0 ;
   
-  arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1; 
+  arg1 = (Dali::Application *)jarg1; 
   {
     try {
-      result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
+      result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
+  void * jresult ;
+  Dali::Application *arg1 = (Dali::Application *) 0 ;
+  Dali::Application::AppSignalType *result = 0 ;
+  
+  arg1 = (Dali::Application *)jarg1; 
+  {
+    try {
+      result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
+  void * jresult ;
+  Dali::Application *arg1 = (Dali::Application *) 0 ;
+  Dali::Application::AppSignalType *result = 0 ;
+  
+  arg1 = (Dali::Application *)jarg1; 
+  {
+    try {
+      result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
+  void * jresult ;
+  Dali::Application *arg1 = (Dali::Application *) 0 ;
+  Dali::Application::AppSignalType *result = 0 ;
+  
+  arg1 = (Dali::Application *)jarg1; 
+  {
+    try {
+      result = (Dali::Application::AppSignalType *) &(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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
+  void * jresult ;
+  Dali::Application *arg1 = (Dali::Application *) 0 ;
+  Dali::Application::AppControlSignalType *result = 0 ;
+  
+  arg1 = (Dali::Application *)jarg1; 
+  {
+    try {
+      result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
+  void * jresult ;
+  Dali::Application *arg1 = (Dali::Application *) 0 ;
+  Dali::Application::AppSignalType *result = 0 ;
+  
+  arg1 = (Dali::Application *)jarg1; 
+  {
+    try {
+      result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
+  void * jresult ;
+  Dali::Application *arg1 = (Dali::Application *) 0 ;
+  Dali::Application::AppSignalType *result = 0 ;
+  
+  arg1 = (Dali::Application *)jarg1; 
+  {
+    try {
+      result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
+  void * jresult ;
+  Dali::Application *arg1 = (Dali::Application *) 0 ;
+  Dali::Application::AppSignalType *result = 0 ;
+  
+  arg1 = (Dali::Application *)jarg1; 
+  {
+    try {
+      result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
+  void * jresult ;
+  Dali::Application *arg1 = (Dali::Application *) 0 ;
+  Dali::Application::AppSignalType *result = 0 ;
+  
+  arg1 = (Dali::Application *)jarg1; 
+  {
+    try {
+      result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
+  unsigned int jresult ;
+  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
+  bool result;
+  
+  arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1; 
+  {
+    try {
+      result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
+  unsigned long jresult ;
+  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
+  std::size_t result;
+  
+  arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1; 
+  {
+    try {
+      result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
+  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
+  void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
+  
+  arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1; 
+  arg2 = (void (*)(Dali::Application &))jarg2; 
+  {
+    try {
+      Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
+  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
+  void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
+  
+  arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1; 
+  arg2 = (void (*)(Dali::Application &))jarg2; 
+  {
+    try {
+      Dali_Signal_Sl_void_Sp_Dali_Application_SA__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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
+  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
+  Dali::Application *arg2 = 0 ;
+  
+  arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1; 
+  arg2 = (Dali::Application *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
+    return ;
+  } 
+  {
+    try {
+      Dali_Signal_Sl_void_Sp_Dali_Application_SA__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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
+  void * jresult ;
+  Dali::Signal< void (Dali::Application &) > *result = 0 ;
+  
+  {
+    try {
+      result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
+  Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
+  
+  arg1 = (Dali::Signal< void (Dali::Application &) > *)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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
+  unsigned int jresult ;
+  Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
+  bool result;
+  
+  arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1; 
+  {
+    try {
+      result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
+  unsigned long jresult ;
+  Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
+  std::size_t result;
+  
+  arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1; 
+  {
+    try {
+      result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
     } catch (std::out_of_range& e) {
       {
         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
@@ -55758,10 +56601,6 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
 }
 
 
-
-
-
-//manual merge 2017-03-31
 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
   unsigned int jresult ;
   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
@@ -55946,10 +56785,6 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg
 }
 
 
-
-
-
-
 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
   int jresult ;
   int result;
@@ -63218,6 +64053,69 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
   return jresult;
 }
 
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
+  void * jresult ;
+  Dali::Toolkit::Control *arg1 = 0 ;
+  Dali::Toolkit::DevelControl::ResourceReadySignalType *result = 0 ;
+  
+  arg1 = (Dali::Toolkit::Control *)jarg1;
+  if (!arg1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Toolkit::DevelControl::ResourceReadySignalType *) &Dali::Toolkit::DevelControl::ResourceReadySignal(*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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
+  unsigned int jresult ;
+  Dali::Toolkit::Control *arg1 = 0 ;
+  bool result;
+  
+  arg1 = (Dali::Toolkit::Control *)jarg1;
+  if (!arg1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (bool)Dali::Toolkit::DevelControl::IsResourceReady((Dali::Toolkit::Control 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
 
 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
   void * jresult ;
@@ -64047,36 +64945,6 @@ SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
 }
 
 
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_STATE_IMAGE_get() {
-  int jresult ;
-  int result;
-  
-  result = (int)Dali::Toolkit::Button::Property::UNSELECTED_STATE_IMAGE;
-  jresult = (int)result; 
-  return jresult;
-}
-
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_STATE_IMAGE_get() {
-  int jresult ;
-  int result;
-  
-  result = (int)Dali::Toolkit::Button::Property::SELECTED_STATE_IMAGE;
-  jresult = (int)result; 
-  return jresult;
-}
-
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_STATE_IMAGE_get() {
-  int jresult ;
-  int result;
-  
-  result = (int)Dali::Toolkit::Button::Property::DISABLED_STATE_IMAGE;
-  jresult = (int)result; 
-  return jresult;
-}
-
-
 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
   int jresult ;
   int result;
@@ -73058,6 +73926,15 @@ SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE
 }
 
 
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
+  int jresult ;
+  int result;
+
+  result = (int)Dali::Toolkit::DevelScrollView::Property::SCROLL_MODE;
+  jresult = (int)result;
+  return jresult;
+}
+
 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
   int jresult ;
   int result;
@@ -93005,6 +93882,195 @@ SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
 }
 
 
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
+  unsigned int jresult ;
+  Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
+  bool result;
+  
+  arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1; 
+  {
+    try {
+      result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
+  unsigned long jresult ;
+  Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
+  std::size_t result;
+  
+  arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1; 
+  {
+    try {
+      result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
+  Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
+  void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
+  
+  arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1; 
+  arg2 = (void (*)(Dali::Toolkit::Control))jarg2; 
+  {
+    try {
+      Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
+  Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
+  void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
+  
+  arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1; 
+  arg2 = (void (*)(Dali::Toolkit::Control))jarg2; 
+  {
+    try {
+      Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
+  Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
+  Dali::Toolkit::Control arg2 ;
+  Dali::Toolkit::Control *argp2 ;
+  
+  arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1; 
+  argp2 = (Dali::Toolkit::Control *)jarg2; 
+  if (!argp2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
+    return ;
+  }
+  arg2 = *argp2; 
+  {
+    try {
+      Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
+  void * jresult ;
+  Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
+  
+  {
+    try {
+      result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
+  Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
+  
+  arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
     return (Dali::RefObject *)jarg1;
 }
@@ -93381,6 +94447,1224 @@ SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcas
     return (Dali::BaseHandle *)jarg1;
 }
 
+
+
+
+
+//////////////////////////////////////////////////
+//from dali-swig autogeneration (from dali_wrap.cpp)
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_0() {
+  void * jresult ;
+  Dali::ImfManager::ImfEventData *result = 0 ;
+
+  {
+    try {
+      result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = (void *)result;
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_1(int jarg1, char * jarg2, int jarg3, int jarg4) {
+  void * jresult ;
+  Dali::ImfManager::ImfEvent arg1 ;
+  std::string *arg2 = 0 ;
+  int arg3 ;
+  int arg4 ;
+  Dali::ImfManager::ImfEventData *result = 0 ;
+
+  arg1 = (Dali::ImfManager::ImfEvent)jarg1;
+  if (!jarg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+    return 0;
+  }
+  std::string arg2_str(jarg2);
+  arg2 = &arg2_str;
+  arg3 = (int)jarg3;
+  arg4 = (int)jarg4;
+  {
+    try {
+      result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData(arg1,(std::string const &)*arg2,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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = (void *)result;
+
+  //argout typemap for const std::string&
+
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_set(void * jarg1, char * jarg2) {
+  Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
+  std::string *arg2 = 0 ;
+
+  arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
+  if (!jarg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+    return ;
+  }
+  std::string arg2_str(jarg2);
+  arg2 = &arg2_str;
+  if (arg1) (arg1)->predictiveString = *arg2;
+
+  //argout typemap for const std::string&
+
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_get(void * jarg1) {
+  char * jresult ;
+  Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
+  std::string *result = 0 ;
+
+  arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
+  result = (std::string *) & ((arg1)->predictiveString);
+  jresult = SWIG_csharp_string_callback(result->c_str());
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_set(void * jarg1, int jarg2) {
+  Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
+  Dali::ImfManager::ImfEvent arg2 ;
+
+  arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
+  arg2 = (Dali::ImfManager::ImfEvent)jarg2;
+  if (arg1) (arg1)->eventName = arg2;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_get(void * jarg1) {
+  int jresult ;
+  Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
+  Dali::ImfManager::ImfEvent result;
+
+  arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
+  result = (Dali::ImfManager::ImfEvent) ((arg1)->eventName);
+  jresult = (int)result;
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_set(void * jarg1, int jarg2) {
+  Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
+  int arg2 ;
+
+  arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
+  arg2 = (int)jarg2;
+  if (arg1) (arg1)->cursorOffset = arg2;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_get(void * jarg1) {
+  int jresult ;
+  Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
+  int result;
+
+  arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
+  result = (int) ((arg1)->cursorOffset);
+  jresult = result;
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_set(void * jarg1, int jarg2) {
+  Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
+  int arg2 ;
+
+  arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
+  arg2 = (int)jarg2;
+  if (arg1) (arg1)->numberOfChars = arg2;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_get(void * jarg1) {
+  int jresult ;
+  Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
+  int result;
+
+  arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
+  result = (int) ((arg1)->numberOfChars);
+  jresult = result;
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfEventData(void * jarg1) {
+  Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
+
+  arg1 = (Dali::ImfManager::ImfEventData *)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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_0() {
+  void * jresult ;
+  Dali::ImfManager::ImfCallbackData *result = 0 ;
+
+  {
+    try {
+      result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = (void *)result;
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_1(unsigned int jarg1, int jarg2, char * jarg3, unsigned int jarg4) {
+  void * jresult ;
+  bool arg1 ;
+  int arg2 ;
+  std::string *arg3 = 0 ;
+  bool arg4 ;
+  Dali::ImfManager::ImfCallbackData *result = 0 ;
+
+  arg1 = jarg1 ? true : false;
+  arg2 = (int)jarg2;
+  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::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData(arg1,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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = (void *)result;
+
+  //argout typemap for const std::string&
+
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_set(void * jarg1, char * jarg2) {
+  Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
+  std::string *arg2 = 0 ;
+
+  arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
+  if (!jarg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+    return ;
+  }
+  std::string arg2_str(jarg2);
+  arg2 = &arg2_str;
+  if (arg1) (arg1)->currentText = *arg2;
+
+  //argout typemap for const std::string&
+
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_get(void * jarg1) {
+  char * jresult ;
+  Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
+  std::string *result = 0 ;
+
+  arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
+  result = (std::string *) & ((arg1)->currentText);
+  jresult = SWIG_csharp_string_callback(result->c_str());
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_set(void * jarg1, int jarg2) {
+  Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
+  int arg2 ;
+
+  arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
+  arg2 = (int)jarg2;
+  if (arg1) (arg1)->cursorPosition = arg2;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_get(void * jarg1) {
+  int jresult ;
+  Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
+  int result;
+
+  arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
+  result = (int) ((arg1)->cursorPosition);
+  jresult = result;
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_set(void * jarg1, unsigned int jarg2) {
+  Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
+  bool arg2 ;
+
+  arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
+  arg2 = jarg2 ? true : false;
+  if (arg1) (arg1)->update = arg2;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_get(void * jarg1) {
+  unsigned int jresult ;
+  Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
+  bool result;
+
+  arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
+  result = (bool) ((arg1)->update);
+  jresult = result;
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_set(void * jarg1, unsigned int jarg2) {
+  Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
+  bool arg2 ;
+
+  arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
+  arg2 = jarg2 ? true : false;
+  if (arg1) (arg1)->preeditResetRequired = arg2;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_get(void * jarg1) {
+  unsigned int jresult ;
+  Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
+  bool result;
+
+  arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
+  result = (bool) ((arg1)->preeditResetRequired);
+  jresult = result;
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfCallbackData(void * jarg1) {
+  Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
+
+  arg1 = (Dali::ImfManager::ImfCallbackData *)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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_Get() {
+  void * jresult ;
+  Dali::ImfManager result;
+
+  {
+    try {
+      result = Dali::ImfManager::Get();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = new Dali::ImfManager((const Dali::ImfManager &)result);
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Activate(void * jarg1) {
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+
+  arg1 = (Dali::ImfManager *)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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Deactivate(void * jarg1) {
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  {
+    try {
+      (arg1)->Deactivate();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_RestoreAfterFocusLost(void * jarg1) {
+  unsigned int jresult ;
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  bool result;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  {
+    try {
+      result = (bool)((Dali::ImfManager const *)arg1)->RestoreAfterFocusLost();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = result;
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetRestoreAfterFocusLost(void * jarg1, unsigned int jarg2) {
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  bool arg2 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  arg2 = jarg2 ? true : false;
+  {
+    try {
+      (arg1)->SetRestoreAfterFocusLost(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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Reset(void * jarg1) {
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  {
+    try {
+      (arg1)->Reset();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyCursorPosition(void * jarg1) {
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  {
+    try {
+      (arg1)->NotifyCursorPosition();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetCursorPosition(void * jarg1, unsigned int jarg2) {
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  unsigned int arg2 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  arg2 = (unsigned int)jarg2;
+  {
+    try {
+      (arg1)->SetCursorPosition(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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_GetCursorPosition(void * jarg1) {
+  unsigned int jresult ;
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  unsigned int result;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  {
+    try {
+      result = (unsigned int)((Dali::ImfManager const *)arg1)->GetCursorPosition();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = result;
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetSurroundingText(void * jarg1, char * jarg2) {
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  std::string *arg2 = 0 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  if (!jarg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+    return ;
+  }
+  std::string arg2_str(jarg2);
+  arg2 = &arg2_str;
+  {
+    try {
+      (arg1)->SetSurroundingText((std::string 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+
+  //argout typemap for const std::string&
+
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_GetSurroundingText(void * jarg1) {
+  char * jresult ;
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  std::string *result = 0 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  {
+    try {
+      result = (std::string *) &((Dali::ImfManager const *)arg1)->GetSurroundingText();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = SWIG_csharp_string_callback(result->c_str());
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyTextInputMultiLine(void * jarg1, unsigned int jarg2) {
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  bool arg2 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  arg2 = jarg2 ? true : false;
+  {
+    try {
+      (arg1)->NotifyTextInputMultiLine(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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetTextDirection(void * jarg1) {
+  int jresult ;
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  Dali::ImfManager::TextDirection result;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  {
+    try {
+      result = (Dali::ImfManager::TextDirection)(arg1)->GetTextDirection();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = (int)result;
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_GetInputMethodArea(void * jarg1) {
+  void * jresult ;
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  Dali::Rect< int > result;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  {
+    try {
+      result = (arg1)->GetInputMethodArea();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ApplyOptions(void * jarg1, void * jarg2) {
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  Dali::InputMethodOptions *arg2 = 0 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  arg2 = (Dali::InputMethodOptions *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InputMethodOptions const & type is null", 0);
+    return ;
+  }
+  {
+    try {
+      (arg1)->ApplyOptions((Dali::InputMethodOptions 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetInputPanelUserData(void * jarg1, char * jarg2) {
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  std::string *arg2 = 0 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  if (!jarg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+    return ;
+  }
+  std::string arg2_str(jarg2);
+  arg2 = &arg2_str;
+  {
+    try {
+      (arg1)->SetInputPanelUserData((std::string 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+
+  //argout typemap for const std::string&
+
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelUserData(void * jarg1, char * jarg2) {
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  std::string *arg2 = 0 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  if (!jarg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+    return ;
+  }
+  std::string arg2_str(jarg2);
+  arg2 = &arg2_str;
+  {
+    try {
+      (arg1)->GetInputPanelUserData((std::string &)*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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelState(void * jarg1) {
+  int jresult ;
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  Dali::ImfManager::State result;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  {
+    try {
+      result = (Dali::ImfManager::State)(arg1)->GetInputPanelState();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = (int)result;
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetReturnKeyState(void * jarg1, unsigned int jarg2) {
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  bool arg2 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  arg2 = jarg2 ? true : false;
+  {
+    try {
+      (arg1)->SetReturnKeyState(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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_AutoEnableInputPanel(void * jarg1, unsigned int jarg2) {
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  bool arg2 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  arg2 = jarg2 ? true : false;
+  {
+    try {
+      (arg1)->AutoEnableInputPanel(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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ShowInputPanel(void * jarg1) {
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  {
+    try {
+      (arg1)->ShowInputPanel();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_HideInputPanel(void * jarg1) {
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  {
+    try {
+      (arg1)->HideInputPanel();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ActivatedSignal(void * jarg1) {
+  void * jresult ;
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  Dali::ImfManager::ImfManagerSignalType *result = 0 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  {
+    try {
+      result = (Dali::ImfManager::ImfManagerSignalType *) &(arg1)->ActivatedSignal();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = (void *)result;
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_EventReceivedSignal(void * jarg1) {
+  void * jresult ;
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  Dali::ImfManager::ImfEventSignalType *result = 0 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  {
+    try {
+      result = (Dali::ImfManager::ImfEventSignalType *) &(arg1)->EventReceivedSignal();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = (void *)result;
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_StatusChangedSignal(void * jarg1) {
+  void * jresult ;
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  Dali::ImfManager::StatusSignalType *result = 0 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  {
+    try {
+      result = (Dali::ImfManager::StatusSignalType *) &(arg1)->StatusChangedSignal();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = (void *)result;
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ResizedSignal(void * jarg1) {
+  void * jresult ;
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  Dali::ImfManager::VoidSignalType *result = 0 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  {
+    try {
+      result = (Dali::ImfManager::VoidSignalType *) &(arg1)->ResizedSignal();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = (void *)result;
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_LanguageChangedSignal(void * jarg1) {
+  void * jresult ;
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+  Dali::ImfManager::VoidSignalType *result = 0 ;
+
+  arg1 = (Dali::ImfManager *)jarg1;
+  {
+    try {
+      result = (Dali::ImfManager::VoidSignalType *) &(arg1)->LanguageChangedSignal();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = (void *)result;
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_0() {
+  void * jresult ;
+  Dali::ImfManager *result = 0 ;
+
+  {
+    try {
+      result = (Dali::ImfManager *)new Dali::ImfManager();
+    } 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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = (void *)result;
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager(void * jarg1) {
+  Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
+
+  arg1 = (Dali::ImfManager *)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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_1(void * jarg1) {
+  void * jresult ;
+  Dali::Internal::Adaptor::ImfManager *arg1 = (Dali::Internal::Adaptor::ImfManager *) 0 ;
+  Dali::ImfManager *result = 0 ;
+
+  arg1 = (Dali::Internal::Adaptor::ImfManager *)jarg1;
+  {
+    try {
+      result = (Dali::ImfManager *)new Dali::ImfManager(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 (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = (void *)result;
+  return jresult;
+}
+
+
+SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ImfManager_SWIGUpcast(Dali::ImfManager *jarg1) {
+    return (Dali::BaseHandle *)jarg1;
+}
+
+
+//////////////////////////////////////////////////
+//from dali-swig autogeneration (from dali_wrap.cpp)
+
+
+
+
+
+
+
+
+
+
+
+
 #ifdef __cplusplus
 }
 #endif