Add APIs for console message & loading error in csharp binder.

This patch is to add some APIs into csharp binder for console
message and loading error.

Change-Id: Ic004650bb124092a98c58601e9629b92901121f8

diff --git a/dali-csharp-binder/src/web-view-signal-converter.h b/dali-csharp-binder/src/web-view-signal-converter.h
index 76a5c5c..5a45ae3 100755 (executable)
--- a/dali-csharp-binder/src/web-view-signal-converter.h
+++ b/dali-csharp-binder/src/web-view-signal-converter.h
@@ -1,7 +1,7 @@
 #ifndef __DALI_CSHARP_BINDER_WEB_VIEW_SIGNAL_CONVERTER_H__
 #define __DALI_CSHARP_BINDER_WEB_VIEW_SIGNAL_CONVERTER_H__
 /*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,8 +18,8 @@
  */
 
 // EXTERNAL INCLUDES
-#include <dali/public-api/signals/connection-tracker.h>
 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
+#include <dali/public-api/signals/connection-tracker.h>
 
 /* Callback for returning strings to C# without leaking memory */
 typedef char* (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char*);
@@ -29,156 +29,101 @@ namespace SignalConverter
 {
 
 // Proxy class of WebViewPageLoadSignal.
-// WebViewPageLoadSignal has an argument of std::string type which is not supported at C# side.
-// The purpose of this class is to convert signal argument of string type safely.
+// WebViewPageLoadSignal has an argument of std::string type which is not
+// supported at C# side. The purpose of this class is to convert signal argument
+// of string type safely.
 class WebViewPageLoadSignal : public Dali::ConnectionTracker
 {
-
 public:
-  using NativeSignalType = Dali::Signal< void( Dali::Toolkit::WebView, const std::string& ) >;
-  using ProxySignalType = Dali::Signal< void( Dali::Toolkit::WebView, char* ) >;
-  using CallbackType = void ( * )( Dali::Toolkit::WebView, char* );
+  using NativeSignalType = Dali::Signal<void(Dali::Toolkit::WebView, const std::string&)>;
+  using ProxySignalType = Dali::Signal<void(Dali::Toolkit::WebView, char*)>;
+  using CallbackType = void (*)(Dali::Toolkit::WebView, char*);
 
-  WebViewPageLoadSignal( NativeSignalType* signal )
-    : mNativeSignalPtr( signal )
+  WebViewPageLoadSignal(NativeSignalType* signal) : mNativeSignalPtr(signal)
   {
   }
 
   ~WebViewPageLoadSignal()
   {
-    if( !mProxySignal.Empty() )
-    {
-      mNativeSignalPtr->Disconnect( this, &SignalConverter::WebViewPageLoadSignal::OnEmit );
-    }
-  }
-
-  void Connect( CallbackType csharpCallback )
-  {
-    if( mNativeSignalPtr->Empty())
-    {
-      mNativeSignalPtr->Connect( this, &SignalConverter::WebViewPageLoadSignal::OnEmit );
-    }
-    mProxySignal.Connect( csharpCallback );
-  }
-
-  void Disconnect( CallbackType csharpCallback )
-  {
-    mProxySignal.Disconnect( csharpCallback );
-    if( mProxySignal.Empty() )
-    {
-      mNativeSignalPtr->Disconnect( this, &SignalConverter::WebViewPageLoadSignal::OnEmit );
-    }
-  }
-
-  void OnEmit( Dali::Toolkit::WebView webview, const std::string& url )
-  {
-    // Safe string conversion
-    mProxySignal.Emit( webview, SWIG_csharp_string_callback( url.c_str() ) );
-  }
-
-private:
-
-  NativeSignalType* mNativeSignalPtr;
-  ProxySignalType   mProxySignal;
-};
-
-// Proxy class of WebViewPageLoadErrorSignal.
-// WebViewPageLoadSignal has an argument of std::string type which is not supported at C# side.
-// The purpose of this class is to convert signal argument of string type safely.
-class WebViewPageLoadErrorSignal : public Dali::ConnectionTracker
-{
-public:
-  using NativeSignalType = Dali::Signal< void( Dali::Toolkit::WebView, const std::string&, Dali::Toolkit::WebView::LoadErrorCode ) >;
-  using ProxySignalType = Dali::Signal< void( Dali::Toolkit::WebView, char*, int ) >;
-  using CallbackType = void ( * )( Dali::Toolkit::WebView, char*, int );
-
-  WebViewPageLoadErrorSignal( NativeSignalType* signal )
-    : mNativeSignalPtr( signal )
-  {
-  }
-
-  ~WebViewPageLoadErrorSignal()
-  {
-    if( !mProxySignal.Empty() )
+    if (!mProxySignal.Empty())
     {
-      mNativeSignalPtr->Disconnect( this, &SignalConverter::WebViewPageLoadErrorSignal::OnEmit );
+      mNativeSignalPtr->Disconnect(this, &SignalConverter::WebViewPageLoadSignal::OnEmit);
     }
   }
 
-  void Connect( CallbackType csharpCallback )
+  void Connect(CallbackType csharpCallback)
   {
-    if( mNativeSignalPtr->Empty() )
+    if (mNativeSignalPtr->Empty())
     {
-      mNativeSignalPtr->Connect( this, &SignalConverter::WebViewPageLoadErrorSignal::OnEmit );
+      mNativeSignalPtr->Connect(this, &SignalConverter::WebViewPageLoadSignal::OnEmit);
     }
-    mProxySignal.Connect( csharpCallback );
+    mProxySignal.Connect(csharpCallback);
   }
 
-  void Disconnect( CallbackType csharpCallback )
+  void Disconnect(CallbackType csharpCallback)
   {
-    mProxySignal.Disconnect( csharpCallback );
-    if( mProxySignal.Empty() )
+    mProxySignal.Disconnect(csharpCallback);
+    if (mProxySignal.Empty())
     {
-      mNativeSignalPtr->Disconnect( this, &SignalConverter::WebViewPageLoadErrorSignal::OnEmit );
+      mNativeSignalPtr->Disconnect(this, &SignalConverter::WebViewPageLoadSignal::OnEmit);
     }
   }
 
-  void OnEmit( Dali::Toolkit::WebView webview, const std::string& url, Dali::Toolkit::WebView::LoadErrorCode code )
+  void OnEmit(Dali::Toolkit::WebView webview, const std::string& url)
   {
     // Safe string conversion
-    mProxySignal.Emit( webview, SWIG_csharp_string_callback( url.c_str() ), static_cast<int>( code ) );
+    mProxySignal.Emit(webview, SWIG_csharp_string_callback(url.c_str()));
   }
 
 private:
-
-  NativeSignalType* mNativeSignalPtr;
-  ProxySignalType   mProxySignal;
+  NativeSignalType *mNativeSignalPtr;
+  ProxySignalType mProxySignal;
 };
 
 // Proxy class of WebViewScrollEdgeReachedSignal.
-// WebViewScrollEdgeReachedSignal has an argument of enum type which is not supported at C# side.
-// The purpose of this class is to convert signal argument of enum type safely.
+// WebViewScrollEdgeReachedSignal has an argument of enum type which is not
+// supported at C# side. The purpose of this class is to convert signal argument
+// of enum type safely.
 class WebViewScrollEdgeReachedSignal : public Dali::ConnectionTracker
 {
 public:
-  using NativeSignalType = Dali::Signal< void( Dali::Toolkit::WebView, Dali::WebEnginePlugin::ScrollEdge ) >;
-  using ProxySignalType = Dali::Signal< void( Dali::Toolkit::WebView, int ) >;
-  using CallbackType = void ( * )( Dali::Toolkit::WebView, int );
+  using NativeSignalType = Dali::Signal<void(Dali::Toolkit::WebView, Dali::WebEnginePlugin::ScrollEdge)>;
+  using ProxySignalType = Dali::Signal<void(Dali::Toolkit::WebView, int)>;
+  using CallbackType = void (*)(Dali::Toolkit::WebView, int);
 
-  WebViewScrollEdgeReachedSignal( NativeSignalType* signal )
-    : mNativeSignalPtr( signal )
+  WebViewScrollEdgeReachedSignal(NativeSignalType *signal) : mNativeSignalPtr(signal)
   {
   }
 
   ~WebViewScrollEdgeReachedSignal()
   {
-    if ( !mProxySignal.Empty() )
+    if (!mProxySignal.Empty())
     {
-       mNativeSignalPtr->Disconnect( this, &SignalConverter::WebViewScrollEdgeReachedSignal::OnEmit );
+      mNativeSignalPtr->Disconnect(this, &SignalConverter::WebViewScrollEdgeReachedSignal::OnEmit);
     }
   }
 
-  void Connect( CallbackType csharpCallback )
+  void Connect(CallbackType csharpCallback)
   {
-    if ( mNativeSignalPtr->Empty() )
+    if (mNativeSignalPtr->Empty())
     {
-       mNativeSignalPtr->Connect( this, &SignalConverter::WebViewScrollEdgeReachedSignal::OnEmit );
+      mNativeSignalPtr->Connect(this, &SignalConverter::WebViewScrollEdgeReachedSignal::OnEmit);
     }
-    mProxySignal.Connect( csharpCallback );
+    mProxySignal.Connect(csharpCallback);
   }
 
-  void Disconnect( CallbackType csharpCallback )
+  void Disconnect(CallbackType csharpCallback)
   {
-    mProxySignal.Disconnect( csharpCallback );
-    if ( mProxySignal.Empty() )
+    mProxySignal.Disconnect(csharpCallback);
+    if (mProxySignal.Empty())
     {
-       mNativeSignalPtr->Disconnect( this, &SignalConverter::WebViewScrollEdgeReachedSignal::OnEmit );
+      mNativeSignalPtr->Disconnect(this, &SignalConverter::WebViewScrollEdgeReachedSignal::OnEmit);
     }
   }
 
-  void OnEmit( Dali::Toolkit::WebView webview, Dali::WebEnginePlugin::ScrollEdge edge )
+  void OnEmit(Dali::Toolkit::WebView webview, Dali::WebEnginePlugin::ScrollEdge edge)
   {
-    mProxySignal.Emit( webview, static_cast< int >( edge ) );
+    mProxySignal.Emit(webview, static_cast<int>(edge));
   }
 
 private:
@@ -192,44 +137,44 @@ private:
 class WebViewUrlChangedSignal : public Dali::ConnectionTracker
 {
 public:
-  using NativeSignalType = Dali::Signal< void( Dali::Toolkit::WebView, const std::string& ) >;
-  using ProxySignalType = Dali::Signal< void( Dali::Toolkit::WebView, char* ) >;
-  using CallbackType = void ( * )( Dali::Toolkit::WebView, char* );
+  using NativeSignalType = Dali::Signal<void(Dali::Toolkit::WebView, const std::string&)>;
+  using ProxySignalType = Dali::Signal<void(Dali::Toolkit::WebView, char*)>;
+  using CallbackType = void (*)(Dali::Toolkit::WebView, char*);
 
-  WebViewUrlChangedSignal( NativeSignalType* signal )
+  WebViewUrlChangedSignal(NativeSignalType* signal)
     : mNativeSignalPtr(signal)
   {
   }
 
   ~WebViewUrlChangedSignal()
   {
-    if ( !mProxySignal.Empty() )
+    if (!mProxySignal.Empty())
     {
-      mNativeSignalPtr->Disconnect( this, &SignalConverter::WebViewUrlChangedSignal::OnEmit );
+      mNativeSignalPtr->Disconnect(this, &SignalConverter::WebViewUrlChangedSignal::OnEmit);
     }
   }
 
-  void Connect( CallbackType csharpCallback )
+  void Connect(CallbackType csharpCallback)
   {
     if ( mNativeSignalPtr->Empty() )
     {
-      mNativeSignalPtr->Connect( this, &SignalConverter::WebViewUrlChangedSignal::OnEmit );
+      mNativeSignalPtr->Connect(this, &SignalConverter::WebViewUrlChangedSignal::OnEmit);
     }
-    mProxySignal.Connect( csharpCallback );
+    mProxySignal.Connect(csharpCallback);
   }
 
-  void Disconnect( CallbackType csharpCallback )
+  void Disconnect(CallbackType csharpCallback)
   {
-    mProxySignal.Disconnect( csharpCallback );
-    if ( mProxySignal.Empty() )
+    mProxySignal.Disconnect(csharpCallback);
+    if (mProxySignal.Empty())
     {
-      mNativeSignalPtr->Disconnect( this, &SignalConverter::WebViewUrlChangedSignal::OnEmit );
+      mNativeSignalPtr->Disconnect(this, &SignalConverter::WebViewUrlChangedSignal::OnEmit);
     }
   }
 
-  void OnEmit( Dali::Toolkit::WebView webview, const std::string& url )
+  void OnEmit(Dali::Toolkit::WebView webview, const std::string& url)
   {
-    mProxySignal.Emit( webview, SWIG_csharp_string_callback( url.c_str() ) );
+    mProxySignal.Emit(webview, SWIG_csharp_string_callback(url.c_str()));
   }
 
 private:

diff --git a/dali-csharp-binder/src/web-view.cpp b/dali-csharp-binder/src/web-view.cpp
index a422ed8..4c8625c 100755 (executable)
--- a/dali-csharp-binder/src/web-view.cpp
+++ b/dali-csharp-binder/src/web-view.cpp
@@ -23,7 +23,6 @@
 
 #include "web-view-signal-converter.h"
 
-#include <dali/devel-api/adaptor-framework/web-engine-request-interceptor.h>
 #include <dali-toolkit/devel-api/controls/web-view/web-back-forward-list-item.h>
 #include <dali-toolkit/devel-api/controls/web-view/web-back-forward-list.h>
 #include <dali-toolkit/devel-api/controls/web-view/web-context.h>
@@ -31,6 +30,9 @@
 #include <dali-toolkit/devel-api/controls/web-view/web-form-repost-decision.h>
 #include <dali-toolkit/devel-api/controls/web-view/web-settings.h>
 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
+#include <dali/devel-api/adaptor-framework/web-engine-console-message.h>
+#include <dali/devel-api/adaptor-framework/web-engine-load-error.h>
+#include <dali/devel-api/adaptor-framework/web-engine-request-interceptor.h>
 #include <dali/public-api/common/dali-common.h>
 
 #define CALL_CATCH_EXCEPTION(ret)                                              \
@@ -983,19 +985,19 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void *
   }
 }
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void* jarg1) {
   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
-  SignalConverter::WebViewPageLoadErrorSignal *result = 0;
+  SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>* result = 0;
   {
     try {
-      result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
+      result = new SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>(&webview->PageLoadErrorSignal());
     } CALL_CATCH_EXCEPTION(0);
   }
-  return (void *)result;
+  return (void*)result;
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1) {
-  SignalConverter::WebViewPageLoadErrorSignal *object = (SignalConverter::WebViewPageLoadErrorSignal *)jarg1;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void* jarg1) {
+  SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>* object = (SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>*)jarg1;
   {
     try {
       delete object;
@@ -1003,9 +1005,9 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void *
   }
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2) {
-  SignalConverter::WebViewPageLoadErrorSignal *proxy = (SignalConverter::WebViewPageLoadErrorSignal *)jarg1;
-  SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType)jarg2;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void* jarg1, void* jarg2) {
+  SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>*)jarg1;
+  SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>::CallbackType)jarg2;
   {
     try {
       proxy->Connect(callback);
@@ -1013,9 +1015,9 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void
   }
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
-  SignalConverter::WebViewPageLoadErrorSignal *proxy = (SignalConverter::WebViewPageLoadErrorSignal *)jarg1;
-  SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType)jarg2;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void* jarg1, void* jarg2) {
+  SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>*)jarg1;
+  SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>::CallbackType)jarg2;
   {
     try {
       proxy->Disconnect(callback);
@@ -1025,7 +1027,7 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(vo
 
 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewScrollEdgeReachedSignal_ScrollEdgeReached(void * jarg1) {
   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
-  SignalConverter::WebViewScrollEdgeReachedSignal *result = 0;
+  SignalConverter::WebViewScrollEdgeReachedSignal* result = 0;
   {
     try {
       result = new SignalConverter::WebViewScrollEdgeReachedSignal(&webview->ScrollEdgeReachedSignal());
@@ -1214,6 +1216,46 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewRequestInterceptorSignal_Disconne
   }
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_WebViewConsoleMessageSignal_ConsoleMessage(void* jarg1) {
+  Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
+  SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>* result = 0;
+  {
+    try {
+      result = new SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>(&webview->ConsoleMessageSignal());
+    } CALL_CATCH_EXCEPTION(0);
+  }
+  return (void*)result;
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewConsoleMessageSignal(void* jarg1) {
+  SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>* object = (SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>*)jarg1;
+  {
+    try {
+      delete object;
+    } CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewConsoleMessageSignal_Connect(void* jarg1, void* jarg2) {
+  SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>*)jarg1;
+  SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>::CallbackType)jarg2;
+  {
+    try {
+      proxy->Connect(callback);
+    } CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewConsoleMessageSignal_Disconnect(void* jarg1, void* jarg2) {
+  SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>*)jarg1;
+  SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>::CallbackType)jarg2;
+  {
+    try {
+      proxy->Disconnect(callback);
+    } CALL_CATCH_EXCEPTION();
+  }
+}
+
 //----------------------------------WebBackForwardList-----------------------------------------------------
 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebBackForwardListItem_GetUrl(void * jarg1) {
   Dali::Toolkit::WebBackForwardListItem *arg1 = (Dali::Toolkit::WebBackForwardListItem *)0;
@@ -1288,6 +1330,53 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetItemAtIndex(void
   return result;
 }
 
+//----------------------------------WebConsoleMessage-----------------------------------------------------
+SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebConsoleMessage_GetSource(void* jarg1) {
+  Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1;
+  std::string result;
+  {
+    try {
+      result = arg1->GetSource();
+    } CALL_CATCH_EXCEPTION(0);
+  }
+  char* jresult = SWIG_csharp_string_callback(result.c_str());
+  return jresult;
+}
+
+SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebConsoleMessage_GetLine(void* jarg1) {
+  Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1;
+  uint32_t result;
+  {
+    try {
+      result = arg1->GetLine();
+    } CALL_CATCH_EXCEPTION(0);
+  }
+  return result;
+}
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebConsoleMessage_GetSeverityLevel(void* jarg1) {
+  Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1;
+  int result;
+  {
+    try {
+      result = (int)arg1->GetSeverityLevel();
+    } CALL_CATCH_EXCEPTION(0);
+  }
+  return result;
+}
+
+SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebConsoleMessage_GetText(void* jarg1) {
+  Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1;
+  std::string result;
+  {
+    try {
+      result = arg1->GetText();
+    } CALL_CATCH_EXCEPTION(0);
+  }
+  char* jresult = SWIG_csharp_string_callback(result.c_str());
+  return jresult;
+}
+
 //----------------------------------WebContext-----------------------------------------------------
 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebContext_GetCacheModel(void * jarg1) {
   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
@@ -1525,6 +1614,53 @@ SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_AddResponseBody(vo
   return ret;
 }
 
+//----------------------------------WebLoadError-----------------------------------------------------
+SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebLoadError_GetUrl(void* jarg1) {
+  Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1;
+  std::string result;
+  {
+    try {
+      result = arg1->GetUrl();
+    } CALL_CATCH_EXCEPTION(0);
+  }
+  char* jresult = SWIG_csharp_string_callback(result.c_str());
+  return jresult;
+}
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebLoadError_GetCode(void* jarg1) {
+  Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1;
+  int result;
+  {
+    try {
+      result = (int)arg1->GetCode();
+    } CALL_CATCH_EXCEPTION(0);
+  }
+  return result;
+}
+
+SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebLoadError_GetDescription(void* jarg1) {
+  Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1;
+  std::string result;
+  {
+    try {
+      result = arg1->GetDescription();
+    } CALL_CATCH_EXCEPTION(0);
+  }
+  char* jresult = SWIG_csharp_string_callback(result.c_str());
+  return jresult;
+}
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebLoadError_GetType(void* jarg1) {
+  Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1;
+  int result;
+  {
+    try {
+      result = (int)arg1->GetType();
+    } CALL_CATCH_EXCEPTION(0);
+  }
+  return result;
+}
+
 //----------------------------------WebSettings---------------------------------------------------
 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_AllowMixedContents(void * jarg1, bool jarg2) {
   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;