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

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