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

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