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

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