dali-csharp-binder/src/web-view.cpp

   1 /** Copyright (c) 2021 Samsung Electronics Co., Ltd.
   2  *
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at
   6  *
   7  * http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  *
  15  */
  16
  17 #ifndef CSHARP_WEB_VIEW
  18 #define CSHARP_WEB_VIEW
  19 #endif
  20
  21 // EXTERNAL INCLUDES
  22 #include "common.h"
  23
  24 #include "web-view-signal-converter.h"
  25
  26 #include <dali-toolkit/devel-api/controls/web-view/web-back-forward-list.h>
  27 #include <dali-toolkit/devel-api/controls/web-view/web-context.h>
  28 #include <dali-toolkit/devel-api/controls/web-view/web-cookie-manager.h>
  29 #include <dali-toolkit/devel-api/controls/web-view/web-settings.h>
  30 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
  31 #include <dali/devel-api/adaptor-framework/web-engine-certificate.h>
  32 #include <dali/devel-api/adaptor-framework/web-engine-context-menu.h>
  33 #include <dali/devel-api/adaptor-framework/web-engine-context-menu-item.h>
  34 #include <dali/devel-api/adaptor-framework/web-engine-console-message.h>
  35 #include <dali/devel-api/adaptor-framework/web-engine-form-repost-decision.h>
  36 #include <dali/devel-api/adaptor-framework/web-engine-frame.h>
  37 #include <dali/devel-api/adaptor-framework/web-engine-hit-test.h>
  38 #include <dali/devel-api/adaptor-framework/web-engine-http-auth-handler.h>
  39 #include <dali/devel-api/adaptor-framework/web-engine-load-error.h>
  40 #include <dali/devel-api/adaptor-framework/web-engine-policy-decision.h>
  41 #include <dali/devel-api/adaptor-framework/web-engine-request-interceptor.h>
  42 #include <dali/devel-api/adaptor-framework/web-engine-security-origin.h>
  43 #include <dali/devel-api/adaptor-framework/web-engine-back-forward-list-item.h>
  44 #include <dali/public-api/common/dali-common.h>
  45
  46 #define CALL_CATCH_EXCEPTION(ret)                                              \
  47   catch (std::out_of_range & e) {                                              \
  48     SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));       \
  49     return ret;                                                                \
  50   }                                                                            \
  51   catch (std::exception & e) {                                                 \
  52     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what()));     \
  53     return ret;                                                                \
  54   }                                                                            \
  55   catch (Dali::DaliException e) {                                              \
  56     SWIG_CSharpException(SWIG_UnknownError, e.condition);                      \
  57     return ret;                                                                \
  58   }                                                                            \
  59   catch (...) {                                                                \
  60     SWIG_CSharpException(SWIG_UnknownError, "unknown error");                  \
  61     return ret;                                                                \
  62   }
  63
  64 /* Callback for returning strings to C# without leaking memory */
  65 typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char*);
  66 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
  67
  68 #ifdef __cplusplus
  69 extern "C" {
  70 #endif
  71
  72 //----------------------------------WebView---------------------------------------------------
  73 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
  74   void * jresult;
  75   Dali::Toolkit::WebView result;
  76
  77   {
  78     try {
  79       result = Dali::Toolkit::WebView::New();
  80     } CALL_CATCH_EXCEPTION(0);
  81   }
  82   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView&)result);
  83   return jresult;
  84 }
  85
  86 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
  87   void * jresult;
  88   Dali::Toolkit::WebView result;
  89
  90   std::string *arg1;
  91   std::string *arg2;
  92
  93   if (!jarg1) {
  94     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
  95     return 0;
  96   }
  97   if (!jarg2) {
  98     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
  99     return 0;
 100   }
 101
 102   std::string jarg1_str = std::string(jarg1);
 103   std::string jarg2_str = std::string(jarg2);
 104
 105   arg1 = &jarg1_str;
 106   arg2 = &jarg2_str;
 107
 108   {
 109     try {
 110       result = Dali::Toolkit::WebView::New((std::string const &)*arg1, (std::string const &)*arg2);
 111     } CALL_CATCH_EXCEPTION(0);
 112   }
 113   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView&)result);
 114   return jresult;
 115 }
 116
 117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_3(uint32_t jarg1, char ** jarg2) {
 118   if (!jarg2) {
 119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
 120     return 0;
 121   }
 122
 123   Dali::Toolkit::WebView result;
 124   {
 125     try {
 126       result = Dali::Toolkit::WebView::New(jarg1, jarg2);
 127     } CALL_CATCH_EXCEPTION(0);
 128   }
 129   void * jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
 130   return jresult;
 131 }
 132
 133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
 134   void * jresult;
 135   Dali::Toolkit::WebView* arg1 = 0;
 136   Dali::Toolkit::WebView* result = 0;
 137
 138   arg1 = (Dali::Toolkit::WebView*)jarg1;
 139   if (!arg1) {
 140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
 141     return 0;
 142   }
 143   {
 144     try {
 145       result = (Dali::Toolkit::WebView*)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
 146     } CALL_CATCH_EXCEPTION(0);
 147   }
 148   jresult = (void *)result;
 149   return jresult;
 150 }
 151
 152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
 153   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 154   arg1 = (Dali::Toolkit::WebView*)jarg1;
 155   {
 156     try {
 157       delete arg1;
 158     } CALL_CATCH_EXCEPTION();
 159   }
 160 }
 161
 162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
 163   void * jresult;
 164   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 165   Dali::Toolkit::WebView* arg2 = 0;
 166   Dali::Toolkit::WebView* result = 0;
 167
 168   arg1 = (Dali::Toolkit::WebView*)jarg1;
 169   arg2 = (Dali::Toolkit::WebView*)jarg2;
 170   if (!arg2) {
 171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
 172     return 0;
 173   }
 174   {
 175     try {
 176       result = (Dali::Toolkit::WebView*)&(arg1)->operator=((Dali::Toolkit::WebView const &)*arg2);
 177     } CALL_CATCH_EXCEPTION(0);
 178   }
 179   jresult = (void *)result;
 180   return jresult;
 181 }
 182
 183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
 184   void * jresult;
 185   Dali::BaseHandle arg1;
 186   Dali::BaseHandle* argp1;
 187   Dali::Toolkit::WebView result;
 188
 189   argp1 = (Dali::BaseHandle*)jarg1;
 190   if (!argp1) {
 191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
 192     return 0;
 193   }
 194   arg1 = *argp1;
 195   {
 196     try {
 197       result = Dali::Toolkit::WebView::DownCast(arg1);
 198     } CALL_CATCH_EXCEPTION(0);
 199   }
 200   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView&)result);
 201   return jresult;
 202 }
 203
 204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_GetBackForwardList(void * jarg1) {
 205   void * jresult;
 206   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 207   Dali::Toolkit::WebBackForwardList *result = 0;
 208
 209   arg1 = (Dali::Toolkit::WebView*)jarg1;
 210
 211   {
 212     try {
 213       result = arg1->GetBackForwardList();
 214     } CALL_CATCH_EXCEPTION(0);
 215   }
 216
 217   jresult = (void *)result;
 218   return jresult;
 219 }
 220
 221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_GetContext(void * jarg1) {
 222   void * jresult;
 223   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 224   Dali::Toolkit::WebContext *result = 0;
 225
 226   arg1 = (Dali::Toolkit::WebView*)jarg1;
 227
 228   {
 229     try {
 230       result = arg1->GetContext();
 231     } CALL_CATCH_EXCEPTION(0);
 232   }
 233
 234   jresult = (void *)result;
 235   return jresult;
 236 }
 237
 238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_GetCookieManager(void * jarg1) {
 239   void * jresult;
 240   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 241   Dali::Toolkit::WebCookieManager *result = 0;
 242
 243   arg1 = (Dali::Toolkit::WebView*)jarg1;
 244
 245   {
 246     try {
 247       result = arg1->GetCookieManager();
 248     } CALL_CATCH_EXCEPTION(0);
 249   }
 250
 251   jresult = (void *)result;
 252   return jresult;
 253 }
 254
 255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_GetSettings(void * jarg1) {
 256   void * jresult;
 257   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 258   Dali::Toolkit::WebSettings *result = 0;
 259
 260   arg1 = (Dali::Toolkit::WebView*)jarg1;
 261
 262   {
 263     try {
 264       result = arg1->GetSettings();
 265     } CALL_CATCH_EXCEPTION(0);
 266   }
 267
 268   jresult = (void *)result;
 269   return jresult;
 270 }
 271
 272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
 273   return (int)Dali::Toolkit::WebView::Property::URL;
 274 }
 275
 276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_SCROLL_POSITION_get() {
 277   return (int)Dali::Toolkit::WebView::Property::SCROLL_POSITION;
 278 }
 279
 280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_SCROLL_SIZE_get() {
 281   return (int)Dali::Toolkit::WebView::Property::SCROLL_SIZE;
 282 }
 283
 284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CONTENT_SIZE_get() {
 285   return (int)Dali::Toolkit::WebView::Property::CONTENT_SIZE;
 286 }
 287
 288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_TITLE_get() {
 289   return (int)Dali::Toolkit::WebView::Property::TITLE;
 290 }
 291
 292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_VIDEO_HOLE_ENABLED_get() {
 293   return (int)Dali::Toolkit::WebView::Property::VIDEO_HOLE_ENABLED;
 294 }
 295
 296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_MOUSE_EVENTS_ENABLED_get() {
 297   return (int) Dali::Toolkit::WebView::Property::MOUSE_EVENTS_ENABLED;
 298 }
 299
 300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_KEY_EVENTS_ENABLED_get() {
 301   return (int) Dali::Toolkit::WebView::Property::KEY_EVENTS_ENABLED;
 302 }
 303
 304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DOCUMENT_BACKGROUND_COLOR_get() {
 305   return (int)Dali::Toolkit::WebView::Property::DOCUMENT_BACKGROUND_COLOR;
 306 }
 307
 308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_TILES_CLEARED_WHEN_HIDDEN_get() {
 309   return (int)Dali::Toolkit::WebView::Property::TILES_CLEARED_WHEN_HIDDEN;
 310 }
 311
 312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_TILE_COVER_AREA_MULTIPLIER_get() {
 313   return (int)Dali::Toolkit::WebView::Property::TILE_COVER_AREA_MULTIPLIER;
 314 }
 315
 316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CURSOR_ENABLED_BY_CLIENT_get() {
 317   return (int)Dali::Toolkit::WebView::Property::CURSOR_ENABLED_BY_CLIENT;
 318 }
 319
 320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_SELECTED_TEXT_get() {
 321   return (int)Dali::Toolkit::WebView::Property::SELECTED_TEXT;
 322 }
 323
 324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_PAGE_ZOOM_FACTOR_get() {
 325   return (int)Dali::Toolkit::WebView::Property::PAGE_ZOOM_FACTOR;
 326 }
 327
 328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_TEXT_ZOOM_FACTOR_get() {
 329   return (int)Dali::Toolkit::WebView::Property::TEXT_ZOOM_FACTOR;
 330 }
 331
 332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_PROGRESS_PERCENTAGE_get() {
 333   return (int)Dali::Toolkit::WebView::Property::LOAD_PROGRESS_PERCENTAGE;
 334 }
 335
 336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
 337   return (int)Dali::Toolkit::WebView::Property::USER_AGENT;
 338 }
 339
 340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
 341   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 342   std::string *arg2;
 343
 344   arg1 = (Dali::Toolkit::WebView*)jarg1;
 345
 346   if (!jarg2) {
 347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 348     return;
 349   }
 350
 351   std::string jarg2str = std::string(jarg2);
 352   arg2 = &jarg2str;
 353   {
 354     try {
 355       (arg1)->LoadUrl((std::string const &)*arg2);
 356     } CALL_CATCH_EXCEPTION();
 357   }
 358 }
 359
 360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHtmlString(void * jarg1, char * jarg2) {
 361   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 362   std::string *arg2;
 363
 364   arg1 = (Dali::Toolkit::WebView*)jarg1;
 365   if (!jarg2) {
 366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 367     return;
 368   }
 369   std::string jarg2str = std::string(jarg2);
 370   arg2 = &jarg2str;
 371   {
 372     try {
 373       (arg1)->LoadHtmlString((std::string const &)*arg2);
 374     } CALL_CATCH_EXCEPTION();
 375   }
 376 }
 377
 378 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_LoadHtmlStringOverrideCurrentEntry(void * jarg1, const char *jarg2, const char *jarg3, const char *jarg4) {
 379   if (!jarg2 || !jarg3 || !jarg4) {
 380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 381     return false;
 382   }
 383
 384   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 385   std::string jarg2str = std::string(jarg2);
 386   std::string jarg3str = std::string(jarg3);
 387   std::string jarg4str = std::string(jarg4);
 388   bool result = false;
 389   {
 390     try {
 391       result = (arg1)->LoadHtmlStringOverrideCurrentEntry(jarg2str, jarg3str, jarg4str);
 392     } CALL_CATCH_EXCEPTION(0);
 393   }
 394   return result;
 395 }
 396
 397 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_LoadContents(void * jarg1, const char *jarg2, uint32_t jarg3, const char *jarg4, const char *jarg5, const char *jarg6) {
 398   if (!jarg2 || !jarg4 || !jarg5 || !jarg6) {
 399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 400     return false;
 401   }
 402
 403   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 404   std::string jarg2str = std::string(jarg2);
 405   std::string jarg4str = std::string(jarg4);
 406   std::string jarg5str = std::string(jarg5);
 407   std::string jarg6str = std::string(jarg6);
 408   bool result = false;
 409   {
 410     try {
 411       result = (arg1)->LoadContents(jarg2str, jarg3, jarg4str, jarg5str, jarg6str);
 412     } CALL_CATCH_EXCEPTION(0);
 413   }
 414   return result;
 415 }
 416
 417 SWIGEXPORT const void * SWIGSTDCALL CSharp_Dali_WebView_GetFavicon(void * jarg1) {
 418   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1;
 419   Dali::Toolkit::ImageView* result = 0;
 420   {
 421     try {
 422       Dali::Toolkit::ImageView favicon = (arg1)->GetFavicon();
 423       if (favicon)
 424       {
 425         result = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)favicon);
 426       }
 427     } CALL_CATCH_EXCEPTION(0);
 428   }
 429   return result;
 430 }
 431
 432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
 433   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 434
 435   arg1 = (Dali::Toolkit::WebView*)jarg1;
 436   {
 437     try {
 438       (arg1)->Reload();
 439     } CALL_CATCH_EXCEPTION();
 440   }
 441 }
 442
 443 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_ReloadWithoutCache(void * jarg1) {
 444   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 445   bool result = false;
 446   {
 447     try {
 448       result = (arg1)->ReloadWithoutCache();
 449     } CALL_CATCH_EXCEPTION(0);
 450   }
 451   return result;
 452 }
 453
 454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
 455   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 456
 457   arg1 = (Dali::Toolkit::WebView*)jarg1;
 458   {
 459     try {
 460       (arg1)->StopLoading();
 461     } CALL_CATCH_EXCEPTION();
 462   }
 463 }
 464
 465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
 466   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 467
 468   arg1 = (Dali::Toolkit::WebView*)jarg1;
 469   {
 470     try {
 471       (arg1)->Suspend();
 472     } CALL_CATCH_EXCEPTION();
 473   }
 474 }
 475
 476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
 477   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 478
 479   arg1 = (Dali::Toolkit::WebView*)jarg1;
 480   {
 481     try {
 482       (arg1)->Resume();
 483     } CALL_CATCH_EXCEPTION();
 484   }
 485 }
 486
 487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_SuspendNetworkLoading(void * jarg1) {
 488   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 489   {
 490     try {
 491       (arg1)->SuspendNetworkLoading();
 492     } CALL_CATCH_EXCEPTION();
 493   }
 494 }
 495
 496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ResumeNetworkLoading(void * jarg1) {
 497   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 498   {
 499     try {
 500       (arg1)->ResumeNetworkLoading();
 501     } CALL_CATCH_EXCEPTION();
 502   }
 503 }
 504
 505 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_AddCustomHeader(void * jarg1, const char *jarg2, const char *jarg3) {
 506   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 507   std::string jarg2str = std::string(jarg2);
 508   std::string jarg3str = std::string(jarg3);
 509   bool result = false;
 510   {
 511     try {
 512       result = (arg1)->AddCustomHeader(jarg2str, jarg3str);
 513     } CALL_CATCH_EXCEPTION(0);
 514   }
 515   return result;
 516 }
 517
 518 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_RemoveCustomHeader(void * jarg1, const char *jarg2) {
 519   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 520   std::string jarg2str = std::string(jarg2);
 521   bool result = false;
 522   {
 523     try {
 524       result = (arg1)->RemoveCustomHeader(jarg2str);
 525     } CALL_CATCH_EXCEPTION(0);
 526   }
 527   return result;
 528 }
 529
 530 SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebView_StartInspectorServer(void * jarg1, uint32_t jarg2) {
 531   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 532   uint32_t result = 0;
 533   {
 534     try {
 535       result = (arg1)->StartInspectorServer(jarg2);
 536     } CALL_CATCH_EXCEPTION(0);
 537   }
 538   return result;
 539 }
 540
 541 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_StopInspectorServer(void * jarg1) {
 542   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 543   bool result = false;
 544   {
 545     try {
 546       result = (arg1)->StopInspectorServer();
 547     } CALL_CATCH_EXCEPTION(0);
 548   }
 549   return result;
 550 }
 551
 552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ScrollBy(void * jarg1, int32_t jarg2, int32_t jarg3) {
 553   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 554   arg1 = (Dali::Toolkit::WebView*)jarg1;
 555   {
 556     try {
 557       (arg1)->ScrollBy(jarg2, jarg3);
 558     } CALL_CATCH_EXCEPTION();
 559   }
 560 }
 561
 562 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_ScrollEdgeBy(void * jarg1, int32_t jarg2, int32_t jarg3) {
 563   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 564   bool result = false;
 565   {
 566     try {
 567       result = (arg1)->ScrollEdgeBy(jarg2, jarg3);
 568     } CALL_CATCH_EXCEPTION(0);
 569   }
 570   return result;
 571 }
 572
 573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
 574   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 575
 576   arg1 = (Dali::Toolkit::WebView*)jarg1;
 577   {
 578     try {
 579       (arg1)->GoBack();
 580     } CALL_CATCH_EXCEPTION();
 581   }
 582 }
 583
 584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
 585   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 586
 587   arg1 = (Dali::Toolkit::WebView*)jarg1;
 588   {
 589     try {
 590       (arg1)->GoForward();
 591     } CALL_CATCH_EXCEPTION();
 592   }
 593 }
 594
 595 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
 596   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 597   bool ret;
 598
 599   arg1 = (Dali::Toolkit::WebView*)jarg1;
 600   {
 601     try {
 602       ret = (arg1)->CanGoBack();
 603     } CALL_CATCH_EXCEPTION(0);
 604   }
 605   return ret;
 606 }
 607
 608 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
 609   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 610   bool ret;
 611
 612   arg1 = (Dali::Toolkit::WebView*)jarg1;
 613   {
 614     try {
 615       ret = (arg1)->CanGoForward();
 616     } CALL_CATCH_EXCEPTION(0);
 617   }
 618   return ret;
 619 }
 620
 621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void * jarg3) {
 622   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 623   std::string *arg2;
 624
 625   arg1 = (Dali::Toolkit::WebView*)jarg1;
 626   if (!jarg2) {
 627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 628     return;
 629   }
 630   std::string jarg2_str = std::string(jarg2);
 631   arg2 = &jarg2_str;
 632
 633   {
 634     try {
 635       if (jarg3) {
 636         void (*handler)(char *) = (void (*)(char *))jarg3;
 637         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string &result) {
 638               handler(SWIG_csharp_string_callback(result.c_str()));
 639             });
 640       }
 641       else {
 642         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
 643       }
 644     } CALL_CATCH_EXCEPTION();
 645   }
 646 }
 647
 648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void * jarg1, char * jarg2, void * jarg3) {
 649   if (!jarg2) {
 650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 651     return;
 652   }
 653
 654   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
 655   std::string exposedObjectName = jarg2;
 656   void (*handler)(char*) = (void (*)(char*))jarg3;
 657
 658   {
 659     try {
 660       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string &message) {
 661             handler(SWIG_csharp_string_callback(message.c_str()));
 662           });
 663     } CALL_CATCH_EXCEPTION();
 664   }
 665 }
 666
 667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterJavaScriptAlertCallback(void * jarg1, void * jarg2) {
 668   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
 669   bool (*handler)(char*) = (bool (*)(char*))jarg2;
 670   {
 671     try {
 672       webview->RegisterJavaScriptAlertCallback([handler](const std::string &message) -> bool {
 673             return handler(SWIG_csharp_string_callback(message.c_str()));
 674           });
 675     } CALL_CATCH_EXCEPTION();
 676   }
 677 }
 678
 679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_JavaScriptAlertReply(void * jarg1) {
 680   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1;
 681   {
 682     try {
 683       (arg1)->JavaScriptAlertReply();
 684     } CALL_CATCH_EXCEPTION();
 685   }
 686 }
 687
 688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterJavaScriptConfirmCallback(void * jarg1, void * jarg2) {
 689   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
 690   bool (*handler)(char*) = (bool (*)(char*))jarg2;
 691
 692   {
 693     try {
 694       webview->RegisterJavaScriptConfirmCallback([handler](const std::string &message) -> bool {
 695             return handler(SWIG_csharp_string_callback(message.c_str()));
 696           });
 697     } CALL_CATCH_EXCEPTION();
 698   }
 699 }
 700
 701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_JavaScriptConfirmReply(void * jarg1, bool jarg2) {
 702   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1;
 703   {
 704     try {
 705       (arg1)->JavaScriptConfirmReply(jarg2);
 706     } CALL_CATCH_EXCEPTION();
 707   }
 708 }
 709
 710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterJavaScriptPromptCallback(void * jarg1, void * jarg2) {
 711   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
 712   bool (*handler)(char *, char*) = (bool (*)(char *, char*))jarg2;
 713
 714   {
 715     try {
 716       webview->RegisterJavaScriptPromptCallback([handler](const std::string &message1,
 717                     const std::string &message2) -> bool {
 718             return handler(SWIG_csharp_string_callback(message1.c_str()),
 719                            SWIG_csharp_string_callback(message2.c_str()));
 720           });
 721     } CALL_CATCH_EXCEPTION();
 722   }
 723 }
 724
 725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_JavaScriptPromptReply(void * jarg1, char * jarg2) {
 726   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1;
 727   std::string jarg2str = std::string(jarg2);
 728   {
 729     try {
 730       (arg1)->JavaScriptPromptReply(jarg2str);
 731     } CALL_CATCH_EXCEPTION();
 732   }
 733 }
 734
 735 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WebView_CreateHitTest(void * jarg1, int32_t jarg2, int32_t jarg3, int jarg4) {
 736   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1;
 737   Dali::WebEngineHitTest* result = 0;
 738   {
 739     try {
 740       std::unique_ptr<Dali::WebEngineHitTest> hitTest = (arg1)->CreateHitTest(jarg2, jarg3, (Dali::WebEngineHitTest::HitTestMode)jarg4);
 741       result = hitTest.release();
 742     } CALL_CATCH_EXCEPTION(0);
 743   }
 744   return (void *)result;
 745 }
 746
 747 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CreateHitTestAsynchronously(void * jarg1, int32_t jarg2, int32_t jarg3, int jarg4, void * jarg5) {
 748   Dali::Toolkit::WebView *webview = (Dali::Toolkit::WebView *)jarg1;
 749   bool (*handler)(Dali::WebEngineHitTest*) = (bool (*)(Dali::WebEngineHitTest*))jarg5;
 750   bool result = false;
 751   {
 752     try {
 753       result = webview->CreateHitTestAsynchronously(jarg2, jarg3, (Dali::WebEngineHitTest::HitTestMode)jarg4,
 754           [handler](std::unique_ptr<Dali::WebEngineHitTest> hitTest) -> bool {
 755             return handler(hitTest.release());
 756           });
 757     } CALL_CATCH_EXCEPTION(0);
 758   }
 759   return result;
 760 }
 761
 762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
 763   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0;
 764
 765   arg1 = (Dali::Toolkit::WebView*)jarg1;
 766   {
 767     try {
 768       (arg1)->ClearHistory();
 769     } CALL_CATCH_EXCEPTION();
 770   }
 771 }
 772
 773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearAllTilesResources(void * jarg1) {
 774   Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1;
 775   {
 776     try {
 777       (arg1)->ClearAllTilesResources();
 778     } CALL_CATCH_EXCEPTION();
 779   }
 780 }
 781
 782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_SetScaleFactor(void * jarg1, float jarg2, void * jarg3) {
 783   if (!jarg3) {
 784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 is null", 0);
 785     return;
 786   }
 787
 788   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 789   Dali::Vector2 *arg3 = (Dali::Vector2 *)jarg3;
 790   {
 791     try {
 792       (arg1)->SetScaleFactor(jarg2, *arg3);
 793     } CALL_CATCH_EXCEPTION();
 794   }
 795 }
 796
 797 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WebView_GetScaleFactor(void * jarg1) {
 798   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 799   float result = 0.0f;
 800   {
 801     try {
 802       result = (arg1)->GetScaleFactor();
 803     } CALL_CATCH_EXCEPTION(0);
 804   }
 805   return result;
 806 }
 807
 808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ActivateAccessibility(void * jarg1, bool jarg2) {
 809   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 810   {
 811     try {
 812       (arg1)->ActivateAccessibility(jarg2);
 813     } CALL_CATCH_EXCEPTION();
 814   }
 815 }
 816
 817 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_HighlightText(void * jarg1, const char *jarg2, int jarg3, uint32_t jarg4) {
 818   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 819   std::string jarg2str = std::string(jarg2);
 820   bool result = false;
 821   {
 822     try {
 823       result = (arg1)->HighlightText(
 824           jarg2str, (Dali::WebEnginePlugin::FindOption)jarg3, jarg4);
 825     } CALL_CATCH_EXCEPTION(0);
 826   }
 827   return result;
 828 }
 829
 830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddDynamicCertificatePath(void * jarg1, const char *jarg2, const char *jarg3) {
 831   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 832   std::string jarg2str = std::string(jarg2);
 833   std::string jarg3str = std::string(jarg3);
 834   {
 835     try {
 836       (arg1)->AddDynamicCertificatePath(jarg2str, jarg3str);
 837     } CALL_CATCH_EXCEPTION();
 838   }
 839 }
 840
 841 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WebView_GetScreenshot(void * jarg1, void * jarg2, float jarg3) {
 842   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 843   Dali::Rect<int32_t> *arg = (Dali::Rect<int32_t> *)jarg2;
 844   Dali::Toolkit::ImageView* result = 0;
 845   {
 846     try {
 847       Dali::Toolkit::ImageView screenshot = (arg1)->GetScreenshot(*arg, jarg3);
 848       if (screenshot)
 849       {
 850         result = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)screenshot);
 851       }
 852     } CALL_CATCH_EXCEPTION(0);
 853   }
 854   return result;
 855 }
 856
 857 using SWIG_CallbackWebViewScreenshotCaptured = void(SWIGSTDCALL *)(Dali::Toolkit::ImageView *);
 858 SWIG_CallbackWebViewScreenshotCaptured swig_callbackOnWebViewScreenshotCaptured;
 859
 860 void OnWebViewScreenshotCapturedCallback(Dali::Toolkit::ImageView imageView) {
 861   if (!imageView)
 862     return;
 863
 864   Dali::Toolkit::ImageView* pImageView = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)imageView);
 865   swig_callbackOnWebViewScreenshotCaptured(pImageView);
 866 }
 867
 868 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_GetScreenshotAsynchronously(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
 869   swig_callbackOnWebViewScreenshotCaptured = (SWIG_CallbackWebViewScreenshotCaptured)jarg4;
 870   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 871   Dali::Rect<int32_t> *arg2 = (Dali::Rect<int32_t> *)jarg2;
 872   Dali::Toolkit::WebView::WebViewScreenshotCapturedCallback callback = OnWebViewScreenshotCapturedCallback;
 873   bool result;
 874   {
 875     try {
 876       result = (arg1)->GetScreenshotAsynchronously(*arg2, jarg3, callback);
 877     } CALL_CATCH_EXCEPTION(0);
 878   }
 879   return result;
 880 }
 881
 882 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CheckVideoPlayingAsynchronously(void * jarg1, void * jarg2) {
 883   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 884   void (*handler)(bool) = (void (*)(bool))jarg2;
 885   bool result;
 886   {
 887     try {
 888       result = (arg1)->CheckVideoPlayingAsynchronously([handler](bool isPlaying) { handler(isPlaying); });
 889     } CALL_CATCH_EXCEPTION(0);
 890   }
 891   return result;
 892 }
 893
 894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterGeolocationPermissionCallback(void * jarg1, void * jarg2) {
 895   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1;
 896   bool (*handler)(char *, char *) = (bool (*)(char *, char *))jarg2;
 897   {
 898     try {
 899       (arg1)->RegisterGeolocationPermissionCallback([handler](const std::string &host, const std::string &protocol) -> bool {
 900             return handler(SWIG_csharp_string_callback(host.c_str()),
 901                            SWIG_csharp_string_callback(protocol.c_str()));
 902           });
 903     } CALL_CATCH_EXCEPTION();
 904   }
 905 }
 906
 907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_SetTtsFocus(void* jarg1, bool jarg2) {
 908   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
 909   try {
 910     webview->SetTtsFocus(jarg2);
 911   } CALL_CATCH_EXCEPTION();
 912 }
 913
 914 SWIGEXPORT Dali::Toolkit::Control *SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView* jarg1) {
 915   return (Dali::Toolkit::Control*)jarg1;
 916 }
 917
 918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
 919   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
 920   SignalConverter::WebViewPageLoadSignal *result = 0;
 921   {
 922     try {
 923       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
 924     } CALL_CATCH_EXCEPTION(0);
 925   }
 926   return (void *)result;
 927 }
 928
 929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadInProgress(void * jarg1) {
 930   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
 931   SignalConverter::WebViewPageLoadSignal *result = 0;
 932   {
 933     try {
 934       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadInProgressSignal());
 935     } CALL_CATCH_EXCEPTION(0);
 936   }
 937   return (void *)result;
 938 }
 939
 940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
 941   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
 942   SignalConverter::WebViewPageLoadSignal *result = 0;
 943   {
 944     try {
 945       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
 946     } CALL_CATCH_EXCEPTION(0);
 947   }
 948   return (void *)result;
 949 }
 950
 951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1) {
 952   SignalConverter::WebViewPageLoadSignal *object = (SignalConverter::WebViewPageLoadSignal*)jarg1;
 953   {
 954     try {
 955       delete object;
 956     } CALL_CATCH_EXCEPTION();
 957   }
 958 }
 959
 960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2) {
 961   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*)jarg1;
 962   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType)jarg2;
 963   {
 964     try {
 965       proxy->Connect(callback);
 966     } CALL_CATCH_EXCEPTION();
 967   }
 968 }
 969
 970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
 971   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*)jarg1;
 972   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType)jarg2;
 973   {
 974     try {
 975       proxy->Disconnect(callback);
 976     } CALL_CATCH_EXCEPTION();
 977   }
 978 }
 979
 980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
 981   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
 982   SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>* result = 0;
 983   {
 984     try {
 985       result = new SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>(&webview->PageLoadErrorSignal());
 986     } CALL_CATCH_EXCEPTION(0);
 987   }
 988   return (void*)result;
 989 }
 990
 991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1) {
 992   SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>* object = (SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>*)jarg1;
 993   {
 994     try {
 995       delete object;
 996     } CALL_CATCH_EXCEPTION();
 997   }
 998 }
 999
1000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2) {
1001   SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>*)jarg1;
1002   SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>::CallbackType)jarg2;
1003   {
1004     try {
1005       proxy->Connect(callback);
1006     } CALL_CATCH_EXCEPTION();
1007   }
1008 }
1009
1010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
1011   SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>*)jarg1;
1012   SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineLoadError>::CallbackType)jarg2;
1013   {
1014     try {
1015       proxy->Disconnect(callback);
1016     } CALL_CATCH_EXCEPTION();
1017   }
1018 }
1019
1020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewScrollEdgeReachedSignal_ScrollEdgeReached(void * jarg1) {
1021   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
1022   SignalConverter::WebViewScrollEdgeReachedSignal* result = 0;
1023   {
1024     try {
1025       result = new SignalConverter::WebViewScrollEdgeReachedSignal(&webview->ScrollEdgeReachedSignal());
1026     } CALL_CATCH_EXCEPTION(0);
1027   }
1028   return (void *)result;
1029 }
1030
1031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewScrollEdgeReachedSignal(void * jarg1) {
1032   SignalConverter::WebViewScrollEdgeReachedSignal*object = (SignalConverter::WebViewScrollEdgeReachedSignal*)jarg1;
1033   {
1034     try {
1035       delete object;
1036     } CALL_CATCH_EXCEPTION();
1037   }
1038 }
1039
1040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewScrollEdgeReachedSignal_Connect(void * jarg1, void * jarg2) {
1041   SignalConverter::WebViewScrollEdgeReachedSignal* proxy = (SignalConverter::WebViewScrollEdgeReachedSignal*)jarg1;
1042   SignalConverter::WebViewScrollEdgeReachedSignal::CallbackType callback = (SignalConverter::WebViewScrollEdgeReachedSignal::CallbackType)jarg2;
1043   {
1044     try {
1045       proxy->Connect(callback);
1046     } CALL_CATCH_EXCEPTION();
1047   }
1048 }
1049
1050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewScrollEdgeReachedSignal_Disconnect(void * jarg1, void * jarg2) {
1051   SignalConverter::WebViewScrollEdgeReachedSignal* proxy = (SignalConverter::WebViewScrollEdgeReachedSignal*)jarg1;
1052   SignalConverter::WebViewScrollEdgeReachedSignal::CallbackType callback = (SignalConverter::WebViewScrollEdgeReachedSignal::CallbackType)jarg2;
1053   {
1054     try {
1055       proxy->Disconnect(callback);
1056     } CALL_CATCH_EXCEPTION();
1057   }
1058 }
1059
1060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewUrlChangedSignal_UrlChanged(void * jarg1) {
1061   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
1062   SignalConverter::WebViewUrlChangedSignal* result = 0;
1063   {
1064     try {
1065       result = new SignalConverter::WebViewUrlChangedSignal(&webview->UrlChangedSignal());
1066     } CALL_CATCH_EXCEPTION(0);
1067   }
1068   return (void *)result;
1069 }
1070
1071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewUrlChangedSignal(void * jarg1) {
1072   SignalConverter::WebViewUrlChangedSignal* object = (SignalConverter::WebViewUrlChangedSignal*)jarg1;
1073   {
1074     try {
1075       delete object;
1076     } CALL_CATCH_EXCEPTION();
1077   }
1078 }
1079
1080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewUrlChangedSignal_Connect(void * jarg1, void * jarg2) {
1081   SignalConverter::WebViewUrlChangedSignal* proxy = (SignalConverter::WebViewUrlChangedSignal*)jarg1;
1082   SignalConverter::WebViewUrlChangedSignal::CallbackType callback = (SignalConverter::WebViewUrlChangedSignal::CallbackType)jarg2;
1083   {
1084     try {
1085       proxy->Connect(callback);
1086     } CALL_CATCH_EXCEPTION();
1087   }
1088 }
1089
1090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewUrlChangedSignal_Disconnect(void * jarg1, void * jarg2) {
1091   SignalConverter::WebViewUrlChangedSignal* proxy = (SignalConverter::WebViewUrlChangedSignal*)jarg1;
1092   SignalConverter::WebViewUrlChangedSignal::CallbackType callback = (SignalConverter::WebViewUrlChangedSignal::CallbackType)jarg2;
1093   {
1094     try {
1095       proxy->Disconnect(callback);
1096     } CALL_CATCH_EXCEPTION();
1097   }
1098 }
1099
1100 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_WebViewContextMenuShownSignal_ContextMenuShown(void * jarg1) {
1101   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
1102   SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>* result = 0;
1103   {
1104     try {
1105       result = new SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>(&webview->ContextMenuShownSignal());
1106     } CALL_CATCH_EXCEPTION(0);
1107   }
1108   return (void*)result;
1109 }
1110
1111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewContextMenuShownSignal(void * jarg1) {
1112   SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>* object = (SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>*)jarg1;
1113   {
1114     try {
1115       delete object;
1116     } CALL_CATCH_EXCEPTION();
1117   }
1118 }
1119
1120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewContextMenuShownSignal_Connect(void * jarg1, void * jarg2) {
1121   SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>*)jarg1;
1122   SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>::CallbackType)jarg2;
1123   {
1124     try {
1125       proxy->Connect(callback);
1126     } CALL_CATCH_EXCEPTION();
1127   }
1128 }
1129
1130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewContextMenuShownSignal_Disconnect(void * jarg1, void * jarg2) {
1131   SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>*)jarg1;
1132   SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>::CallbackType)jarg2;
1133   {
1134     try {
1135       proxy->Disconnect(callback);
1136     } CALL_CATCH_EXCEPTION();
1137   }
1138 }
1139
1140 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_WebViewContextMenuHiddenSignal_ContextMenuHidden(void * jarg1) {
1141   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
1142   SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>* result = 0;
1143   {
1144     try {
1145       result = new SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>(&webview->ContextMenuHiddenSignal());
1146     } CALL_CATCH_EXCEPTION(0);
1147   }
1148   return (void*)result;
1149 }
1150
1151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewContextMenuHiddenSignal(void * jarg1) {
1152   SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>* object = (SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>*)jarg1;
1153   {
1154     try {
1155       delete object;
1156     } CALL_CATCH_EXCEPTION();
1157   }
1158 }
1159
1160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewContextMenuHiddenSignal_Connect(void * jarg1, void * jarg2) {
1161   SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>*)jarg1;
1162   SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>::CallbackType)jarg2;
1163   {
1164     try {
1165       proxy->Connect(callback);
1166     } CALL_CATCH_EXCEPTION();
1167   }
1168 }
1169
1170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewContextMenuHiddenSignal_Disconnect(void * jarg1, void * jarg2) {
1171   SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>*)jarg1;
1172   SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineContextMenu>::CallbackType)jarg2;
1173   {
1174     try {
1175       proxy->Disconnect(callback);
1176     } CALL_CATCH_EXCEPTION();
1177   }
1178 }
1179
1180 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_WebViewFormRepostDecisionSignal_FormRepostDecision(void* jarg1) {
1181   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
1182   SignalConverter::WebViewProxySignal<Dali::WebEngineFormRepostDecision>* result = 0;
1183   {
1184     try {
1185       result = new SignalConverter::WebViewProxySignal<Dali::WebEngineFormRepostDecision>(&webview->FormRepostDecisionSignal());
1186     } CALL_CATCH_EXCEPTION(0);
1187   }
1188   return (void*)result;
1189 }
1190
1191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewFormRepostDecisionSignal(void* jarg1) {
1192   SignalConverter::WebViewProxySignal<Dali::WebEngineFormRepostDecision>* object = (SignalConverter::WebViewProxySignal<Dali::WebEngineFormRepostDecision>*)jarg1;
1193   {
1194     try {
1195       delete object;
1196     } CALL_CATCH_EXCEPTION();
1197   }
1198 }
1199
1200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewFormRepostDecisionSignal_Connect(void* jarg1, void* jarg2) {
1201   SignalConverter::WebViewProxySignal<Dali::WebEngineFormRepostDecision>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineFormRepostDecision>*)jarg1;
1202   SignalConverter::WebViewProxySignal<Dali::WebEngineFormRepostDecision>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineFormRepostDecision>::CallbackType)jarg2;
1203   {
1204     try {
1205       proxy->Connect(callback);
1206     } CALL_CATCH_EXCEPTION();
1207   }
1208 }
1209
1210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewFormRepostDecisionSignal_Disconnect(void* jarg1, void* jarg2) {
1211   SignalConverter::WebViewProxySignal<Dali::WebEngineFormRepostDecision>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineFormRepostDecision>*)jarg1;
1212   SignalConverter::WebViewProxySignal<Dali::WebEngineFormRepostDecision>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineFormRepostDecision>::CallbackType)jarg2;
1213   {
1214     try {
1215       proxy->Disconnect(callback);
1216     } CALL_CATCH_EXCEPTION();
1217   }
1218 }
1219
1220 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_WebViewFrameRenderedSignal_FrameRendered(void* jarg1) {
1221   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
1222   Dali::Toolkit::WebView::WebViewFrameRenderedSignalType* result = 0;
1223   {
1224     try {
1225       result = (Dali::Toolkit::WebView::WebViewFrameRenderedSignalType*)(&(webview->FrameRenderedSignal()));
1226     } CALL_CATCH_EXCEPTION(0);
1227   }
1228   return (void*)result;
1229 }
1230
1231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewFrameRenderedSignal_Connect(void* jarg1, void* jarg2) {
1232   Dali::Toolkit::WebView::WebViewFrameRenderedSignalType* proxy = (Dali::Toolkit::WebView::WebViewFrameRenderedSignalType*)jarg1;
1233   void (*callback)(Dali::Toolkit::WebView) = (void (*)(Dali::Toolkit::WebView))jarg2;
1234   {
1235     try {
1236       proxy->Connect(callback);
1237     } CALL_CATCH_EXCEPTION();
1238   }
1239 }
1240
1241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewFrameRenderedSignal_Disconnect(void* jarg1, void* jarg2) {
1242   Dali::Toolkit::WebView::WebViewFrameRenderedSignalType* proxy = (Dali::Toolkit::WebView::WebViewFrameRenderedSignalType*)jarg1;
1243   void (*callback)(Dali::Toolkit::WebView) = (void (*)(Dali::Toolkit::WebView))jarg2;
1244   {
1245     try {
1246       proxy->Disconnect(callback);
1247     } CALL_CATCH_EXCEPTION();
1248   }
1249 }
1250
1251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewRequestInterceptorSignal_RequestInterceptor(void * jarg1) {
1252   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
1253   SignalConverter::WebViewProxySignal<Dali::WebEngineRequestInterceptor>* result = 0;
1254   {
1255     try {
1256       result = new SignalConverter::WebViewProxySignal<Dali::WebEngineRequestInterceptor>(&webview->RequestInterceptorSignal());
1257     } CALL_CATCH_EXCEPTION(0);
1258   }
1259   return (void*)result;
1260 }
1261
1262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewRequestInterceptorSignal(void* jarg1) {
1263   SignalConverter::WebViewProxySignal<Dali::WebEngineRequestInterceptor>* object = (SignalConverter::WebViewProxySignal<Dali::WebEngineRequestInterceptor>*)jarg1;
1264   {
1265     try {
1266       delete object;
1267     } CALL_CATCH_EXCEPTION();
1268   }
1269 }
1270
1271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewRequestInterceptorSignal_Connect(void * jarg1, void * jarg2) {
1272   SignalConverter::WebViewProxySignal<Dali::WebEngineRequestInterceptor>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineRequestInterceptor>*)jarg1;
1273   SignalConverter::WebViewProxySignal<Dali::WebEngineRequestInterceptor>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineRequestInterceptor>::CallbackType)jarg2;
1274   {
1275     try {
1276       proxy->Connect(callback);
1277     } CALL_CATCH_EXCEPTION();
1278   }
1279 }
1280
1281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewRequestInterceptorSignal_Disconnect(void * jarg1, void * jarg2) {
1282   SignalConverter::WebViewProxySignal<Dali::WebEngineRequestInterceptor>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineRequestInterceptor>*)jarg1;
1283   SignalConverter::WebViewProxySignal<Dali::WebEngineRequestInterceptor>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineRequestInterceptor>::CallbackType)jarg2;
1284   {
1285     try {
1286       proxy->Disconnect(callback);
1287     } CALL_CATCH_EXCEPTION();
1288   }
1289 }
1290
1291 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_WebViewConsoleMessageSignal_ConsoleMessage(void * jarg1) {
1292   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
1293   SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>* result = 0;
1294   {
1295     try {
1296       result = new SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>(&webview->ConsoleMessageSignal());
1297     } CALL_CATCH_EXCEPTION(0);
1298   }
1299   return (void*)result;
1300 }
1301
1302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewConsoleMessageSignal(void * jarg1) {
1303   SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>* object = (SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>*)jarg1;
1304   {
1305     try {
1306       delete object;
1307     } CALL_CATCH_EXCEPTION();
1308   }
1309 }
1310
1311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewConsoleMessageSignal_Connect(void * jarg1, void * jarg2) {
1312   SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>*)jarg1;
1313   SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>::CallbackType)jarg2;
1314   {
1315     try {
1316       proxy->Connect(callback);
1317     } CALL_CATCH_EXCEPTION();
1318   }
1319 }
1320
1321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewConsoleMessageSignal_Disconnect(void * jarg1, void * jarg2) {
1322   SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>*)jarg1;
1323   SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineConsoleMessage>::CallbackType)jarg2;
1324   {
1325     try {
1326       proxy->Disconnect(callback);
1327     } CALL_CATCH_EXCEPTION();
1328   }
1329 }
1330
1331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewCertificateSignal_CertificateConfirm(void * jarg1) {
1332   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
1333   SignalConverter::WebViewProxySignal<Dali::WebEngineCertificate>* result = 0;
1334   {
1335     try {
1336       result = new SignalConverter::WebViewProxySignal<Dali::WebEngineCertificate>(&webview->CertificateConfirmSignal());
1337     } CALL_CATCH_EXCEPTION(0);
1338   }
1339   return (void*)result;
1340 }
1341
1342 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_WebViewCertificateSignal_SslCertificateChanged(void * jarg1) {
1343   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
1344   SignalConverter::WebViewProxySignal<Dali::WebEngineCertificate>* result = 0;
1345   {
1346     try {
1347       result = new SignalConverter::WebViewProxySignal<Dali::WebEngineCertificate>(&webview->SslCertificateChangedSignal());
1348     } CALL_CATCH_EXCEPTION(0);
1349   }
1350   return (void*)result;
1351 }
1352
1353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewCertificateSignal(void * jarg1) {
1354   SignalConverter::WebViewProxySignal<Dali::WebEngineCertificate>* object = (SignalConverter::WebViewProxySignal<Dali::WebEngineCertificate>*)jarg1;
1355   {
1356     try {
1357       delete object;
1358     } CALL_CATCH_EXCEPTION();
1359   }
1360 }
1361
1362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewCertificateSignal_Connect(void * jarg1, void * jarg2) {
1363   SignalConverter::WebViewProxySignal<Dali::WebEngineCertificate>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineCertificate>*)jarg1;
1364   SignalConverter::WebViewProxySignal<Dali::WebEngineCertificate>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineCertificate>::CallbackType)jarg2;
1365   {
1366     try {
1367       proxy->Connect(callback);
1368     } CALL_CATCH_EXCEPTION();
1369   }
1370 }
1371
1372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewCertificateSignal_Disconnect(void * jarg1, void * jarg2) {
1373   SignalConverter::WebViewProxySignal<Dali::WebEngineCertificate>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineCertificate>*)jarg1;
1374   SignalConverter::WebViewProxySignal<Dali::WebEngineCertificate>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineCertificate>::CallbackType)jarg2;
1375   {
1376     try {
1377       proxy->Disconnect(callback);
1378     } CALL_CATCH_EXCEPTION();
1379   }
1380 }
1381
1382 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_WebViewResponsePolicyDecisionSignal_ResponsePolicyDecision(void * jarg1) {
1383   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
1384   SignalConverter::WebViewProxySignal<Dali::WebEnginePolicyDecision>* result = 0;
1385   {
1386     try {
1387       result = new SignalConverter::WebViewProxySignal<Dali::WebEnginePolicyDecision>(&webview->ResponsePolicyDecisionSignal());
1388     } CALL_CATCH_EXCEPTION(0);
1389   }
1390   return (void*)result;
1391 }
1392
1393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewResponsePolicyDecisionSignal(void * jarg1) {
1394   SignalConverter::WebViewProxySignal<Dali::WebEnginePolicyDecision>* object = (SignalConverter::WebViewProxySignal<Dali::WebEnginePolicyDecision>*)jarg1;
1395   {
1396     try {
1397       delete object;
1398     } CALL_CATCH_EXCEPTION();
1399   }
1400 }
1401
1402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPolicyDecisionSignal_Connect(void * jarg1, void * jarg2) {
1403   SignalConverter::WebViewProxySignal<Dali::WebEnginePolicyDecision>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEnginePolicyDecision>*)jarg1;
1404   SignalConverter::WebViewProxySignal<Dali::WebEnginePolicyDecision>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEnginePolicyDecision>::CallbackType)jarg2;
1405   {
1406     try {
1407       proxy->Connect(callback);
1408     } CALL_CATCH_EXCEPTION();
1409   }
1410 }
1411
1412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPolicyDecisionSignal_Disconnect(void * jarg1, void * jarg2) {
1413   SignalConverter::WebViewProxySignal<Dali::WebEnginePolicyDecision>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEnginePolicyDecision>*)jarg1;
1414   SignalConverter::WebViewProxySignal<Dali::WebEnginePolicyDecision>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEnginePolicyDecision>::CallbackType)jarg2;
1415   {
1416     try {
1417       proxy->Disconnect(callback);
1418     } CALL_CATCH_EXCEPTION();
1419   }
1420 }
1421
1422 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_WebViewHttpAuthHandlerSignal_HttpAuthHandler(void * jarg1) {
1423   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1;
1424   SignalConverter::WebViewProxySignal<Dali::WebEngineHttpAuthHandler>* result = 0;
1425   {
1426     try {
1427       result = new SignalConverter::WebViewProxySignal<Dali::WebEngineHttpAuthHandler>(&webview->HttpAuthHandlerSignal());
1428     } CALL_CATCH_EXCEPTION(0);
1429   }
1430   return (void*)result;
1431 }
1432
1433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewHttpAuthHandlerSignal(void * jarg1) {
1434   SignalConverter::WebViewProxySignal<Dali::WebEngineHttpAuthHandler>* object = (SignalConverter::WebViewProxySignal<Dali::WebEngineHttpAuthHandler>*)jarg1;
1435   {
1436     try {
1437       delete object;
1438     } CALL_CATCH_EXCEPTION();
1439   }
1440 }
1441
1442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewHttpAuthHandlerSignal_Connect(void * jarg1, void * jarg2) {
1443   SignalConverter::WebViewProxySignal<Dali::WebEngineHttpAuthHandler>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineHttpAuthHandler>*)jarg1;
1444   SignalConverter::WebViewProxySignal<Dali::WebEngineHttpAuthHandler>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineHttpAuthHandler>::CallbackType)jarg2;
1445   {
1446     try {
1447       proxy->Connect(callback);
1448     } CALL_CATCH_EXCEPTION();
1449   }
1450 }
1451
1452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewHttpAuthHandlerSignal_Disconnect(void * jarg1, void * jarg2) {
1453   SignalConverter::WebViewProxySignal<Dali::WebEngineHttpAuthHandler>* proxy = (SignalConverter::WebViewProxySignal<Dali::WebEngineHttpAuthHandler>*)jarg1;
1454   SignalConverter::WebViewProxySignal<Dali::WebEngineHttpAuthHandler>::CallbackType callback = (SignalConverter::WebViewProxySignal<Dali::WebEngineHttpAuthHandler>::CallbackType)jarg2;
1455   {
1456     try {
1457       proxy->Disconnect(callback);
1458     } CALL_CATCH_EXCEPTION();
1459   }
1460 }
1461
1462 //----------------------------------WebBackForwardListItem-----------------------------------------------------
1463 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebBackForwardListItem_GetUrl(void * jarg1) {
1464   Dali::WebEngineBackForwardListItem *arg1 = (Dali::WebEngineBackForwardListItem *)0;
1465   std::string result;
1466   arg1 = (Dali::WebEngineBackForwardListItem *)jarg1;
1467   {
1468     try {
1469       result = arg1->GetUrl();
1470     } CALL_CATCH_EXCEPTION(0);
1471   }
1472   char * jresult = SWIG_csharp_string_callback(result.c_str());
1473   return jresult;
1474 }
1475
1476 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebBackForwardListItem_GetTitle(void * jarg1) {
1477   Dali::WebEngineBackForwardListItem *arg1 = (Dali::WebEngineBackForwardListItem *)0;
1478   std::string result;
1479   arg1 = (Dali::WebEngineBackForwardListItem *)jarg1;
1480   {
1481     try {
1482       result = (arg1)->GetTitle();
1483     } CALL_CATCH_EXCEPTION(0);
1484   }
1485   char * jresult = SWIG_csharp_string_callback(result.c_str());
1486   return jresult;
1487 }
1488
1489 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebBackForwardListItem_GetOriginalUrl(void * jarg1) {
1490   Dali::WebEngineBackForwardListItem *arg1 = (Dali::WebEngineBackForwardListItem *)0;
1491   std::string result;
1492   arg1 = (Dali::WebEngineBackForwardListItem *)jarg1;
1493   {
1494     try {
1495       result = (arg1)->GetOriginalUrl();
1496     } CALL_CATCH_EXCEPTION(0);
1497   }
1498   char * jresult = SWIG_csharp_string_callback(result.c_str());
1499   return jresult;
1500 }
1501
1502 //----------------------------------WebBackForwardList-----------------------------------------------------
1503 SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetItemCount(void * jarg1) {
1504   Dali::Toolkit::WebBackForwardList *arg1 = (Dali::Toolkit::WebBackForwardList *)0;
1505   uint32_t result = 0;
1506   arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1;
1507   {
1508     try {
1509       result = (arg1)->GetItemCount();
1510     } CALL_CATCH_EXCEPTION(0);
1511   }
1512   return result;
1513 }
1514
1515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetCurrentItem(void *jarg1) {
1516   Dali::WebEngineBackForwardListItem *result = 0;
1517   Dali::Toolkit::WebBackForwardList *arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1;
1518   {
1519     try {
1520       std::unique_ptr<Dali::WebEngineBackForwardListItem> temp = (arg1)->GetCurrentItem();
1521       result = temp.release();
1522     } CALL_CATCH_EXCEPTION(0);
1523   }
1524   return result;
1525 }
1526
1527 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetPreviousItem(void* jarg1) {
1528   Dali::WebEngineBackForwardListItem *result = 0;
1529   Dali::Toolkit::WebBackForwardList* arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1;
1530   {
1531     try {
1532       std::unique_ptr<Dali::WebEngineBackForwardListItem> temp = (arg1)->GetPreviousItem();
1533       result = temp.release();
1534     } CALL_CATCH_EXCEPTION(0);
1535   }
1536   return result;
1537 }
1538
1539 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetNextItem(void* jarg1) {
1540   Dali::WebEngineBackForwardListItem *result = 0;
1541   Dali::Toolkit::WebBackForwardList* arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1;
1542   {
1543     try {
1544       std::unique_ptr<Dali::WebEngineBackForwardListItem> temp = (arg1)->GetNextItem();
1545       result = temp.release();
1546     } CALL_CATCH_EXCEPTION(0);
1547   }
1548   return result;
1549 }
1550
1551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetItemAtIndex(void *jarg1, int jarg2) {
1552   Dali::WebEngineBackForwardListItem *result = 0;
1553   Dali::Toolkit::WebBackForwardList *arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1;
1554   {
1555     try {
1556       std::unique_ptr<Dali::WebEngineBackForwardListItem> temp = (arg1)->GetItemAtIndex(jarg2);
1557       result = temp.release();
1558     } CALL_CATCH_EXCEPTION(0);
1559   }
1560   return result;
1561 }
1562
1563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebBackForwardList_DeleteItem(void *jarg1) {
1564   Dali::WebEngineBackForwardListItem *arg1 = (Dali::WebEngineBackForwardListItem *)jarg1;
1565   {
1566     try {
1567       delete arg1;
1568     } CALL_CATCH_EXCEPTION();
1569   }
1570 }
1571
1572 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetBackwardItems(void *jarg1, int jarg2) {
1573   std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> *result = 0;
1574   Dali::Toolkit::WebBackForwardList *arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1;
1575   {
1576     try {
1577       result = new std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>>();
1578       std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> temp = (arg1)->GetBackwardItems(jarg2);
1579       result->swap(temp);
1580     } CALL_CATCH_EXCEPTION(0);
1581   }
1582   return (void *)result;
1583 }
1584
1585 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetForwardItems(void *jarg1, int jarg2) {
1586   std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> *result = 0;
1587   Dali::Toolkit::WebBackForwardList *arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1;
1588   {
1589     try {
1590       result = new std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>>();
1591       std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> temp = (arg1)->GetForwardItems(jarg2);
1592       result->swap(temp);
1593     } CALL_CATCH_EXCEPTION(0);
1594   }
1595   return (void *)result;
1596 }
1597
1598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebBackForwardList_DeleteCopiedItems(void *jarg1) {
1599   std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> *arg1 = (std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> *)jarg1;
1600   {
1601     try {
1602       delete arg1;
1603     } CALL_CATCH_EXCEPTION();
1604   }
1605 }
1606
1607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetCopiedItemsCount(void *jarg1) {
1608   unsigned int result = 0;
1609   std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> *arg1 = (std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> *)jarg1;
1610   {
1611     try {
1612       result = (arg1)->size();
1613     } CALL_CATCH_EXCEPTION(0);
1614   }
1615
1616   return result;
1617 }
1618
1619 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetItemAtIndexFromCopiedItems(void *jarg1, unsigned int jarg2) {
1620   Dali::WebEngineBackForwardListItem *result = 0;
1621   std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> *arg1 = (std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> *)jarg1;
1622   {
1623     try {
1624       result = (arg1)->operator[](jarg2).get();
1625     } CALL_CATCH_EXCEPTION(0);
1626   }
1627   return (void *)result;
1628 }
1629
1630 //----------------------------------WebConsoleMessage-----------------------------------------------------
1631 SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebConsoleMessage_GetSource(void* jarg1) {
1632   Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1;
1633   std::string result;
1634   {
1635     try {
1636       result = arg1->GetSource();
1637     } CALL_CATCH_EXCEPTION(0);
1638   }
1639   char* jresult = SWIG_csharp_string_callback(result.c_str());
1640   return jresult;
1641 }
1642
1643 SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebConsoleMessage_GetLine(void* jarg1) {
1644   Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1;
1645   uint32_t result;
1646   {
1647     try {
1648       result = arg1->GetLine();
1649     } CALL_CATCH_EXCEPTION(0);
1650   }
1651   return result;
1652 }
1653
1654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebConsoleMessage_GetSeverityLevel(void* jarg1) {
1655   Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1;
1656   int result;
1657   {
1658     try {
1659       result = (int)arg1->GetSeverityLevel();
1660     } CALL_CATCH_EXCEPTION(0);
1661   }
1662   return result;
1663 }
1664
1665 SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebConsoleMessage_GetText(void* jarg1) {
1666   Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1;
1667   std::string result;
1668   {
1669     try {
1670       result = arg1->GetText();
1671     } CALL_CATCH_EXCEPTION(0);
1672   }
1673   char* jresult = SWIG_csharp_string_callback(result.c_str());
1674   return jresult;
1675 }
1676
1677 //----------------------------------WebCertificate-----------------------------------------------------
1678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebCertificate_Allow(void * jarg1, bool jarg2) {
1679   Dali::WebEngineCertificate *arg1 = (Dali::WebEngineCertificate*)jarg1;
1680   {
1681     try {
1682       (arg1)->Allow(jarg2);
1683     } CALL_CATCH_EXCEPTION();
1684   }
1685 }
1686
1687 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebCertificate_IsFromMainFrame(void * jarg1) {
1688   Dali::WebEngineCertificate* arg1 = (Dali::WebEngineCertificate*)jarg1;
1689   bool ret;
1690   {
1691     try {
1692       ret = (arg1)->IsFromMainFrame();
1693     } CALL_CATCH_EXCEPTION(0);
1694   }
1695   return ret;
1696 }
1697
1698 SWIGEXPORT const char *SWIGSTDCALL CSharp_Dali_WebCertificate_GetPem(void * jarg1) {
1699   Dali::WebEngineCertificate* arg1 = (Dali::WebEngineCertificate*)jarg1;
1700   std::string result;
1701   {
1702     try {
1703       result = (arg1)->GetPem();
1704     } CALL_CATCH_EXCEPTION(0);
1705   }
1706   char *jresult = SWIG_csharp_string_callback(result.c_str());
1707   return jresult;
1708 }
1709
1710 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebCertificate_IsContextSecure(void * jarg1) {
1711   Dali::WebEngineCertificate* arg1 = (Dali::WebEngineCertificate*)jarg1;
1712   bool ret;
1713   {
1714     try {
1715       ret = (arg1)->IsContextSecure();
1716     } CALL_CATCH_EXCEPTION(0);
1717   }
1718   return ret;
1719 }
1720
1721 //----------------------------------WebContext-----------------------------------------------------
1722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebContext_GetCacheModel(void * jarg1) {
1723   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
1724   int ret;
1725   arg1 = (Dali::Toolkit::WebContext *)jarg1;
1726   {
1727     try {
1728       ret = (int)(arg1)->GetCacheModel();
1729     } CALL_CATCH_EXCEPTION(0);
1730   }
1731   return ret;
1732 }
1733
1734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetCacheModel(void * jarg1, int jarg2) {
1735   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
1736
1737   arg1 = (Dali::Toolkit::WebContext *)jarg1;
1738   {
1739     try {
1740       (arg1)->SetCacheModel((Dali::WebEngineContext::CacheModel)jarg2);
1741     } CALL_CATCH_EXCEPTION();
1742   }
1743 }
1744
1745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetProxyUri(void * jarg1, const char * jarg2) {
1746   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
1747
1748   arg1 = (Dali::Toolkit::WebContext *)jarg1;
1749   std::string arg2_str(jarg2);
1750   {
1751     try {
1752       (arg1)->SetProxyUri(arg2_str);
1753     } CALL_CATCH_EXCEPTION();
1754   }
1755 }
1756
1757 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContext_GetProxyUri(void *jarg1) {
1758   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
1759   char *jresult;
1760   arg1 = (Dali::Toolkit::WebContext *)jarg1;
1761   {
1762     try {
1763       const std::string str = (arg1)->GetProxyUri();
1764       jresult = SWIG_csharp_string_callback(str.c_str());
1765     } CALL_CATCH_EXCEPTION(0);
1766   }
1767
1768   return jresult;
1769 }
1770
1771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetProxyBypassRule(void *jarg1, char *jarg2, char *jarg3) {
1772   if (!jarg2 || !jarg3) {
1773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1774     return;
1775   }
1776
1777   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
1778   const std::string arg2(jarg2);
1779   const std::string arg3(jarg3);
1780
1781   arg1 = (Dali::Toolkit::WebContext *)jarg1;
1782   {
1783     try {
1784       (arg1)->SetProxyBypassRule(arg2, arg3);
1785     } CALL_CATCH_EXCEPTION();
1786   }
1787 }
1788
1789 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContext_GetProxyBypassRule(void *jarg1) {
1790   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
1791   char *jresult;
1792
1793   arg1 = (Dali::Toolkit::WebContext *)jarg1;
1794   {
1795     try {
1796       const std::string str = (arg1)->GetProxyBypassRule();
1797       jresult = SWIG_csharp_string_callback(str.c_str());
1798     } CALL_CATCH_EXCEPTION(0);
1799   }
1800
1801   return jresult;
1802 }
1803
1804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetCertificateFilePath(void * jarg1, const char * jarg2) {
1805   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
1806
1807   arg1 = (Dali::Toolkit::WebContext *)jarg1;
1808   std::string arg2_str(jarg2);
1809   {
1810     try {
1811       (arg1)->SetCertificateFilePath(arg2_str);
1812     } CALL_CATCH_EXCEPTION();
1813   }
1814 }
1815
1816 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContext_GetCertificateFilePath(void *jarg1) {
1817   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
1818   char *jresult;
1819   arg1 = (Dali::Toolkit::WebContext *)jarg1;
1820   {
1821     try {
1822       const std::string str = (arg1)->GetCertificateFilePath();
1823       jresult = SWIG_csharp_string_callback(str.c_str());
1824     } CALL_CATCH_EXCEPTION(0);
1825   }
1826
1827   return jresult;
1828 }
1829
1830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetDefaultProxyAuth(void * jarg1, const char * jarg2, const char * jarg3) {
1831   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)jarg1;
1832   std::string arg2_str(jarg2);
1833   std::string arg3_str(jarg3);
1834   {
1835     try {
1836       (arg1)->SetDefaultProxyAuth(arg2_str, arg3_str);
1837     } CALL_CATCH_EXCEPTION();
1838   }
1839 }
1840
1841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllWebDatabase(void *jarg1) {
1842   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)jarg1;
1843   {
1844     try {
1845       (arg1)->DeleteAllWebDatabase();
1846     } CALL_CATCH_EXCEPTION();
1847   }
1848 }
1849
1850 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_GetWebDatabaseOrigins(void *jarg1, void *jarg2) {
1851   Dali::Toolkit::WebContext * arg1 = (Dali::Toolkit::WebContext *)jarg1;
1852   void (*handler)(std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>>*) = (void (*)(std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>>*))jarg2;
1853   bool result = false;
1854   {
1855     try {
1856       result = (arg1)->GetWebDatabaseOrigins(
1857                  [handler](std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>>& originList) {
1858                     std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>>* webOriginList = new std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>>();
1859                     webOriginList->swap(originList);
1860                     handler(webOriginList);
1861                  });
1862     } CALL_CATCH_EXCEPTION(0);
1863   }
1864   return result;
1865 }
1866
1867 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_DeleteWebDatabase(void *jarg1, void *jarg2) {
1868   Dali::Toolkit::WebContext * arg1 = (Dali::Toolkit::WebContext *)jarg1;
1869   Dali::WebEngineSecurityOrigin * origin = (Dali::WebEngineSecurityOrigin *)jarg2;
1870   bool result = false;
1871   {
1872     try {
1873       result = (arg1)->DeleteWebDatabase(*origin);
1874     } CALL_CATCH_EXCEPTION(0);
1875   }
1876   return result;
1877 }
1878
1879 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_GetWebStorageOrigins(void *jarg1, void *jarg2) {
1880   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)jarg1;
1881   void (*handler)(std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>>*) = (void (*)(std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>>*))jarg2;
1882   bool result = false;
1883   {
1884     try {
1885       result = (arg1)->GetWebStorageOrigins(
1886                  [handler](std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>>& originList) {
1887                     std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>>* contextOriginList = new std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>>();
1888                     contextOriginList->swap(originList);
1889                     handler(contextOriginList);
1890                  });
1891     } CALL_CATCH_EXCEPTION(0);
1892   }
1893   return result;
1894 }
1895
1896 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_GetWebStorageUsageForOrigin(void *jarg1, void *jarg2, void *jarg3) {
1897   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)jarg1;
1898   Dali::WebEngineSecurityOrigin *origin = (Dali::WebEngineSecurityOrigin *)jarg2;
1899   void (*callback)(uint64_t) = (void (*)(uint64_t))jarg3;
1900   bool result = false;
1901   {
1902     try {
1903       result = (arg1)->GetWebStorageUsageForOrigin(*origin, callback);
1904     } CALL_CATCH_EXCEPTION(0);
1905   }
1906   return result;
1907 }
1908
1909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllWebStorage(void *jarg1) {
1910   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
1911
1912   arg1 = (Dali::Toolkit::WebContext *)jarg1;
1913   {
1914     try {
1915       (arg1)->DeleteAllWebStorage();
1916     } CALL_CATCH_EXCEPTION();
1917   }
1918 }
1919
1920 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_DeleteWebStorage(void *jarg1, void *jarg2) {
1921   Dali::Toolkit::WebContext * arg1 = (Dali::Toolkit::WebContext *)jarg1;
1922   Dali::WebEngineSecurityOrigin * origin = (Dali::WebEngineSecurityOrigin *)jarg2;
1923   bool result = false;
1924   {
1925     try {
1926       result = (arg1)->DeleteWebStorage(*origin);
1927     } CALL_CATCH_EXCEPTION(0);
1928   }
1929   return result;
1930 }
1931
1932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteLocalFileSystem(void *jarg1) {
1933   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)jarg1;
1934   {
1935     try {
1936       (arg1)->DeleteLocalFileSystem();
1937     } CALL_CATCH_EXCEPTION();
1938   }
1939 }
1940
1941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_ClearCache(void * jarg1) {
1942   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)jarg1;
1943   {
1944     try {
1945       (arg1)->ClearCache();
1946     } CALL_CATCH_EXCEPTION();
1947   }
1948 }
1949
1950 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_DeleteApplicationCache(void * jarg1, void * jarg2) {
1951   Dali::Toolkit::WebContext * arg1 = (Dali::Toolkit::WebContext *)jarg1;
1952   Dali::WebEngineSecurityOrigin * origin = (Dali::WebEngineSecurityOrigin *)jarg2;
1953   bool result = false;
1954   {
1955     try {
1956       result = (arg1)->DeleteApplicationCache(*origin);
1957     } CALL_CATCH_EXCEPTION(0);
1958   }
1959   return result;
1960 }
1961
1962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_GetFormPasswordList(void *jarg1, void *jarg2) {
1963   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)jarg1;
1964   void (*handler)(std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>>*) = (void (*)(std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>>*))jarg2;
1965   {
1966     try {
1967       (arg1)->GetFormPasswordList(
1968                  [handler](std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>>& passwordList) {
1969                     std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>>* contextPasswordList = new std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>>();
1970                     contextPasswordList->swap(passwordList);
1971                     handler(contextPasswordList);
1972                  });
1973     } CALL_CATCH_EXCEPTION();
1974   }
1975 }
1976
1977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_RegisterDownloadStartedCallback(void * jarg1, void * jarg2) {
1978   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)jarg1;
1979   void (*handler)(char *) = (void (*)(char *))jarg2;
1980   {
1981     try {
1982       (arg1)->RegisterDownloadStartedCallback(
1983                  [handler](const std::string& url) {
1984                    handler(SWIG_csharp_string_callback(url.c_str()));
1985                  });
1986     } CALL_CATCH_EXCEPTION();
1987   }
1988 }
1989
1990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_RegisterMimeOverriddenCallback(void *jarg1, void *jarg2) {
1991   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)jarg1;
1992   bool (*handler)(char *, char *, char *) = (bool (*)(char *, char *, char *))jarg2;
1993   {
1994     try {
1995       (arg1)->RegisterMimeOverriddenCallback(
1996           [handler](const std::string& url, const std::string& mime, std::string& newMime) -> bool {
1997             return handler(SWIG_csharp_string_callback(url.c_str()),
1998                            SWIG_csharp_string_callback(mime.c_str()),
1999                            SWIG_csharp_string_callback(newMime.c_str()));
2000           });
2001     } CALL_CATCH_EXCEPTION();
2002   }
2003 }
2004
2005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_EnableCache(void * jarg1, bool jarg2) {
2006   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
2007
2008   arg1 = (Dali::Toolkit::WebContext *)jarg1;
2009   {
2010     try {
2011       (arg1)->EnableCache(jarg2);
2012     } CALL_CATCH_EXCEPTION();
2013   }
2014 }
2015
2016 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_IsCacheEnabled(void *jarg1) {
2017   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
2018   bool ret;
2019   arg1 = (Dali::Toolkit::WebContext *)jarg1;
2020   {
2021     try {
2022       ret = (arg1)->IsCacheEnabled();
2023     } CALL_CATCH_EXCEPTION(0);
2024   }
2025
2026   return ret;
2027 }
2028
2029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetAppId(void *jarg1, char *jarg2) {
2030   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
2031   if (!jarg2) {
2032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
2033     return;
2034   }
2035
2036   const std::string str(jarg2);
2037   arg1 = (Dali::Toolkit::WebContext *)jarg1;
2038   {
2039     try {
2040       (arg1)->SetAppId(str);
2041     } CALL_CATCH_EXCEPTION();
2042   }
2043 }
2044
2045 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_SetAppVersion(void *jarg1, char *jarg2) {
2046   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
2047   if (!jarg2) {
2048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
2049     return false;
2050   }
2051
2052   const std::string str(jarg2);
2053   bool ret;
2054   arg1 = (Dali::Toolkit::WebContext *)jarg1;
2055   {
2056     try {
2057       ret = (arg1)->SetAppVersion(str);
2058     } CALL_CATCH_EXCEPTION(0);
2059   }
2060
2061   return ret;
2062 }
2063
2064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetApplicationType(void *jarg1, int jarg2) {
2065   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
2066
2067   arg1 = (Dali::Toolkit::WebContext *)jarg1;
2068   {
2069     try {
2070       (arg1)->SetApplicationType((Dali::WebEngineContext::ApplicationType)jarg2);
2071     } CALL_CATCH_EXCEPTION();
2072   }
2073 }
2074
2075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetTimeOffset(void *jarg1, float jarg2) {
2076   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
2077
2078   arg1 = (Dali::Toolkit::WebContext *)jarg1;
2079   {
2080     try {
2081       (arg1)->SetTimeOffset(jarg2);
2082     } CALL_CATCH_EXCEPTION();
2083   }
2084 }
2085
2086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetTimeZoneOffset(void *jarg1, float jarg2, float jarg3) {
2087   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
2088
2089   arg1 = (Dali::Toolkit::WebContext *)jarg1;
2090   {
2091     try {
2092       (arg1)->SetTimeZoneOffset(jarg2, jarg3);
2093     } CALL_CATCH_EXCEPTION();
2094   }
2095 }
2096
2097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_RegisterUrlSchemesAsCorsEnabled(void *jarg1, char **jarg2, unsigned int jarg3) {
2098   if (!jarg2) {
2099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
2100     return;
2101   }
2102
2103   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
2104   arg1 = (Dali::Toolkit::WebContext *)jarg1;
2105   {
2106     try {
2107       std::vector<std::string> vecStr;
2108       for (unsigned int i=0; i<jarg3; i++)
2109       {
2110         if (!jarg2[i]) {
2111           SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
2112           return;
2113         }
2114         std::string str(jarg2[i]);
2115         vecStr.push_back(str);
2116       }
2117       (arg1)->RegisterUrlSchemesAsCorsEnabled(vecStr);
2118     } CALL_CATCH_EXCEPTION();
2119   }
2120 }
2121
2122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_RegisterJsPluginMimeTypes(void *jarg1, char **jarg2, unsigned int jarg3) {
2123   if (!jarg2) {
2124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
2125     return;
2126   }
2127
2128   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
2129   arg1 = (Dali::Toolkit::WebContext *)jarg1;
2130   {
2131     try {
2132       std::vector<std::string> vecStr;
2133       for (unsigned int i=0; i<jarg3; i++)
2134       {
2135         if (!jarg2[i]) {
2136           SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
2137           return;
2138         }
2139         std::string str(jarg2[i]);
2140         vecStr.push_back(str);
2141       }
2142       (arg1)->RegisterJsPluginMimeTypes(vecStr);
2143     } CALL_CATCH_EXCEPTION();
2144   }
2145 }
2146
2147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetDefaultZoomFactor(void *jarg1, float jarg2) {
2148   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
2149
2150   arg1 = (Dali::Toolkit::WebContext *)jarg1;
2151   {
2152     try {
2153       (arg1)->SetDefaultZoomFactor(jarg2);
2154     } CALL_CATCH_EXCEPTION();
2155   }
2156 }
2157
2158 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WebContext_GetDefaultZoomFactor(void *jarg1) {
2159   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
2160   float ret;
2161   arg1 = (Dali::Toolkit::WebContext *)jarg1;
2162   {
2163     try {
2164       ret = (arg1)->GetDefaultZoomFactor();
2165     } CALL_CATCH_EXCEPTION(0);
2166   }
2167
2168   return ret;
2169 }
2170
2171 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllApplicationCache(void *jarg1) {
2172   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
2173   bool ret;
2174   arg1 = (Dali::Toolkit::WebContext *)jarg1;
2175   {
2176     try {
2177       ret = (arg1)->DeleteAllApplicationCache();
2178     } CALL_CATCH_EXCEPTION(0);
2179   }
2180
2181   return ret;
2182 }
2183
2184 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllWebIndexedDatabase(void *jarg1) {
2185   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
2186   bool ret;
2187   arg1 = (Dali::Toolkit::WebContext *)jarg1;
2188   {
2189     try {
2190       ret = (arg1)->DeleteAllWebIndexedDatabase();
2191     } CALL_CATCH_EXCEPTION(0);
2192   }
2193
2194   return ret;
2195 }
2196
2197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteFormPasswordDataList(void *jarg1, char **jarg2, unsigned int jarg3) {
2198   if (!jarg2) {
2199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
2200     return;
2201   }
2202
2203   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
2204   arg1 = (Dali::Toolkit::WebContext *)jarg1;
2205   {
2206     try {
2207       std::vector<std::string> vecStr;
2208       for (unsigned int i=0; i<jarg3; i++)
2209       {
2210         if (!jarg2[i]) {
2211           SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
2212           return;
2213         }
2214         std::string str(jarg2[i]);
2215         vecStr.push_back(str);
2216       }
2217       (arg1)->DeleteFormPasswordDataList(vecStr);
2218     } CALL_CATCH_EXCEPTION()
2219   }
2220 }
2221
2222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllFormPasswordData(void *jarg1) {
2223   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
2224
2225   arg1 = (Dali::Toolkit::WebContext *)jarg1;
2226   {
2227     try {
2228       (arg1)->DeleteAllFormPasswordData();
2229     } CALL_CATCH_EXCEPTION();
2230   }
2231 }
2232
2233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllFormCandidateData(void *jarg1) {
2234   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
2235
2236   arg1 = (Dali::Toolkit::WebContext *)jarg1;
2237   {
2238     try {
2239       (arg1)->DeleteAllFormCandidateData();
2240     } CALL_CATCH_EXCEPTION();
2241   }
2242 }
2243
2244 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_FreeUnusedMemory(void *jarg1) {
2245   Dali::Toolkit::WebContext *arg1 = (Dali::Toolkit::WebContext *)0;
2246   bool ret;
2247   arg1 = (Dali::Toolkit::WebContext *)jarg1;
2248   {
2249     try {
2250       ret = (arg1)->FreeUnusedMemory();
2251     } CALL_CATCH_EXCEPTION(0);
2252   }
2253
2254   return ret;
2255 }
2256
2257 //----------------------------------WebContextMenu---------------------------------------------------
2258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebContextMenu(void * jarg1) {
2259   if (!jarg1) {
2260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebContextMenu is null", 0);
2261     return;
2262   }
2263
2264   Dali::WebEngineContextMenu* arg1 = (Dali::WebEngineContextMenu*)jarg1;
2265   {
2266     try {
2267       delete arg1;
2268     } CALL_CATCH_EXCEPTION();
2269   }
2270 }
2271
2272 SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebContextMenu_GetItemCount(void *jarg1) {
2273   Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1;
2274   uint32_t ret;
2275   {
2276     try {
2277       ret = (arg1)->GetItemCount();
2278     } CALL_CATCH_EXCEPTION(0);
2279   }
2280   return ret;
2281 }
2282
2283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebContextMenu_GetItemAt(void *jarg1, uint32_t jarg2) {
2284   Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1;
2285   Dali::WebEngineContextMenuItem *result = 0;
2286   {
2287     try {
2288       std::unique_ptr<Dali::WebEngineContextMenuItem> item = (arg1)->GetItemAt(jarg2);
2289       result = item.release();
2290     } CALL_CATCH_EXCEPTION(0);
2291   }
2292   return (void *)result;
2293 }
2294
2295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebContextMenu_GetItemList(void *jarg1) {
2296   Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1;
2297   std::vector<std::unique_ptr<Dali::WebEngineContextMenuItem>>* result = nullptr;
2298   {
2299     try {
2300       result = new std::vector<std::unique_ptr<Dali::WebEngineContextMenuItem>>();
2301       std::vector<std::unique_ptr<Dali::WebEngineContextMenuItem>> itemList = (arg1)->GetItemList();
2302       result->swap(itemList);
2303     } CALL_CATCH_EXCEPTION(0);
2304   }
2305   return (void *)result;
2306 }
2307
2308 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenu_RemoveItem(void *jarg1, void *jarg2) {
2309   Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1;
2310   bool result = 0;
2311   {
2312     try {
2313       result = (arg1)->RemoveItem(*((Dali::WebEngineContextMenuItem*)jarg2));
2314     } CALL_CATCH_EXCEPTION(0);
2315   }
2316   return result;
2317 }
2318
2319 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenu_AppendItemAsAction(void *jarg1, int jarg2, const char *jarg3, bool jarg4) {
2320   Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1;
2321   bool result = 0;
2322   {
2323     try {
2324       result = (arg1)->AppendItemAsAction((Dali::WebEngineContextMenuItem::ItemTag)jarg2, jarg3, jarg4);
2325     } CALL_CATCH_EXCEPTION(0);
2326   }
2327   return result;
2328 }
2329
2330 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenu_AppendItem(void *jarg1, int jarg2, const char *jarg3, const char *jarg4, bool jarg5) {
2331   Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1;
2332   bool result = 0;
2333   {
2334     try {
2335       result = (arg1)->AppendItem((Dali::WebEngineContextMenuItem::ItemTag)jarg2, jarg3, jarg4, jarg5);
2336     } CALL_CATCH_EXCEPTION(0);
2337   }
2338   return result;
2339 }
2340
2341 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenu_SelectItem(void *jarg1, void *jarg2) {
2342   Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1;
2343   bool result = 0;
2344   {
2345     try {
2346       result = (arg1)->SelectItem(*((Dali::WebEngineContextMenuItem*)jarg2));
2347     } CALL_CATCH_EXCEPTION(0);
2348   }
2349   return result;
2350 }
2351
2352 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenu_Hide(void *jarg1) {
2353   Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1;
2354   bool result = 0;
2355   {
2356     try {
2357       result = (arg1)->Hide();
2358     } CALL_CATCH_EXCEPTION(0);
2359   }
2360   return result;
2361 }
2362
2363 //----------------------------------WebContextMenuItem---------------------------------------------------
2364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebContextMenuItem(void * jarg1) {
2365   if (!jarg1) {
2366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebContextMenuItem is null", 0);
2367     return;
2368   }
2369
2370   Dali::WebEngineContextMenuItem* arg1 = (Dali::WebEngineContextMenuItem*)jarg1;
2371   {
2372     try {
2373       delete arg1;
2374     } CALL_CATCH_EXCEPTION();
2375   }
2376 }
2377
2378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetTag(void *jarg1) {
2379   Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1;
2380   int result = 0;
2381   {
2382     try {
2383       result = (int)(arg1)->GetTag();
2384     } CALL_CATCH_EXCEPTION(0);
2385   }
2386   return result;
2387 }
2388
2389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetType(void *jarg1) {
2390   Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1;
2391   int result = 0;
2392   {
2393     try {
2394       result = (int)(arg1)->GetType();
2395     } CALL_CATCH_EXCEPTION(0);
2396   }
2397   return result;
2398 }
2399
2400 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenuItem_IsEnabled(void *jarg1) {
2401   Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1;
2402   bool result = 0;
2403   {
2404     try {
2405       result = (arg1)->IsEnabled();
2406     } CALL_CATCH_EXCEPTION(0);
2407   }
2408   return result;
2409 }
2410
2411 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetLinkUrl(void *jarg1) {
2412   Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1;
2413   std::string result;
2414   {
2415     try {
2416       result = (arg1)->GetLinkUrl();
2417     } CALL_CATCH_EXCEPTION(0);
2418   }
2419   char *jresult = SWIG_csharp_string_callback(result.c_str());
2420   return jresult;
2421 }
2422
2423 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetImageUrl(void *jarg1) {
2424   Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1;
2425   std::string result;
2426   {
2427     try {
2428       result = (arg1)->GetImageUrl();
2429     } CALL_CATCH_EXCEPTION(0);
2430   }
2431   char *jresult = SWIG_csharp_string_callback(result.c_str());
2432   return jresult;
2433 }
2434
2435 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetTitle(void *jarg1) {
2436   Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1;
2437   std::string result;
2438   {
2439     try {
2440       result = (arg1)->GetTitle();
2441     } CALL_CATCH_EXCEPTION(0);
2442   }
2443   char *jresult = SWIG_csharp_string_callback(result.c_str());
2444   return jresult;
2445 }
2446
2447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetParentMenu(void *jarg1) {
2448   Dali::WebEngineContextMenuItem* arg1 = (Dali::WebEngineContextMenuItem*)jarg1;
2449   Dali::WebEngineContextMenu* result = 0;
2450   {
2451     try {
2452       std::unique_ptr<Dali::WebEngineContextMenu> item = (arg1)->GetParentMenu();
2453       result = item.release();
2454     } CALL_CATCH_EXCEPTION(0);
2455   }
2456   return (void *)result;
2457 }
2458
2459 //----------------------------------WebContextMenuItemList---------------------------------------------------
2460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebContextMenu_ItemList(void * jarg1) {
2461   if (!jarg1) {
2462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebContextMenu ItemList is null", 0);
2463     return;
2464   }
2465
2466   std::vector<std::unique_ptr<Dali::WebEngineContextMenuItem>>* arg1 = (std::vector<std::unique_ptr<Dali::WebEngineContextMenuItem>>*)jarg1;
2467   {
2468     try {
2469       delete arg1;
2470     } CALL_CATCH_EXCEPTION();
2471   }
2472 }
2473
2474 SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebContextMenu_ItemList_GetItemCount(void* jarg1) {
2475   std::vector<std::unique_ptr<Dali::WebEngineContextMenuItem>>* arg1 = (std::vector<std::unique_ptr<Dali::WebEngineContextMenuItem>>*)jarg1;
2476   uint32_t result = 0;
2477   {
2478     try {
2479       result = (arg1)->size();
2480     } CALL_CATCH_EXCEPTION(0);
2481   }
2482   return result;
2483 }
2484
2485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebContextMenu_ItemList_ValueOfIndex(void* jarg1, unsigned int jarg2) {
2486   std::vector<std::unique_ptr<Dali::WebEngineContextMenuItem>>* arg1 = (std::vector<std::unique_ptr<Dali::WebEngineContextMenuItem>>*)jarg1;
2487   Dali::WebEngineContextMenuItem* result = 0;
2488   {
2489     try {
2490       result = ((arg1)->operator[](jarg2)).get();
2491     } CALL_CATCH_EXCEPTION(0);
2492   }
2493   return result;
2494 }
2495
2496 //----------------------------------WebCookieManager---------------------------------------------------
2497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebCookieManager_GetCookieAcceptPolicy(void * jarg1) {
2498   Dali::Toolkit::WebCookieManager* arg1 = (Dali::Toolkit::WebCookieManager*)0;
2499   int ret;
2500
2501   arg1 = (Dali::Toolkit::WebCookieManager*)jarg1;
2502   {
2503     try {
2504       ret = (int)(arg1)->GetCookieAcceptPolicy();
2505     } CALL_CATCH_EXCEPTION(0);
2506   }
2507   return ret;
2508 }
2509
2510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebCookieManager_SetCookieAcceptPolicy(void * jarg1, int jarg2) {
2511   Dali::Toolkit::WebCookieManager* arg1 = (Dali::Toolkit::WebCookieManager*)0;
2512   arg1 = (Dali::Toolkit::WebCookieManager*)jarg1;
2513   {
2514     try {
2515       (arg1)->SetCookieAcceptPolicy(
2516           (Dali::WebEngineCookieManager::CookieAcceptPolicy)jarg2);
2517     } CALL_CATCH_EXCEPTION();
2518   }
2519 }
2520
2521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebCookieManager_SetPersistentStorage(void * jarg1, const char * jarg2, int jarg3) {
2522   Dali::Toolkit::WebCookieManager* arg1 = (Dali::Toolkit::WebCookieManager*)0;
2523
2524   arg1 = (Dali::Toolkit::WebCookieManager*)jarg1;
2525   std::string arg2_str(jarg2);
2526   Dali::WebEngineCookieManager::CookiePersistentStorage arg3_enum = (Dali::WebEngineCookieManager::CookiePersistentStorage)jarg3;
2527   {
2528     try {
2529       (arg1)->SetPersistentStorage(arg2_str, arg3_enum);
2530     } CALL_CATCH_EXCEPTION();
2531   }
2532 }
2533
2534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebCookieManager_ClearCookies(void * jarg1) {
2535   Dali::Toolkit::WebCookieManager* arg1 = (Dali::Toolkit::WebCookieManager*)0;
2536
2537   arg1 = (Dali::Toolkit::WebCookieManager*)jarg1;
2538   {
2539     try {
2540       (arg1)->ClearCookies();
2541     } CALL_CATCH_EXCEPTION();
2542   }
2543 }
2544
2545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebCookieManager_ChangesWatch(void *jarg1, void *jarg2) {
2546   Dali::Toolkit::WebCookieManager *arg1 = (Dali::Toolkit::WebCookieManager *)jarg1;
2547   void (*callback)() = (void (*)())jarg2;
2548   {
2549     try {
2550       (arg1)->ChangesWatch(callback);
2551     } CALL_CATCH_EXCEPTION();
2552   }
2553 }
2554
2555 //----------------------------------WebFormRepostDecision---------------------------------------------------
2556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebFormRepostDecision_Reply(void *jarg1, bool jarg2) {
2557   Dali::WebEngineFormRepostDecision* arg1 = (Dali::WebEngineFormRepostDecision*)jarg1;
2558   {
2559     try {
2560       arg1->Reply(jarg2);
2561     } CALL_CATCH_EXCEPTION();
2562   }
2563 }
2564
2565 //----------------------------------WebFrame---------------------------------------------------
2566 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebFrame_IsMainFrame(void* jarg1) {
2567   Dali::WebEngineFrame* arg1 = (Dali::WebEngineFrame*)jarg1;
2568   bool result = false;
2569   {
2570     try {
2571       result = (arg1)->IsMainFrame();
2572     } CALL_CATCH_EXCEPTION(0);
2573   }
2574   return result;
2575 }
2576
2577 //----------------------------------WebPolicyDecision-----------------------------------------------------
2578 SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetUrl(void* jarg1) {
2579   Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1;
2580   std::string result;
2581   {
2582     try {
2583       result = arg1->GetUrl();
2584     } CALL_CATCH_EXCEPTION(0);
2585   }
2586   char* jresult = SWIG_csharp_string_callback(result.c_str());
2587   return jresult;
2588 }
2589
2590 SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetCookie(void* jarg1) {
2591   Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1;
2592   std::string result;
2593   {
2594     try {
2595       result = arg1->GetCookie();
2596     } CALL_CATCH_EXCEPTION(0);
2597   }
2598   char* jresult = SWIG_csharp_string_callback(result.c_str());
2599   return jresult;
2600 }
2601
2602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetDecisionType(void* jarg1) {
2603   Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1;
2604   int result;
2605   {
2606     try {
2607       result = (int)arg1->GetDecisionType();
2608     } CALL_CATCH_EXCEPTION(0);
2609   }
2610   return result;
2611 }
2612
2613 SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetResponseMime(void* jarg1) {
2614   Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1;
2615   std::string result;
2616   {
2617     try {
2618       result = arg1->GetResponseMime();
2619     } CALL_CATCH_EXCEPTION(0);
2620   }
2621   char* jresult = SWIG_csharp_string_callback(result.c_str());
2622   return jresult;
2623 }
2624
2625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetResponseStatusCode(void* jarg1) {
2626   Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1;
2627   int result;
2628   {
2629     try {
2630       result = arg1->GetResponseStatusCode();
2631     } CALL_CATCH_EXCEPTION(0);
2632   }
2633   return result;
2634 }
2635
2636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetNavigationType(void* jarg1) {
2637   Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1;
2638   int result;
2639   {
2640     try {
2641       result = (int)arg1->GetNavigationType();
2642     } CALL_CATCH_EXCEPTION(0);
2643   }
2644   return result;
2645 }
2646
2647 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetFrame(void* jarg1) {
2648   Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1;
2649   Dali::WebEngineFrame* result = 0;
2650   {
2651     try {
2652       result = &((arg1)->GetFrame());
2653     } CALL_CATCH_EXCEPTION(0);
2654   }
2655   return result;
2656 }
2657
2658 SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetScheme(void* jarg1) {
2659   Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1;
2660   std::string result;
2661   {
2662     try {
2663       result = arg1->GetScheme();
2664     } CALL_CATCH_EXCEPTION(0);
2665   }
2666   char* jresult = SWIG_csharp_string_callback(result.c_str());
2667   return jresult;
2668 }
2669
2670 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebPolicyDecision_Use(void* jarg1) {
2671   Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1;
2672   bool result;
2673   {
2674     try {
2675       result = arg1->Use();
2676     } CALL_CATCH_EXCEPTION(0);
2677   }
2678   return result;
2679 }
2680
2681 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebPolicyDecision_Ignore(void* jarg1) {
2682   Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1;
2683   bool result;
2684   {
2685     try {
2686       result = arg1->Ignore();
2687     } CALL_CATCH_EXCEPTION(0);
2688   }
2689   return result;
2690 }
2691
2692 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebPolicyDecision_Suspend(void* jarg1) {
2693   Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1;
2694   bool result;
2695   {
2696     try {
2697       result = arg1->Suspend();
2698     } CALL_CATCH_EXCEPTION(0);
2699   }
2700   return result;
2701 }
2702
2703 //----------------------------------WebRequestInterceptor---------------------------------------------------
2704 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_GetUrl(void * jarg1) {
2705   Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1;
2706   std::string result;
2707   {
2708     try {
2709       result = (arg1)->GetUrl();
2710     } CALL_CATCH_EXCEPTION(0);
2711   }
2712   char* jresult = SWIG_csharp_string_callback(result.c_str());
2713   return jresult;
2714 }
2715
2716 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_Ignore(void * jarg1) {
2717   Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1;
2718   bool ret = false;
2719   {
2720     try {
2721       ret = (arg1)->Ignore();
2722     } CALL_CATCH_EXCEPTION(0);
2723   }
2724   return ret;
2725 }
2726
2727 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_SetResponseStatus(void * jarg1, int jarg2, const char *jarg3) {
2728   Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1;
2729   bool ret = false;
2730   std::string arg3_str(jarg3);
2731   {
2732     try {
2733       ret = (arg1)->SetResponseStatus(jarg2, arg3_str);
2734     } CALL_CATCH_EXCEPTION(0);
2735   }
2736   return ret;
2737 }
2738
2739 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_AddResponseHeader(void * jarg1, const char *jarg2, const char *jarg3) {
2740   Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1;
2741   bool ret = false;
2742   std::string arg2_str(jarg2);
2743   std::string arg3_str(jarg3);
2744   {
2745     try {
2746       ret = (arg1)->AddResponseHeader(arg2_str, arg3_str);
2747     } CALL_CATCH_EXCEPTION(0);
2748   }
2749   return ret;
2750 }
2751
2752 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_AddResponseBody(void * jarg1, const char *jarg2, uint32_t length) {
2753   Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1;
2754   bool ret = false;
2755   std::string arg2_str(jarg2);
2756   {
2757     try {
2758       ret = (arg1)->AddResponseBody(arg2_str, length);
2759     } CALL_CATCH_EXCEPTION(0);
2760   }
2761   return ret;
2762 }
2763
2764 //----------------------------------WebHttpAuthHandler---------------------------------------------------
2765 SWIGEXPORT const char *SWIGSTDCALL CSharp_Dali_WebHttpAuthHandler_GetRealm(void * jarg1) {
2766   Dali::WebEngineHttpAuthHandler* arg1 = (Dali::WebEngineHttpAuthHandler*)jarg1;
2767   std::string result;
2768   {
2769     try {
2770       result = (arg1)->GetRealm();
2771     } CALL_CATCH_EXCEPTION(0);
2772   }
2773   char *jresult = SWIG_csharp_string_callback(result.c_str());
2774   return jresult;
2775 }
2776
2777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebHttpAuthHandler_Suspend(void * jarg1) {
2778   Dali::WebEngineHttpAuthHandler* arg1 = (Dali::WebEngineHttpAuthHandler*)jarg1;
2779   {
2780     try {
2781       (arg1)->Suspend();
2782     } CALL_CATCH_EXCEPTION();
2783   }
2784 }
2785
2786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebHttpAuthHandler_UseCredential(
2787     void * jarg1, const char *jarg2, const char *jarg3) {
2788   Dali::WebEngineHttpAuthHandler* arg1 = (Dali::WebEngineHttpAuthHandler*)jarg1;
2789   std::string arg2_str(jarg2);
2790   std::string arg3_str(jarg3);
2791   {
2792     try {
2793       (arg1)->UseCredential(arg2_str, arg3_str);
2794     } CALL_CATCH_EXCEPTION();
2795   }
2796 }
2797
2798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebHttpAuthHandler_CancelCredential(void * jarg1) {
2799   Dali::WebEngineHttpAuthHandler* arg1 = (Dali::WebEngineHttpAuthHandler*)jarg1;
2800   {
2801     try {
2802       (arg1)->CancelCredential();
2803     } CALL_CATCH_EXCEPTION();
2804   }
2805 }
2806
2807 //----------------------------------WebPasswordData---------------------------------------------------
2808 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebPasswordData_GetUrl(void * jarg1) {
2809   Dali::WebEngineContext::PasswordData *arg1 = (Dali::WebEngineContext::PasswordData *)jarg1;
2810   std::string result;
2811   {
2812     try {
2813       result = (arg1)->url;
2814     } CALL_CATCH_EXCEPTION(0);
2815   }
2816   char * jresult = SWIG_csharp_string_callback(result.c_str());
2817   return jresult;
2818 }
2819
2820 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebPasswordData_GetUseFingerprint(void * jarg1) {
2821   Dali::WebEngineContext::PasswordData * arg1 = (Dali::WebEngineContext::PasswordData *)jarg1;
2822   bool result = false;
2823   {
2824     try {
2825       result = (arg1)->useFingerprint;
2826     } CALL_CATCH_EXCEPTION(0);
2827   }
2828   return result;
2829 }
2830
2831 //----------------------------------WebLoadError-----------------------------------------------------
2832 SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebLoadError_GetUrl(void* jarg1) {
2833   Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1;
2834   std::string result;
2835   {
2836     try {
2837       result = arg1->GetUrl();
2838     } CALL_CATCH_EXCEPTION(0);
2839   }
2840   char* jresult = SWIG_csharp_string_callback(result.c_str());
2841   return jresult;
2842 }
2843
2844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebLoadError_GetCode(void* jarg1) {
2845   Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1;
2846   int result;
2847   {
2848     try {
2849       result = (int)arg1->GetCode();
2850     } CALL_CATCH_EXCEPTION(0);
2851   }
2852   return result;
2853 }
2854
2855 SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebLoadError_GetDescription(void* jarg1) {
2856   Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1;
2857   std::string result;
2858   {
2859     try {
2860       result = arg1->GetDescription();
2861     } CALL_CATCH_EXCEPTION(0);
2862   }
2863   char* jresult = SWIG_csharp_string_callback(result.c_str());
2864   return jresult;
2865 }
2866
2867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebLoadError_GetType(void* jarg1) {
2868   Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1;
2869   int result;
2870   {
2871     try {
2872       result = (int)arg1->GetType();
2873     } CALL_CATCH_EXCEPTION(0);
2874   }
2875   return result;
2876 }
2877
2878 //----------------------------------WebPasswordDataList---------------------------------------------------
2879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebPasswordDataList(void * jarg1) {
2880   if (!jarg1) {
2881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebEngineContext::PasswordData List is null", 0);
2882     return;
2883   }
2884
2885   std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>>* arg1 = (std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>>*)jarg1;
2886   {
2887     try {
2888       delete arg1;
2889     } CALL_CATCH_EXCEPTION();
2890   }
2891 }
2892
2893 SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebPasswordDataList_GetItemCount(void* jarg1) {
2894   std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>>* arg1 = (std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>>*)jarg1;
2895   uint32_t result = 0;
2896   {
2897     try {
2898       result = (arg1)->size();
2899     } CALL_CATCH_EXCEPTION(0);
2900   }
2901   return result;
2902 }
2903
2904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebPasswordDataList_ValueOfIndex(void * jarg1, unsigned int jarg2) {
2905   std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>>* arg1 = (std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>>*)jarg1;
2906   Dali::WebEngineContext::PasswordData* result = 0;
2907   {
2908     try {
2909       result = ((arg1)->operator[](jarg2)).get();
2910     } CALL_CATCH_EXCEPTION(0);
2911   }
2912
2913   return result;
2914 }
2915
2916 //----------------------------------WebSecurityOrigin---------------------------------------------------
2917 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebSecurityOrigin_GetHost(void * jarg1) {
2918   Dali::WebEngineSecurityOrigin *arg1 = (Dali::WebEngineSecurityOrigin *)jarg1;
2919   std::string result;
2920   {
2921     try {
2922       result = (arg1)->GetHost();
2923     } CALL_CATCH_EXCEPTION(0);
2924   }
2925   char * jresult = SWIG_csharp_string_callback(result.c_str());
2926   return jresult;
2927 }
2928
2929 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebSecurityOrigin_GetProtocol(void * jarg1) {
2930   Dali::WebEngineSecurityOrigin *arg1 = (Dali::WebEngineSecurityOrigin *)jarg1;
2931   std::string result;
2932   {
2933     try {
2934       result = (arg1)->GetProtocol();
2935     } CALL_CATCH_EXCEPTION(0);
2936   }
2937   char * jresult = SWIG_csharp_string_callback(result.c_str());
2938   return jresult;
2939 }
2940
2941 //----------------------------------WebSecurityOriginList---------------------------------------------------
2942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebSecurityOriginList(void *jarg1) {
2943   if (!jarg1) {
2944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebEngineSecurityOrigin List is null", 0);
2945     return;
2946   }
2947
2948   std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>>* arg1 = (std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>>*)jarg1;
2949   {
2950     try {
2951       delete arg1;
2952     } CALL_CATCH_EXCEPTION();
2953   }
2954 }
2955
2956 SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebSecurityOriginList_GetItemCount(void* jarg1) {
2957   std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>>* arg1 = (std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>>*)jarg1;
2958   uint32_t result = 0;
2959   {
2960     try {
2961       result = (arg1)->size();
2962     } CALL_CATCH_EXCEPTION(0);
2963   }
2964   return result;
2965 }
2966
2967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebSecurityOriginList_ValueOfIndex(void *jarg1, unsigned int jarg2) {
2968   std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>>* arg1 = (std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>>*)jarg1;
2969   Dali::WebEngineSecurityOrigin * result = 0;
2970   {
2971     try {
2972       result = ((arg1)->operator[](jarg2)).get();
2973     } CALL_CATCH_EXCEPTION(0);
2974   }
2975   return result;
2976 }
2977
2978 //----------------------------------WebHitTest---------------------------------------------------
2979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebHitTest(void * jarg1) {
2980   if (!jarg1) {
2981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebEngineHitTest is null", 0);
2982     return;
2983   }
2984
2985   Dali::WebEngineHitTest* arg1 = (Dali::WebEngineHitTest*)jarg1;
2986   {
2987     try {
2988       delete arg1;
2989     } CALL_CATCH_EXCEPTION();
2990   }
2991 }
2992
2993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebHitTest_GetResultContext(void * jarg1) {
2994   Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1;
2995   int ret;
2996   {
2997     try {
2998       ret = (int)(arg1)->GetResultContext();
2999     } CALL_CATCH_EXCEPTION(0);
3000   }
3001   return ret;
3002 }
3003
3004 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetLinkUri(void * jarg1) {
3005   Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1;
3006   std::string result;
3007   {
3008     try {
3009       result = (arg1)->GetLinkUri();
3010     } CALL_CATCH_EXCEPTION(0);
3011   }
3012   char *jresult = SWIG_csharp_string_callback(result.c_str());
3013   return jresult;
3014 }
3015
3016 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetLinkTitle(void * jarg1) {
3017   Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1;
3018   std::string result;
3019   {
3020     try {
3021       result = (arg1)->GetLinkTitle();
3022     } CALL_CATCH_EXCEPTION(0);
3023   }
3024   char *jresult = SWIG_csharp_string_callback(result.c_str());
3025   return jresult;
3026 }
3027
3028 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetLinkLabel(void * jarg1) {
3029   Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1;
3030   std::string result;
3031   {
3032     try {
3033       result = (arg1)->GetLinkLabel();
3034     } CALL_CATCH_EXCEPTION(0);
3035   }
3036   char *jresult = SWIG_csharp_string_callback(result.c_str());
3037   return jresult;
3038 }
3039
3040 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetImageUri(void * jarg1) {
3041   Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1;
3042   std::string result;
3043   {
3044     try {
3045       result = (arg1)->GetImageUri();
3046     } CALL_CATCH_EXCEPTION(0);
3047   }
3048   char * jresult = SWIG_csharp_string_callback(result.c_str());
3049   return jresult;
3050 }
3051
3052 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetMediaUri(void * jarg1) {
3053   Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1;
3054   std::string result;
3055   {
3056     try {
3057       result = (arg1)->GetMediaUri();
3058     } CALL_CATCH_EXCEPTION(0);
3059   }
3060   char * jresult = SWIG_csharp_string_callback(result.c_str());
3061   return jresult;
3062 }
3063
3064 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetTagName(void * jarg1) {
3065   Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1;
3066   std::string result;
3067   {
3068     try {
3069       result = (arg1)->GetTagName();
3070     } CALL_CATCH_EXCEPTION(0);
3071   }
3072   char *jresult = SWIG_csharp_string_callback(result.c_str());
3073   return jresult;
3074 }
3075
3076 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetNodeValue(void * jarg1) {
3077   Dali::WebEngineHitTest * arg1 = (Dali::WebEngineHitTest *)jarg1;
3078   std::string result;
3079   {
3080     try {
3081       result = (arg1)->GetNodeValue();
3082     } CALL_CATCH_EXCEPTION(0);
3083   }
3084   char * jresult = SWIG_csharp_string_callback(result.c_str());
3085   return jresult;
3086 }
3087
3088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebHitTest_GetAttributes(void * jarg1) {
3089   Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1;
3090   Dali::Property::Map *result = 0;
3091   {
3092     try {
3093       result = &(arg1)->GetAttributes();
3094     } CALL_CATCH_EXCEPTION(0);
3095   }
3096   return (void *)result;
3097 }
3098
3099 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetImageFileNameExtension(void * jarg1) {
3100   Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1;
3101   std::string result;
3102   {
3103     try {
3104       result = (arg1)->GetImageFileNameExtension();
3105     } CALL_CATCH_EXCEPTION(0);
3106   }
3107   char *jresult = SWIG_csharp_string_callback(result.c_str());
3108   return jresult;
3109 }
3110
3111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebHitTest_GetImageBuffer(void * jarg1) {
3112   Dali::WebEngineHitTest* arg1 = (Dali::WebEngineHitTest *)jarg1;
3113   Dali::PixelData result;
3114   {
3115     try {
3116       result = (arg1)->GetImageBuffer();
3117     } CALL_CATCH_EXCEPTION(0);
3118   }
3119
3120   Dali::PixelData* jresult = new Dali::PixelData((const Dali::PixelData &)result);
3121   return (void *)jresult;
3122 }
3123
3124 //----------------------------------WebSettings---------------------------------------------------
3125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_AllowMixedContents(void * jarg1, bool jarg2) {
3126   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3127
3128   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3129   {
3130     try {
3131       (arg1)->AllowMixedContents(jarg2);
3132     } CALL_CATCH_EXCEPTION();
3133   }
3134 }
3135
3136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableSpatialNavigation(void * jarg1, bool jarg2) {
3137   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3138
3139   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3140   {
3141     try {
3142       (arg1)->EnableSpatialNavigation(jarg2);
3143     } CALL_CATCH_EXCEPTION();
3144   }
3145 }
3146
3147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebSettings_GetDefaultFontSize(void * jarg1) {
3148   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3149   int ret;
3150
3151   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3152   {
3153     try {
3154       ret = (arg1)->GetDefaultFontSize();
3155     } CALL_CATCH_EXCEPTION(0);
3156   }
3157   return ret;
3158 }
3159
3160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_SetDefaultFontSize(void * jarg1, int jarg2) {
3161   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3162
3163   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3164   {
3165     try {
3166       (arg1)->SetDefaultFontSize(jarg2);
3167     } CALL_CATCH_EXCEPTION();
3168   }
3169 }
3170
3171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableWebSecurity(void * jarg1, bool jarg2) {
3172   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3173
3174   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3175   {
3176     try {
3177       (arg1)->EnableWebSecurity(jarg2);
3178     } CALL_CATCH_EXCEPTION();
3179   }
3180 }
3181
3182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableCacheBuilder(void * jarg1, bool jarg2) {
3183   Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0;
3184
3185   arg1 = (Dali::Toolkit::WebSettings*)jarg1;
3186   {
3187     try {
3188       (arg1)->EnableCacheBuilder(jarg2);
3189     } CALL_CATCH_EXCEPTION();
3190   }
3191 }
3192
3193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_UseScrollbarThumbFocusNotifications(void * jarg1, bool jarg2) {
3194   Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0;
3195
3196   arg1 = (Dali::Toolkit::WebSettings*)jarg1;
3197   {
3198     try {
3199       (arg1)->UseScrollbarThumbFocusNotifications(jarg2);
3200     } CALL_CATCH_EXCEPTION();
3201   }
3202 }
3203
3204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableDoNotTrack(void * jarg1, bool jarg2) {
3205   Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0;
3206
3207   arg1 = (Dali::Toolkit::WebSettings*)jarg1;
3208   {
3209     try {
3210       (arg1)->EnableDoNotTrack(jarg2);
3211     } CALL_CATCH_EXCEPTION();
3212   }
3213 }
3214
3215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_AllowFileAccessFromExternalUrl(void * jarg1, bool jarg2) {
3216   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3217
3218   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3219   {
3220     try {
3221       (arg1)->AllowFileAccessFromExternalUrl(jarg2);
3222     } CALL_CATCH_EXCEPTION();
3223   }
3224 }
3225
3226 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsJavaScriptEnabled(void * jarg1) {
3227   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3228   bool ret;
3229
3230   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3231   {
3232     try {
3233       ret = (arg1)->IsJavaScriptEnabled();
3234     } CALL_CATCH_EXCEPTION(0);
3235   }
3236   return ret;
3237 }
3238
3239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableJavaScript(void * jarg1, bool jarg2) {
3240   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3241
3242   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3243   {
3244     try {
3245       (arg1)->EnableJavaScript(jarg2);
3246     } CALL_CATCH_EXCEPTION();
3247   }
3248 }
3249
3250 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsAutoFittingEnabled(void * jarg1) {
3251   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3252   bool ret;
3253
3254   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3255   {
3256     try {
3257       ret = (arg1)->IsAutoFittingEnabled();
3258     } CALL_CATCH_EXCEPTION(0);
3259   }
3260   return ret;
3261 }
3262
3263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableAutoFitting(void * jarg1, bool jarg2) {
3264   Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0;
3265
3266   arg1 = (Dali::Toolkit::WebSettings*)jarg1;
3267   {
3268     try {
3269       (arg1)->EnableAutoFitting(jarg2);
3270     } CALL_CATCH_EXCEPTION();
3271   }
3272 }
3273
3274 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_ArePluginsEnabled(void * jarg1) {
3275   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3276   bool ret;
3277
3278   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3279   {
3280     try {
3281       ret = (arg1)->ArePluginsEnabled();
3282     } CALL_CATCH_EXCEPTION(0);
3283   }
3284   return ret;
3285 }
3286
3287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnablePlugins(void * jarg1, bool jarg2) {
3288   Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0;
3289
3290   arg1 = (Dali::Toolkit::WebSettings*)jarg1;
3291   {
3292     try {
3293       (arg1)->EnablePlugins(jarg2);
3294     } CALL_CATCH_EXCEPTION();
3295   }
3296 }
3297
3298 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsPrivateBrowsingEnabled(void * jarg1) {
3299   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3300   bool ret;
3301
3302   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3303   {
3304     try {
3305       ret = (arg1)->IsPrivateBrowsingEnabled();
3306     } CALL_CATCH_EXCEPTION(0);
3307   }
3308   return ret;
3309 }
3310
3311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnablePrivateBrowsing(void * jarg1, bool jarg2) {
3312   Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0;
3313
3314   arg1 = (Dali::Toolkit::WebSettings*)jarg1;
3315   {
3316     try {
3317       (arg1)->EnablePrivateBrowsing(jarg2);
3318     } CALL_CATCH_EXCEPTION();
3319   }
3320 }
3321
3322 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsLinkMagnifierEnabled(void * jarg1) {
3323   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3324   bool ret;
3325
3326   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3327   {
3328     try {
3329       ret = (arg1)->IsLinkMagnifierEnabled();
3330     } CALL_CATCH_EXCEPTION(0);
3331   }
3332   return ret;
3333 }
3334
3335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableLinkMagnifier(void * jarg1, bool jarg2) {
3336   Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0;
3337
3338   arg1 = (Dali::Toolkit::WebSettings*)jarg1;
3339   {
3340     try {
3341       (arg1)->EnableLinkMagnifier(jarg2);
3342     } CALL_CATCH_EXCEPTION();
3343   }
3344 }
3345
3346 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsKeypadWithoutUserActionUsed(void * jarg1) {
3347   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3348   bool ret;
3349
3350   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3351   {
3352     try {
3353       ret = (arg1)->IsKeypadWithoutUserActionUsed();
3354     } CALL_CATCH_EXCEPTION(0);
3355   }
3356   return ret;
3357 }
3358
3359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_UseKeypadWithoutUserAction(void * jarg1, bool jarg2) {
3360   Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0;
3361
3362   arg1 = (Dali::Toolkit::WebSettings*)jarg1;
3363   {
3364     try {
3365       (arg1)->UseKeypadWithoutUserAction(jarg2);
3366     } CALL_CATCH_EXCEPTION();
3367   }
3368 }
3369
3370 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsAutofillPasswordFormEnabled(void * jarg1) {
3371   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3372   bool ret;
3373
3374   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3375   {
3376     try {
3377       ret = (arg1)->IsAutofillPasswordFormEnabled();
3378     } CALL_CATCH_EXCEPTION(0);
3379   }
3380   return ret;
3381 }
3382
3383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableAutofillPasswordForm(void * jarg1, bool jarg2) {
3384   Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0;
3385
3386   arg1 = (Dali::Toolkit::WebSettings*)jarg1;
3387   {
3388     try {
3389       (arg1)->EnableAutofillPasswordForm(jarg2);
3390     } CALL_CATCH_EXCEPTION();
3391   }
3392 }
3393
3394 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsFormCandidateDataEnabled(void * jarg1) {
3395   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3396   bool ret;
3397
3398   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3399   {
3400     try {
3401       ret = (arg1)->IsFormCandidateDataEnabled();
3402     } CALL_CATCH_EXCEPTION(0);
3403   }
3404   return ret;
3405 }
3406
3407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableFormCandidateData(void * jarg1, bool jarg2) {
3408   Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0;
3409
3410   arg1 = (Dali::Toolkit::WebSettings*)jarg1;
3411   {
3412     try {
3413       (arg1)->EnableFormCandidateData(jarg2);
3414     } CALL_CATCH_EXCEPTION();
3415   }
3416 }
3417
3418 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsTextSelectionEnabled(void * jarg1) {
3419   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3420   bool ret;
3421
3422   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3423   {
3424     try {
3425       ret = (arg1)->IsTextSelectionEnabled();
3426     } CALL_CATCH_EXCEPTION(0);
3427   }
3428   return ret;
3429 }
3430
3431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableTextSelection(void * jarg1, bool jarg2) {
3432   Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0;
3433
3434   arg1 = (Dali::Toolkit::WebSettings*)jarg1;
3435   {
3436     try {
3437       (arg1)->EnableTextSelection(jarg2);
3438     } CALL_CATCH_EXCEPTION();
3439   }
3440 }
3441
3442 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsTextAutosizingEnabled(void * jarg1) {
3443   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3444   bool ret;
3445
3446   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3447   {
3448     try {
3449       ret = (arg1)->IsTextAutosizingEnabled();
3450     } CALL_CATCH_EXCEPTION(0);
3451   }
3452   return ret;
3453 }
3454
3455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableTextAutosizing(void * jarg1, bool jarg2) {
3456   Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0;
3457
3458   arg1 = (Dali::Toolkit::WebSettings*)jarg1;
3459   {
3460     try {
3461       (arg1)->EnableTextAutosizing(jarg2);
3462     } CALL_CATCH_EXCEPTION();
3463   }
3464 }
3465
3466 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsArrowScrollEnabled(void * jarg1) {
3467   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3468   bool ret;
3469
3470   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3471   {
3472     try {
3473       ret = (arg1)->IsArrowScrollEnabled();
3474     } CALL_CATCH_EXCEPTION(0);
3475   }
3476   return ret;
3477 }
3478
3479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableArrowScroll(void * jarg1, bool jarg2) {
3480   Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0;
3481
3482   arg1 = (Dali::Toolkit::WebSettings*)jarg1;
3483   {
3484     try {
3485       (arg1)->EnableArrowScroll(jarg2);
3486     } CALL_CATCH_EXCEPTION();
3487   }
3488 }
3489
3490 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsClipboardEnabled(void * jarg1) {
3491   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3492   bool ret;
3493
3494   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3495   {
3496     try {
3497       ret = (arg1)->IsClipboardEnabled();
3498     } CALL_CATCH_EXCEPTION(0);
3499   }
3500   return ret;
3501 }
3502
3503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableClipboard(void * jarg1, bool jarg2) {
3504   Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0;
3505
3506   arg1 = (Dali::Toolkit::WebSettings*)jarg1;
3507   {
3508     try {
3509       (arg1)->EnableClipboard(jarg2);
3510     } CALL_CATCH_EXCEPTION();
3511   }
3512 }
3513
3514 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsImePanelEnabled(void * jarg1) {
3515   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3516   bool ret;
3517
3518   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3519   {
3520     try {
3521       ret = (arg1)->IsImePanelEnabled();
3522     } CALL_CATCH_EXCEPTION(0);
3523   }
3524   return ret;
3525 }
3526
3527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableImePanel(void * jarg1, bool jarg2) {
3528   Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0;
3529
3530   arg1 = (Dali::Toolkit::WebSettings*)jarg1;
3531   {
3532     try {
3533       (arg1)->EnableImePanel(jarg2);
3534     } CALL_CATCH_EXCEPTION();
3535   }
3536 }
3537
3538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_AllowScriptsOpenWindows(void * jarg1, bool jarg2) {
3539   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3540
3541   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3542   {
3543     try {
3544       (arg1)->AllowScriptsOpenWindows(jarg2);
3545     } CALL_CATCH_EXCEPTION();
3546   }
3547 }
3548
3549 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_AreImagesLoadedAutomatically(void * jarg1) {
3550   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3551   bool ret;
3552
3553   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3554   {
3555     try {
3556       ret = (arg1)->AreImagesLoadedAutomatically();
3557     } CALL_CATCH_EXCEPTION(0);
3558   }
3559   return ret;
3560 }
3561
3562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_AllowImagesLoadAutomatically(void * jarg1, bool jarg2) {
3563   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3564
3565   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3566   {
3567     try {
3568       (arg1)->AllowImagesLoadAutomatically(jarg2);
3569     } CALL_CATCH_EXCEPTION();
3570   }
3571 }
3572
3573 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebSettings_GetDefaultTextEncodingName(void * jarg1) {
3574   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3575   std::string result;
3576
3577   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3578   {
3579     try {
3580       result = (arg1)->GetDefaultTextEncodingName();
3581     } CALL_CATCH_EXCEPTION(0);
3582   }
3583   char * jresult = SWIG_csharp_string_callback(result.c_str());
3584   return jresult;
3585 }
3586
3587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_SetDefaultTextEncodingName(void * jarg1, const char * jarg2) {
3588   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3589
3590   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3591   std::string arg2_str(jarg2);
3592   {
3593     try {
3594       (arg1)->SetDefaultTextEncodingName(arg2_str);
3595     } CALL_CATCH_EXCEPTION();
3596   }
3597 }
3598
3599 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_SetViewportMetaTag(void *jarg1, bool jarg2) {
3600   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3601   bool ret;
3602
3603   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3604   {
3605     try {
3606       ret = (arg1)->SetViewportMetaTag(jarg2);
3607     } CALL_CATCH_EXCEPTION(0);
3608   }
3609   return ret;
3610 }
3611
3612 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_SetForceZoom(void *jarg1, bool jarg2) {
3613   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3614   bool ret;
3615
3616   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3617   {
3618     try {
3619       ret = (arg1)->SetForceZoom(jarg2);
3620     } CALL_CATCH_EXCEPTION(0);
3621   }
3622   return ret;
3623 }
3624
3625 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsZoomForced(void *jarg1) {
3626   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3627   bool ret;
3628
3629   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3630   {
3631     try {
3632       ret = (arg1)->IsZoomForced();
3633     } CALL_CATCH_EXCEPTION(0);
3634   }
3635   return ret;
3636 }
3637
3638 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_SetTextZoomEnabled(void *jarg1, bool jarg2) {
3639   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3640   bool ret;
3641
3642   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3643   {
3644     try {
3645       ret = (arg1)->SetTextZoomEnabled(jarg2);
3646     } CALL_CATCH_EXCEPTION(0);
3647   }
3648   return ret;
3649 }
3650
3651 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsTextZoomEnabled(void *jarg1) {
3652   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3653   bool ret;
3654
3655   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3656   {
3657     try {
3658       ret = (arg1)->IsTextZoomEnabled();
3659     } CALL_CATCH_EXCEPTION(0);
3660   }
3661   return ret;
3662 }
3663
3664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_SetExtraFeature(void *jarg1, const char *jarg2, bool jarg3) {
3665   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3666   std::string arg2(jarg2);
3667
3668   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3669   {
3670     try {
3671       (arg1)->SetExtraFeature(arg2, jarg3);
3672     } CALL_CATCH_EXCEPTION();
3673   }
3674 }
3675
3676 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsExtraFeatureEnabled(void *jarg1, const char *jarg2) {
3677   Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0;
3678   std::string arg2(jarg2);
3679   bool ret;
3680
3681   arg1 = (Dali::Toolkit::WebSettings *)jarg1;
3682   {
3683     try {
3684       ret = (arg1)->IsExtraFeatureEnabled(arg2);
3685     } CALL_CATCH_EXCEPTION(0);
3686   }
3687   return ret;
3688 }
3689
3690 #ifdef __cplusplus
3691 } // end extern "C"
3692 #endif