dali-toolkit/internal/controls/web-view/web-view-impl.cpp

   1 /*
   2  * Copyright (c) 2021 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 // CLASS HEADER
  19 #include "web-view-impl.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/adaptor-framework/web-engine-back-forward-list.h>
  23 #include <dali/devel-api/adaptor-framework/web-engine-certificate.h>
  24 #include <dali/devel-api/adaptor-framework/web-engine-console-message.h>
  25 #include <dali/devel-api/adaptor-framework/web-engine-context-menu-item.h>
  26 #include <dali/devel-api/adaptor-framework/web-engine-context-menu.h>
  27 #include <dali/devel-api/adaptor-framework/web-engine-context.h>
  28 #include <dali/devel-api/adaptor-framework/web-engine-cookie-manager.h>
  29 #include <dali/devel-api/adaptor-framework/web-engine-form-repost-decision.h>
  30 #include <dali/devel-api/adaptor-framework/web-engine-hit-test.h>
  31 #include <dali/devel-api/adaptor-framework/web-engine-http-auth-handler.h>
  32 #include <dali/devel-api/adaptor-framework/web-engine-load-error.h>
  33 #include <dali/devel-api/adaptor-framework/web-engine-policy-decision.h>
  34 #include <dali/devel-api/adaptor-framework/web-engine-request-interceptor.h>
  35 #include <dali/devel-api/adaptor-framework/web-engine-settings.h>
  36 #include <dali/devel-api/common/stage.h>
  37 #include <dali/devel-api/scripting/enum-helper.h>
  38 #include <dali/devel-api/scripting/scripting.h>
  39 #include <dali/public-api/adaptor-framework/native-image-source.h>
  40 #include <dali/public-api/object/type-registry-helper.h>
  41 #include <dali/public-api/object/type-registry.h>
  42 #include <cstring>
  43 #include <memory>
  44
  45 // INTERNAL INCLUDES
  46 #include <dali-toolkit/devel-api/controls/control-devel.h>
  47 #include <dali-toolkit/devel-api/controls/web-view/web-back-forward-list.h>
  48 #include <dali-toolkit/devel-api/controls/web-view/web-context.h>
  49 #include <dali-toolkit/devel-api/controls/web-view/web-cookie-manager.h>
  50 #include <dali-toolkit/devel-api/controls/web-view/web-settings.h>
  51 #include <dali-toolkit/devel-api/image-loader/texture-manager.h>
  52 #include <dali-toolkit/internal/visuals/visual-factory-impl.h>
  53 #include <dali-toolkit/public-api/image-loader/image.h>
  54 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  55
  56 namespace Dali
  57 {
  58 namespace Toolkit
  59 {
  60 namespace Internal
  61 {
  62 namespace
  63 {
  64 BaseHandle Create()
  65 {
  66   return Toolkit::WebView::New();
  67 }
  68
  69 // clang-format off
  70 DALI_TYPE_REGISTRATION_BEGIN(Toolkit::WebView, Toolkit::Control, Create)
  71
  72 DALI_PROPERTY_REGISTRATION(Toolkit, WebView, "url",                     STRING,  URL                       )
  73 DALI_PROPERTY_REGISTRATION(Toolkit, WebView, "userAgent",               STRING,  USER_AGENT                )
  74 DALI_PROPERTY_REGISTRATION(Toolkit, WebView, "scrollPosition",          VECTOR2, SCROLL_POSITION           )
  75 DALI_PROPERTY_REGISTRATION(Toolkit, WebView, "scrollSize",              VECTOR2, SCROLL_SIZE               )
  76 DALI_PROPERTY_REGISTRATION(Toolkit, WebView, "contentSize",             VECTOR2, CONTENT_SIZE              )
  77 DALI_PROPERTY_REGISTRATION(Toolkit, WebView, "title",                   STRING,  TITLE                     )
  78 DALI_PROPERTY_REGISTRATION(Toolkit, WebView, "videoHoleEnabled",        BOOLEAN, VIDEO_HOLE_ENABLED        )
  79 DALI_PROPERTY_REGISTRATION(Toolkit, WebView, "mouseEventsEnabled",      BOOLEAN, MOUSE_EVENTS_ENABLED      )
  80 DALI_PROPERTY_REGISTRATION(Toolkit, WebView, "keyEventsEnabled",        BOOLEAN, KEY_EVENTS_ENABLED        )
  81 DALI_PROPERTY_REGISTRATION(Toolkit, WebView, "documentBackgroundColor", VECTOR4, DOCUMENT_BACKGROUND_COLOR )
  82 DALI_PROPERTY_REGISTRATION(Toolkit, WebView, "tilesClearedWhenHidden",  BOOLEAN, TILES_CLEARED_WHEN_HIDDEN )
  83 DALI_PROPERTY_REGISTRATION(Toolkit, WebView, "tileCoverAreaMultiplier", FLOAT,   TILE_COVER_AREA_MULTIPLIER)
  84 DALI_PROPERTY_REGISTRATION(Toolkit, WebView, "cursorEnabledByClient",   BOOLEAN, CURSOR_ENABLED_BY_CLIENT  )
  85 DALI_PROPERTY_REGISTRATION(Toolkit, WebView, "selectedText",            STRING,  SELECTED_TEXT             )
  86 DALI_PROPERTY_REGISTRATION(Toolkit, WebView, "pageZoomFactor",          FLOAT,   PAGE_ZOOM_FACTOR          )
  87 DALI_PROPERTY_REGISTRATION(Toolkit, WebView, "textZoomFactor",          FLOAT,   TEXT_ZOOM_FACTOR          )
  88 DALI_PROPERTY_REGISTRATION(Toolkit, WebView, "loadProgressPercentage",  FLOAT,   LOAD_PROGRESS_PERCENTAGE  )
  89
  90 DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "pageLoadStarted",         PAGE_LOAD_STARTED_SIGNAL         )
  91 DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "pageLoadInProgress",      PAGE_LOAD_IN_PROGRESS_SIGNAL     )
  92 DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "pageLoadFinished",        PAGE_LOAD_FINISHED_SIGNAL        )
  93 DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "pageLoadError",           PAGE_LOAD_ERROR_SIGNAL           )
  94 DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "scrollEdgeReached",       SCROLL_EDGE_REACHED_SIGNAL       )
  95 DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "urlChanged",              URL_CHANGED_SIGNAL               )
  96 DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "formRepostDecision",      FORM_REPOST_DECISION_SIGNAL      )
  97 DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "frameRendered",           FRAME_RENDERED_SIGNAL            )
  98 DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "requestInterceptor",      REQUEST_INTERCEPTOR_SIGNAL       )
  99 DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "consoleMessage",          CONSOLE_MESSAGE_SIGNAL           )
 100 DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "responsePolicyDecided",   POLICY_DECISION                  )
 101 DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "certificateConfirm",      CERTIFICATE_CONFIRM_SIGNAL       )
 102 DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "sslCertificateChanged",   SSL_CERTIFICATE_CHANGED_SIGNAL   )
 103 DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "httpAuthRequest",         HTTP_AUTH_REQUEST_SIGNAL         )
 104 DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "contextMenuCustomized",   CONTEXT_MENU_CUSTOMIZED_SIGNAL   )
 105 DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "contextMenuItemSelected", CONTEXT_MENU_ITEM_SELECTED_SIGNAL)
 106
 107 DALI_TYPE_REGISTRATION_END()
 108 // clang-format on
 109
 110 const std::string kEmptyString;
 111
 112 } // namespace
 113
 114 #define GET_ENUM_STRING(structName, inputExp) \
 115   Scripting::GetLinearEnumerationName<Toolkit::WebView::structName::Type>(static_cast<Toolkit::WebView::structName::Type>(inputExp), structName##_TABLE, structName##_TABLE_COUNT)
 116
 117 #define GET_ENUM_VALUE(structName, inputExp, outputExp) \
 118   Scripting::GetEnumerationProperty<Toolkit::WebView::structName::Type>(inputExp, structName##_TABLE, structName##_TABLE_COUNT, outputExp)
 119
 120 WebView::WebView(const std::string& locale, const std::string& timezoneId)
 121 : Control(ControlBehaviour(ACTOR_BEHAVIOUR_DEFAULT | DISABLE_STYLE_CHANGE_SIGNALS)),
 122   mUrl(),
 123   mVisual(),
 124   mWebViewSize(Stage::GetCurrent().GetSize()),
 125   mWebEngine(),
 126   mPageLoadStartedSignal(),
 127   mPageLoadFinishedSignal(),
 128   mPageLoadErrorSignal(),
 129   mUrlChangedSignal(),
 130   mWebViewArea(0, 0, mWebViewSize.width, mWebViewSize.height),
 131   mVideoHoleEnabled(true),
 132   mMouseEventsEnabled(true),
 133   mKeyEventsEnabled(true),
 134   mScreenshotCapturedCallback(nullptr)
 135 {
 136   mWebEngine = Dali::WebEngine::New();
 137
 138   // WebEngine is empty when it is not properly initialized.
 139   if(mWebEngine)
 140   {
 141     mWebEngine.Create(mWebViewSize.width, mWebViewSize.height, locale, timezoneId);
 142   }
 143 }
 144
 145 WebView::WebView(uint32_t argc, char** argv)
 146 : Control(ControlBehaviour(ACTOR_BEHAVIOUR_DEFAULT | DISABLE_STYLE_CHANGE_SIGNALS)),
 147   mUrl(),
 148   mVisual(),
 149   mWebViewSize(Stage::GetCurrent().GetSize()),
 150   mWebEngine(),
 151   mPageLoadStartedSignal(),
 152   mPageLoadFinishedSignal(),
 153   mPageLoadErrorSignal(),
 154   mUrlChangedSignal(),
 155   mWebViewArea(0, 0, mWebViewSize.width, mWebViewSize.height),
 156   mVideoHoleEnabled(true),
 157   mMouseEventsEnabled(true),
 158   mKeyEventsEnabled(true),
 159   mScreenshotCapturedCallback(nullptr)
 160 {
 161   mWebEngine = Dali::WebEngine::New();
 162
 163   // WebEngine is empty when it is not properly initialized.
 164   if(mWebEngine)
 165   {
 166     mWebEngine.Create(mWebViewSize.width, mWebViewSize.height, argc, argv);
 167   }
 168 }
 169
 170 WebView::WebView()
 171 : WebView("", "")
 172 {
 173 }
 174
 175 WebView::~WebView()
 176 {
 177   if(mWebEngine)
 178   {
 179     mWebEngine.Destroy();
 180   }
 181 }
 182
 183 Toolkit::WebView WebView::New()
 184 {
 185   WebView*         impl   = new WebView();
 186   Toolkit::WebView handle = Toolkit::WebView(*impl);
 187
 188   impl->Initialize();
 189   return handle;
 190 }
 191
 192 Toolkit::WebView WebView::New(const std::string& locale, const std::string& timezoneId)
 193 {
 194   WebView*         impl   = new WebView(locale, timezoneId);
 195   Toolkit::WebView handle = Toolkit::WebView(*impl);
 196
 197   impl->Initialize();
 198   return handle;
 199 }
 200
 201 Toolkit::WebView WebView::New(uint32_t argc, char** argv)
 202 {
 203   WebView*         impl   = new WebView(argc, argv);
 204   Toolkit::WebView handle = Toolkit::WebView(*impl);
 205
 206   impl->Initialize();
 207   return handle;
 208 }
 209
 210 void WebView::OnInitialize()
 211 {
 212   Actor self = Self();
 213
 214   self.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
 215   self.TouchedSignal().Connect(this, &WebView::OnTouchEvent);
 216   self.HoveredSignal().Connect(this, &WebView::OnHoverEvent);
 217   self.WheelEventSignal().Connect(this, &WebView::OnWheelEvent);
 218   Dali::DevelActor::VisibilityChangedSignal(self).Connect(this, &WebView::OnVisibilityChanged);
 219
 220   mPositionUpdateNotification = self.AddPropertyNotification(Actor::Property::WORLD_POSITION, StepCondition(1.0f, 1.0f));
 221   mSizeUpdateNotification     = self.AddPropertyNotification(Actor::Property::SIZE, StepCondition(1.0f, 1.0f));
 222   mScaleUpdateNotification    = self.AddPropertyNotification(Actor::Property::WORLD_SCALE, StepCondition(0.1f, 1.0f));
 223   mPositionUpdateNotification.NotifySignal().Connect(this, &WebView::UpdateDisplayArea);
 224   mSizeUpdateNotification.NotifySignal().Connect(this, &WebView::UpdateDisplayArea);
 225   mScaleUpdateNotification.NotifySignal().Connect(this, &WebView::UpdateDisplayArea);
 226
 227   if(mWebEngine)
 228   {
 229     mWebEngine.PageLoadStartedSignal().Connect(this, &WebView::OnPageLoadStarted);
 230     mWebEngine.PageLoadInProgressSignal().Connect(this, &WebView::OnPageLoadInProgress);
 231     mWebEngine.PageLoadFinishedSignal().Connect(this, &WebView::OnPageLoadFinished);
 232     mWebEngine.PageLoadErrorSignal().Connect(this, &WebView::OnPageLoadError);
 233     mWebEngine.ScrollEdgeReachedSignal().Connect(this, &WebView::OnScrollEdgeReached);
 234     mWebEngine.UrlChangedSignal().Connect(this, &WebView::OnUrlChanged);
 235     mWebEngine.FormRepostDecisionSignal().Connect(this, &WebView::OnFormRepostDecision);
 236     mWebEngine.FrameRenderedSignal().Connect(this, &WebView::OnFrameRendered);
 237     mWebEngine.RequestInterceptorSignal().Connect(this, &WebView::OnInterceptRequest);
 238     mWebEngine.ConsoleMessageSignal().Connect(this, &WebView::OnConsoleMessage);
 239     mWebEngine.ResponsePolicyDecisionSignal().Connect(this, &WebView::OnResponsePolicyDecided);
 240     mWebEngine.CertificateConfirmSignal().Connect(this, &WebView::OnCertificateConfirm);
 241     mWebEngine.SslCertificateChangedSignal().Connect(this, &WebView::OnSslCertificateChanged);
 242     mWebEngine.HttpAuthHandlerSignal().Connect(this, &WebView::OnHttpAuthenticationRequest);
 243     mWebEngine.ContextMenuCustomizedSignal().Connect(this, &WebView::OnContextMenuCustomized);
 244     mWebEngine.ContextMenuItemSelectedSignal().Connect(this, &WebView::OnContextMenuItemSelected);
 245
 246     mWebContext         = std::unique_ptr<Dali::Toolkit::WebContext>(new WebContext(mWebEngine.GetContext()));
 247     mWebCookieManager   = std::unique_ptr<Dali::Toolkit::WebCookieManager>(new WebCookieManager(mWebEngine.GetCookieManager()));
 248     mWebSettings        = std::unique_ptr<Dali::Toolkit::WebSettings>(new WebSettings(mWebEngine.GetSettings()));
 249     mWebBackForwardList = std::unique_ptr<Dali::Toolkit::WebBackForwardList>(new WebBackForwardList(mWebEngine.GetBackForwardList()));
 250   }
 251 }
 252
 253 Dali::Toolkit::WebSettings* WebView::GetSettings() const
 254 {
 255   return mWebSettings.get();
 256 }
 257
 258 Dali::Toolkit::WebContext* WebView::GetContext() const
 259 {
 260   return mWebContext.get();
 261 }
 262
 263 Dali::Toolkit::WebCookieManager* WebView::GetCookieManager() const
 264 {
 265   return mWebCookieManager.get();
 266 }
 267
 268 Dali::Toolkit::WebBackForwardList* WebView::GetBackForwardList() const
 269 {
 270   return mWebBackForwardList.get();
 271 }
 272
 273 Dali::Toolkit::ImageView WebView::GetFavicon() const
 274 {
 275   Dali::Toolkit::ImageView faviconView;
 276   if(mWebEngine)
 277   {
 278     Dali::PixelData pixelData = mWebEngine.GetFavicon();
 279     faviconView               = CreateImageView(pixelData);
 280   }
 281   return faviconView;
 282 }
 283
 284 void WebView::LoadUrl(const std::string& url)
 285 {
 286   mUrl = url;
 287   if(mWebEngine)
 288   {
 289     if(!mVisual)
 290     {
 291       mWebEngine.FrameRenderedSignal().Connect(this, &WebView::OnInitialFrameRendered);
 292     }
 293
 294     mWebEngine.LoadUrl(url);
 295   }
 296 }
 297
 298 void WebView::LoadHtmlString(const std::string& htmlString)
 299 {
 300   if(mWebEngine)
 301   {
 302     if(!mVisual)
 303     {
 304       mWebEngine.FrameRenderedSignal().Connect(this, &WebView::OnInitialFrameRendered);
 305     }
 306
 307     mWebEngine.LoadHtmlString(htmlString);
 308   }
 309 }
 310
 311 bool WebView::LoadHtmlStringOverrideCurrentEntry(const std::string& html, const std::string& basicUri, const std::string& unreachableUrl)
 312 {
 313   if(!mWebEngine)
 314     return false;
 315
 316   if(!mVisual)
 317   {
 318     mWebEngine.FrameRenderedSignal().Connect(this, &WebView::OnInitialFrameRendered);
 319   }
 320
 321   return mWebEngine.LoadHtmlStringOverrideCurrentEntry(html, basicUri, unreachableUrl);
 322 }
 323
 324 bool WebView::LoadContents(const std::string& contents, uint32_t contentSize, const std::string& mimeType, const std::string& encoding, const std::string& baseUri)
 325 {
 326   if(!mWebEngine)
 327     return false;
 328
 329   if(!mVisual)
 330   {
 331     mWebEngine.FrameRenderedSignal().Connect(this, &WebView::OnInitialFrameRendered);
 332   }
 333
 334   return mWebEngine.LoadContents(contents, contentSize, mimeType, encoding, baseUri);
 335 }
 336
 337 void WebView::Reload()
 338 {
 339   if(mWebEngine)
 340   {
 341     mWebEngine.Reload();
 342   }
 343 }
 344
 345 bool WebView::ReloadWithoutCache()
 346 {
 347   return mWebEngine ? mWebEngine.ReloadWithoutCache() : false;
 348 }
 349
 350 void WebView::StopLoading()
 351 {
 352   if(mWebEngine)
 353   {
 354     mWebEngine.StopLoading();
 355   }
 356 }
 357
 358 void WebView::Suspend()
 359 {
 360   if(mWebEngine)
 361   {
 362     mWebEngine.Suspend();
 363   }
 364 }
 365
 366 void WebView::Resume()
 367 {
 368   if(mWebEngine)
 369   {
 370     mWebEngine.Resume();
 371   }
 372 }
 373
 374 void WebView::SuspendNetworkLoading()
 375 {
 376   if(mWebEngine)
 377   {
 378     mWebEngine.SuspendNetworkLoading();
 379   }
 380 }
 381
 382 void WebView::ResumeNetworkLoading()
 383 {
 384   if(mWebEngine)
 385   {
 386     mWebEngine.ResumeNetworkLoading();
 387   }
 388 }
 389
 390 bool WebView::AddCustomHeader(const std::string& name, const std::string& value)
 391 {
 392   return mWebEngine ? mWebEngine.AddCustomHeader(name, value) : false;
 393 }
 394
 395 bool WebView::RemoveCustomHeader(const std::string& name)
 396 {
 397   return mWebEngine ? mWebEngine.RemoveCustomHeader(name) : false;
 398 }
 399
 400 uint32_t WebView::StartInspectorServer(uint32_t port)
 401 {
 402   return mWebEngine ? mWebEngine.StartInspectorServer(port) : false;
 403 }
 404
 405 bool WebView::StopInspectorServer()
 406 {
 407   return mWebEngine ? mWebEngine.StopInspectorServer() : false;
 408 }
 409
 410 void WebView::ScrollBy(int32_t deltaX, int32_t deltaY)
 411 {
 412   if(mWebEngine)
 413   {
 414     mWebEngine.ScrollBy(deltaX, deltaY);
 415   }
 416 }
 417
 418 bool WebView::ScrollEdgeBy(int32_t deltaX, int32_t deltaY)
 419 {
 420   return mWebEngine ? mWebEngine.ScrollEdgeBy(deltaX, deltaY) : false;
 421 }
 422
 423 bool WebView::CanGoForward()
 424 {
 425   return mWebEngine ? mWebEngine.CanGoForward() : false;
 426 }
 427
 428 void WebView::GoForward()
 429 {
 430   if(mWebEngine)
 431   {
 432     mWebEngine.GoForward();
 433   }
 434 }
 435
 436 bool WebView::CanGoBack()
 437 {
 438   return mWebEngine ? mWebEngine.CanGoBack() : false;
 439 }
 440
 441 void WebView::GoBack()
 442 {
 443   if(mWebEngine)
 444   {
 445     mWebEngine.GoBack();
 446   }
 447 }
 448
 449 void WebView::EvaluateJavaScript(const std::string& script, std::function<void(const std::string&)> resultHandler)
 450 {
 451   if(mWebEngine)
 452   {
 453     mWebEngine.EvaluateJavaScript(script, resultHandler);
 454   }
 455 }
 456
 457 void WebView::AddJavaScriptMessageHandler(const std::string& exposedObjectName, std::function<void(const std::string&)> handler)
 458 {
 459   if(mWebEngine)
 460   {
 461     mWebEngine.AddJavaScriptMessageHandler(exposedObjectName, handler);
 462   }
 463 }
 464
 465 void WebView::RegisterJavaScriptAlertCallback(Dali::WebEnginePlugin::JavaScriptAlertCallback callback)
 466 {
 467   if(mWebEngine)
 468   {
 469     mWebEngine.RegisterJavaScriptAlertCallback(callback);
 470   }
 471 }
 472
 473 void WebView::JavaScriptAlertReply()
 474 {
 475   if(mWebEngine)
 476   {
 477     mWebEngine.JavaScriptAlertReply();
 478   }
 479 }
 480
 481 void WebView::RegisterJavaScriptConfirmCallback(Dali::WebEnginePlugin::JavaScriptConfirmCallback callback)
 482 {
 483   if(mWebEngine)
 484   {
 485     mWebEngine.RegisterJavaScriptConfirmCallback(callback);
 486   }
 487 }
 488
 489 void WebView::JavaScriptConfirmReply(bool confirmed)
 490 {
 491   if(mWebEngine)
 492   {
 493     mWebEngine.JavaScriptConfirmReply(confirmed);
 494   }
 495 }
 496
 497 void WebView::RegisterJavaScriptPromptCallback(Dali::WebEnginePlugin::JavaScriptPromptCallback callback)
 498 {
 499   if(mWebEngine)
 500   {
 501     mWebEngine.RegisterJavaScriptPromptCallback(callback);
 502   }
 503 }
 504
 505 void WebView::JavaScriptPromptReply(const std::string& result)
 506 {
 507   if(mWebEngine)
 508   {
 509     mWebEngine.JavaScriptPromptReply(result);
 510   }
 511 }
 512
 513 std::unique_ptr<Dali::WebEngineHitTest> WebView::CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
 514 {
 515   std::unique_ptr<Dali::WebEngineHitTest> webHitTest;
 516   if(!mWebEngine)
 517   {
 518     return webHitTest;
 519   }
 520
 521   return mWebEngine.CreateHitTest(x, y, mode);
 522 }
 523
 524 bool WebView::CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback callback)
 525 {
 526   bool result = false;
 527   if(mWebEngine)
 528   {
 529     result = mWebEngine.CreateHitTestAsynchronously(x, y, mode, callback);
 530   }
 531   return result;
 532 }
 533
 534 void WebView::ClearHistory()
 535 {
 536   if(mWebEngine)
 537   {
 538     mWebEngine.ClearHistory();
 539   }
 540 }
 541
 542 void WebView::ClearAllTilesResources()
 543 {
 544   if(mWebEngine)
 545   {
 546     mWebEngine.ClearAllTilesResources();
 547   }
 548 }
 549
 550 void WebView::SetScaleFactor(float scaleFactor, Dali::Vector2 point)
 551 {
 552   if(mWebEngine)
 553   {
 554     mWebEngine.SetScaleFactor(scaleFactor, point);
 555   }
 556 }
 557
 558 float WebView::GetScaleFactor() const
 559 {
 560   return mWebEngine ? mWebEngine.GetScaleFactor() : 0.0f;
 561 }
 562
 563 void WebView::ActivateAccessibility(bool activated)
 564 {
 565   if(mWebEngine)
 566   {
 567     mWebEngine.ActivateAccessibility(activated);
 568   }
 569 }
 570
 571 bool WebView::HighlightText(const std::string& text, Dali::WebEnginePlugin::FindOption options, uint32_t maxMatchCount)
 572 {
 573   return mWebEngine ? mWebEngine.HighlightText(text, options, maxMatchCount) : false;
 574 }
 575
 576 void WebView::AddDynamicCertificatePath(const std::string& host, const std::string& certPath)
 577 {
 578   if(mWebEngine)
 579   {
 580     mWebEngine.AddDynamicCertificatePath(host, certPath);
 581   }
 582 }
 583
 584 Dali::Toolkit::ImageView WebView::GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
 585 {
 586   Dali::Toolkit::ImageView imageView;
 587   if(mWebEngine)
 588   {
 589     Dali::PixelData pixelData = mWebEngine.GetScreenshot(viewArea, scaleFactor);
 590     imageView                 = CreateImageView(pixelData);
 591   }
 592   return imageView;
 593 }
 594
 595 bool WebView::GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, Dali::Toolkit::WebView::WebViewScreenshotCapturedCallback callback)
 596 {
 597   mScreenshotCapturedCallback = callback;
 598   return mWebEngine ? mWebEngine.GetScreenshotAsynchronously(viewArea, scaleFactor, std::bind(&WebView::OnScreenshotCaptured, this, std::placeholders::_1)) : false;
 599 }
 600
 601 bool WebView::CheckVideoPlayingAsynchronously(Dali::WebEnginePlugin::VideoPlayingCallback callback)
 602 {
 603   return mWebEngine ? mWebEngine.CheckVideoPlayingAsynchronously(callback) : false;
 604 }
 605
 606 void WebView::RegisterGeolocationPermissionCallback(Dali::WebEnginePlugin::GeolocationPermissionCallback callback)
 607 {
 608   if(mWebEngine)
 609   {
 610     mWebEngine.RegisterGeolocationPermissionCallback(callback);
 611   }
 612 }
 613
 614 void WebView::UpdateDisplayArea(Dali::PropertyNotification& /*source*/)
 615 {
 616   if(!mWebEngine)
 617     return;
 618
 619   Actor self(Self());
 620
 621   bool    positionUsesAnchorPoint = self.GetProperty<bool>(Actor::Property::POSITION_USES_ANCHOR_POINT);
 622   Vector3 actorSize               = self.GetCurrentProperty<Vector3>(Actor::Property::SIZE) * self.GetCurrentProperty<Vector3>(Actor::Property::SCALE);
 623   Vector3 anchorPointOffSet       = actorSize * (positionUsesAnchorPoint ? self.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT) : AnchorPoint::TOP_LEFT);
 624   Vector2 screenPosition          = self.GetProperty<Vector2>(Actor::Property::SCREEN_POSITION);
 625
 626   Dali::Rect<int32_t> displayArea;
 627   displayArea.x      = screenPosition.x - anchorPointOffSet.x;
 628   displayArea.y      = screenPosition.y - anchorPointOffSet.y;
 629   displayArea.width  = actorSize.x;
 630   displayArea.height = actorSize.y;
 631
 632   Size displaySize = Size(displayArea.width, displayArea.height);
 633   if(mWebViewSize != displaySize)
 634   {
 635     mWebViewSize = displaySize;
 636   }
 637
 638   if(mWebViewArea != displayArea)
 639   {
 640     mWebViewArea = displayArea;
 641     mWebEngine.UpdateDisplayArea(mWebViewArea);
 642   }
 643 }
 644
 645 void WebView::EnableVideoHole(bool enabled)
 646 {
 647   mVideoHoleEnabled = enabled;
 648
 649   EnableBlendMode(!mVideoHoleEnabled);
 650
 651   if(mWebEngine)
 652   {
 653     mWebEngine.EnableVideoHole(mVideoHoleEnabled);
 654   }
 655 }
 656
 657 void WebView::EnableBlendMode(bool blendEnabled)
 658 {
 659   Actor self = Self();
 660   for(uint32_t i = 0; i < self.GetRendererCount(); i++)
 661   {
 662     Dali::Renderer render = self.GetRendererAt(i);
 663     render.SetProperty(Renderer::Property::BLEND_MODE, blendEnabled ? BlendMode::ON : BlendMode::OFF);
 664   }
 665 }
 666
 667 Dali::Toolkit::ImageView WebView::CreateImageView(Dali::PixelData pixel) const
 668 {
 669   if(!pixel)
 670   {
 671     return Dali::Toolkit::ImageView();
 672   }
 673
 674   std::string              url       = Dali::Toolkit::Image::GenerateUrl(pixel);
 675   Dali::Toolkit::ImageView imageView = Dali::Toolkit::ImageView::New(url);
 676   imageView.SetProperty(Dali::Actor::Property::SIZE, Vector2(pixel.GetWidth(), pixel.GetHeight()));
 677   return imageView;
 678 }
 679
 680 Dali::Toolkit::WebView::WebViewPageLoadSignalType& WebView::PageLoadStartedSignal()
 681 {
 682   return mPageLoadStartedSignal;
 683 }
 684
 685 Dali::Toolkit::WebView::WebViewPageLoadSignalType& WebView::PageLoadInProgressSignal()
 686 {
 687   return mPageLoadInProgressSignal;
 688 }
 689
 690 Dali::Toolkit::WebView::WebViewPageLoadSignalType& WebView::PageLoadFinishedSignal()
 691 {
 692   return mPageLoadFinishedSignal;
 693 }
 694
 695 Dali::Toolkit::WebView::WebViewPageLoadErrorSignalType& WebView::PageLoadErrorSignal()
 696 {
 697   return mPageLoadErrorSignal;
 698 }
 699
 700 Dali::Toolkit::WebView::WebViewScrollEdgeReachedSignalType& WebView::ScrollEdgeReachedSignal()
 701 {
 702   return mScrollEdgeReachedSignal;
 703 }
 704
 705 Dali::Toolkit::WebView::WebViewUrlChangedSignalType& WebView::UrlChangedSignal()
 706 {
 707   return mUrlChangedSignal;
 708 }
 709
 710 Dali::Toolkit::WebView::WebViewFormRepostDecisionSignalType& WebView::FormRepostDecisionSignal()
 711 {
 712   return mFormRepostDecisionSignal;
 713 }
 714
 715 Dali::Toolkit::WebView::WebViewFrameRenderedSignalType& WebView::FrameRenderedSignal()
 716 {
 717   return mFrameRenderedSignal;
 718 }
 719
 720 Dali::Toolkit::WebView::WebViewRequestInterceptorSignalType& WebView::RequestInterceptorSignal()
 721 {
 722   return mRequestInterceptorSignal;
 723 }
 724
 725 Dali::Toolkit::WebView::WebViewConsoleMessageSignalType& WebView::ConsoleMessageSignal()
 726 {
 727   return mConsoleMessageSignal;
 728 }
 729
 730 Dali::Toolkit::WebView::WebViewResponsePolicyDecisionSignalType& WebView::ResponsePolicyDecisionSignal()
 731 {
 732   return mResponsePolicyDecisionSignal;
 733 }
 734
 735 Dali::Toolkit::WebView::WebViewCertificateSignalType& WebView::CertificateConfirmSignal()
 736 {
 737   return mCertificateConfirmSignal;
 738 }
 739
 740 Dali::Toolkit::WebView::WebViewCertificateSignalType& WebView::SslCertificateChangedSignal()
 741 {
 742   return mSslCertificateChangedSignal;
 743 }
 744
 745 Dali::Toolkit::WebView::WebViewHttpAuthHandlerSignalType& WebView::HttpAuthHandlerSignal()
 746 {
 747   return mHttpAuthHandlerSignal;
 748 }
 749
 750 Dali::Toolkit::WebView::WebViewContextMenuCustomizedSignalType& WebView::ContextMenuCustomizedSignal()
 751 {
 752   return mContextMenuCustomizedSignal;
 753 }
 754
 755 Dali::Toolkit::WebView::WebViewContextMenuItemSelectedSignalType& WebView::ContextMenuItemSelectedSignal()
 756 {
 757   return mContextMenuItemSelectedSignal;
 758 }
 759
 760 void WebView::OnPageLoadStarted(const std::string& url)
 761 {
 762   if(!mPageLoadStartedSignal.Empty())
 763   {
 764     Dali::Toolkit::WebView handle(GetOwner());
 765     mPageLoadStartedSignal.Emit(handle, url);
 766   }
 767 }
 768
 769 void WebView::OnPageLoadInProgress(const std::string& url)
 770 {
 771   if(!mPageLoadInProgressSignal.Empty())
 772   {
 773     Dali::Toolkit::WebView handle(GetOwner());
 774     mPageLoadInProgressSignal.Emit(handle, url);
 775   }
 776 }
 777
 778 void WebView::OnPageLoadFinished(const std::string& url)
 779 {
 780   if(!mPageLoadFinishedSignal.Empty())
 781   {
 782     Dali::Toolkit::WebView handle(GetOwner());
 783     mPageLoadFinishedSignal.Emit(handle, url);
 784   }
 785 }
 786
 787 void WebView::OnPageLoadError(std::shared_ptr<Dali::WebEngineLoadError> error)
 788 {
 789   if(!mPageLoadErrorSignal.Empty())
 790   {
 791     Dali::Toolkit::WebView handle(GetOwner());
 792     mPageLoadErrorSignal.Emit(handle, std::move(error));
 793   }
 794 }
 795
 796 void WebView::OnScrollEdgeReached(Dali::WebEnginePlugin::ScrollEdge edge)
 797 {
 798   if(!mScrollEdgeReachedSignal.Empty())
 799   {
 800     Dali::Toolkit::WebView handle(GetOwner());
 801     mScrollEdgeReachedSignal.Emit(handle, edge);
 802   }
 803 }
 804
 805 void WebView::OnUrlChanged(const std::string& url)
 806 {
 807   if(!mUrlChangedSignal.Empty())
 808   {
 809     Dali::Toolkit::WebView handle(GetOwner());
 810     mUrlChangedSignal.Emit(handle, url);
 811   }
 812 }
 813
 814 void WebView::OnFormRepostDecision(std::shared_ptr<Dali::WebEngineFormRepostDecision> decision)
 815 {
 816   if(!mFormRepostDecisionSignal.Empty())
 817   {
 818     Dali::Toolkit::WebView handle(GetOwner());
 819     mFormRepostDecisionSignal.Emit(handle, std::move(decision));
 820   }
 821 }
 822
 823 void WebView::OnFrameRendered()
 824 {
 825   if(!mFrameRenderedSignal.Empty())
 826   {
 827     Dali::Toolkit::WebView handle(GetOwner());
 828     mFrameRenderedSignal.Emit(handle);
 829   }
 830 }
 831
 832 void WebView::OnInitialFrameRendered()
 833 {
 834   mWebEngine.FrameRenderedSignal().Disconnect(this, &WebView::OnInitialFrameRendered);
 835
 836   Texture           texture        = Dali::Texture::New(*mWebEngine.GetNativeImageSource());
 837   const std::string nativeImageUrl = Dali::Toolkit::TextureManager::AddTexture(texture);
 838   mVisual                          = Toolkit::VisualFactory::Get().CreateVisual({{Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE}, {Toolkit::ImageVisual::Property::URL, nativeImageUrl}});
 839
 840   if(mVisual)
 841   {
 842     DevelControl::RegisterVisual(*this, Toolkit::WebView::Property::URL, mVisual);
 843     EnableBlendMode(!mVideoHoleEnabled);
 844   }
 845 }
 846
 847 void WebView::OnVisibilityChanged(Actor actor, bool isVisible, Dali::DevelActor::VisibilityChange::Type type)
 848 {
 849   if(type == Dali::DevelActor::VisibilityChange::Type::SELF)
 850   {
 851     SetVisibility(isVisible);
 852   }
 853 }
 854
 855 void WebView::OnScreenshotCaptured(Dali::PixelData pixel)
 856 {
 857   if(mScreenshotCapturedCallback)
 858   {
 859     Dali::Toolkit::ImageView imageView = CreateImageView(pixel);
 860     mScreenshotCapturedCallback(imageView);
 861   }
 862 }
 863
 864 void WebView::OnInterceptRequest(std::shared_ptr<Dali::WebEngineRequestInterceptor> interceptor)
 865 {
 866   if(!mRequestInterceptorSignal.Empty())
 867   {
 868     Dali::Toolkit::WebView handle(GetOwner());
 869     mRequestInterceptorSignal.Emit(handle, std::move(interceptor));
 870   }
 871 }
 872
 873 void WebView::OnConsoleMessage(std::shared_ptr<Dali::WebEngineConsoleMessage> message)
 874 {
 875   if(!mConsoleMessageSignal.Empty())
 876   {
 877     Dali::Toolkit::WebView handle(GetOwner());
 878     mConsoleMessageSignal.Emit(handle, std::move(message));
 879   }
 880 }
 881
 882 void WebView::OnResponsePolicyDecided(std::shared_ptr<Dali::WebEnginePolicyDecision> decision)
 883 {
 884   if(!mResponsePolicyDecisionSignal.Empty())
 885   {
 886     Dali::Toolkit::WebView handle(GetOwner());
 887     mResponsePolicyDecisionSignal.Emit(handle, std::move(decision));
 888   }
 889 }
 890
 891 void WebView::OnCertificateConfirm(std::shared_ptr<Dali::WebEngineCertificate> certificate)
 892 {
 893   if(!mCertificateConfirmSignal.Empty())
 894   {
 895     Dali::Toolkit::WebView handle(GetOwner());
 896     mCertificateConfirmSignal.Emit(handle, std::move(certificate));
 897   }
 898 }
 899
 900 void WebView::OnSslCertificateChanged(std::shared_ptr<Dali::WebEngineCertificate> certificate)
 901 {
 902   if(!mSslCertificateChangedSignal.Empty())
 903   {
 904     Dali::Toolkit::WebView handle(GetOwner());
 905     mSslCertificateChangedSignal.Emit(handle, std::move(certificate));
 906   }
 907 }
 908
 909 void WebView::OnHttpAuthenticationRequest(std::shared_ptr<Dali::WebEngineHttpAuthHandler> handler)
 910 {
 911   if(!mHttpAuthHandlerSignal.Empty())
 912   {
 913     Dali::Toolkit::WebView handle(GetOwner());
 914     mHttpAuthHandlerSignal.Emit(handle, std::move(handler));
 915   }
 916 }
 917
 918 void WebView::OnContextMenuCustomized(std::shared_ptr<Dali::WebEngineContextMenu> menu)
 919 {
 920   if(!mContextMenuCustomizedSignal.Empty())
 921   {
 922     Dali::Toolkit::WebView handle(GetOwner());
 923     mContextMenuCustomizedSignal.Emit(handle, std::move(menu));
 924   }
 925 }
 926
 927 void WebView::OnContextMenuItemSelected(std::shared_ptr<Dali::WebEngineContextMenuItem> item)
 928 {
 929   if(!mContextMenuItemSelectedSignal.Empty())
 930   {
 931     Dali::Toolkit::WebView handle(GetOwner());
 932     mContextMenuItemSelectedSignal.Emit(handle, std::move(item));
 933   }
 934 }
 935
 936 bool WebView::DoConnectSignal(BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor)
 937 {
 938   Dali::BaseHandle handle(object);
 939
 940   bool             connected = false;
 941   Toolkit::WebView webView   = Toolkit::WebView::DownCast(handle);
 942
 943   if(0 == strcmp(signalName.c_str(), PAGE_LOAD_STARTED_SIGNAL))
 944   {
 945     webView.PageLoadStartedSignal().Connect(tracker, functor);
 946     connected = true;
 947   }
 948   else if(0 == strcmp(signalName.c_str(), PAGE_LOAD_IN_PROGRESS_SIGNAL))
 949   {
 950     webView.PageLoadInProgressSignal().Connect(tracker, functor);
 951     connected = true;
 952   }
 953   else if(0 == strcmp(signalName.c_str(), PAGE_LOAD_FINISHED_SIGNAL))
 954   {
 955     webView.PageLoadFinishedSignal().Connect(tracker, functor);
 956     connected = true;
 957   }
 958   else if(0 == strcmp(signalName.c_str(), PAGE_LOAD_ERROR_SIGNAL))
 959   {
 960     webView.PageLoadErrorSignal().Connect(tracker, functor);
 961     connected = true;
 962   }
 963   else if(0 == strcmp(signalName.c_str(), SCROLL_EDGE_REACHED_SIGNAL))
 964   {
 965     webView.ScrollEdgeReachedSignal().Connect(tracker, functor);
 966     connected = true;
 967   }
 968   else if(0 == strcmp(signalName.c_str(), URL_CHANGED_SIGNAL))
 969   {
 970     webView.UrlChangedSignal().Connect(tracker, functor);
 971     connected = true;
 972   }
 973   else if(0 == strcmp(signalName.c_str(), FORM_REPOST_DECISION_SIGNAL))
 974   {
 975     webView.FormRepostDecisionSignal().Connect(tracker, functor);
 976     connected = true;
 977   }
 978   else if(0 == strcmp(signalName.c_str(), FRAME_RENDERED_SIGNAL))
 979   {
 980     webView.FrameRenderedSignal().Connect(tracker, functor);
 981     connected = true;
 982   }
 983   else if(0 == strcmp(signalName.c_str(), REQUEST_INTERCEPTOR_SIGNAL))
 984   {
 985     webView.RequestInterceptorSignal().Connect(tracker, functor);
 986     connected = true;
 987   }
 988   else if(0 == strcmp(signalName.c_str(), CONSOLE_MESSAGE_SIGNAL))
 989   {
 990     webView.ConsoleMessageSignal().Connect(tracker, functor);
 991     connected = true;
 992   }
 993   else if(0 == strcmp(signalName.c_str(), POLICY_DECISION))
 994   {
 995     webView.ResponsePolicyDecisionSignal().Connect(tracker, functor);
 996     connected = true;
 997   }
 998   else if(0 == strcmp(signalName.c_str(), CERTIFICATE_CONFIRM_SIGNAL))
 999   {
1000     webView.CertificateConfirmSignal().Connect(tracker, functor);
1001     connected = true;
1002   }
1003   else if(0 == strcmp(signalName.c_str(), SSL_CERTIFICATE_CHANGED_SIGNAL))
1004   {
1005     webView.SslCertificateChangedSignal().Connect(tracker, functor);
1006     connected = true;
1007   }
1008   else if(0 == strcmp(signalName.c_str(), HTTP_AUTH_REQUEST_SIGNAL))
1009   {
1010     webView.HttpAuthHandlerSignal().Connect(tracker, functor);
1011     connected = true;
1012   }
1013   else if(0 == strcmp(signalName.c_str(), CONTEXT_MENU_CUSTOMIZED_SIGNAL))
1014   {
1015     webView.ContextMenuCustomizedSignal().Connect(tracker, functor);
1016     connected = true;
1017   }
1018   else if(0 == strcmp(signalName.c_str(), CONTEXT_MENU_ITEM_SELECTED_SIGNAL))
1019   {
1020     webView.ContextMenuItemSelectedSignal().Connect(tracker, functor);
1021     connected = true;
1022   }
1023
1024   return connected;
1025 }
1026
1027 Vector3 WebView::GetNaturalSize()
1028 {
1029   if(mVisual)
1030   {
1031     Vector2 rendererNaturalSize;
1032     mVisual.GetNaturalSize(rendererNaturalSize);
1033     return Vector3(rendererNaturalSize);
1034   }
1035
1036   return Vector3(mWebViewSize);
1037 }
1038
1039 void WebView::OnSceneConnection(int depth)
1040 {
1041   Control::OnSceneConnection(depth);
1042
1043   EnableBlendMode(!mVideoHoleEnabled);
1044 }
1045
1046 void WebView::SetProperty(BaseObject* object, Property::Index index, const Property::Value& value)
1047 {
1048   Toolkit::WebView webView = Toolkit::WebView::DownCast(Dali::BaseHandle(object));
1049
1050   if(webView)
1051   {
1052     WebView& impl = GetImpl(webView);
1053     switch(index)
1054     {
1055       case Toolkit::WebView::Property::URL:
1056       {
1057         std::string url;
1058         if(value.Get(url))
1059         {
1060           impl.LoadUrl(url);
1061         }
1062         break;
1063       }
1064       case Toolkit::WebView::Property::USER_AGENT:
1065       {
1066         std::string input;
1067         if(value.Get(input))
1068         {
1069           impl.SetUserAgent(input);
1070         }
1071         break;
1072       }
1073       case Toolkit::WebView::Property::SCROLL_POSITION:
1074       {
1075         Vector2 input;
1076         if(value.Get(input))
1077         {
1078           impl.SetScrollPosition(input.x, input.y);
1079         }
1080         break;
1081       }
1082       case Toolkit::WebView::Property::VIDEO_HOLE_ENABLED:
1083       {
1084         bool input;
1085         if(value.Get(input))
1086         {
1087           impl.EnableVideoHole(input);
1088         }
1089         break;
1090       }
1091       case Toolkit::WebView::Property::MOUSE_EVENTS_ENABLED:
1092       {
1093         bool input;
1094         if(value.Get(input))
1095         {
1096           impl.EnableMouseEvents(input);
1097         }
1098         break;
1099       }
1100       case Toolkit::WebView::Property::KEY_EVENTS_ENABLED:
1101       {
1102         bool input;
1103         if(value.Get(input))
1104         {
1105           impl.EnableKeyEvents(input);
1106         }
1107         break;
1108       }
1109       case Toolkit::WebView::Property::DOCUMENT_BACKGROUND_COLOR:
1110       {
1111         Vector4 input;
1112         if(value.Get(input))
1113         {
1114           impl.SetDocumentBackgroundColor(input);
1115         }
1116         break;
1117       }
1118       case Toolkit::WebView::Property::TILES_CLEARED_WHEN_HIDDEN:
1119       {
1120         bool input;
1121         if(value.Get(input))
1122         {
1123           impl.ClearTilesWhenHidden(input);
1124         }
1125         break;
1126       }
1127       case Toolkit::WebView::Property::TILE_COVER_AREA_MULTIPLIER:
1128       {
1129         float input;
1130         if(value.Get(input))
1131         {
1132           impl.SetTileCoverAreaMultiplier(input);
1133         }
1134         break;
1135       }
1136       case Toolkit::WebView::Property::CURSOR_ENABLED_BY_CLIENT:
1137       {
1138         bool input;
1139         if(value.Get(input))
1140         {
1141           impl.EnableCursorByClient(input);
1142         }
1143         break;
1144       }
1145       case Toolkit::WebView::Property::PAGE_ZOOM_FACTOR:
1146       {
1147         float input;
1148         if(value.Get(input))
1149         {
1150           impl.SetPageZoomFactor(input);
1151         }
1152         break;
1153       }
1154       case Toolkit::WebView::Property::TEXT_ZOOM_FACTOR:
1155       {
1156         float input;
1157         if(value.Get(input))
1158         {
1159           impl.SetTextZoomFactor(input);
1160         }
1161         break;
1162       }
1163       default:
1164         break;
1165     }
1166   }
1167 }
1168
1169 Property::Value WebView::GetProperty(BaseObject* object, Property::Index propertyIndex)
1170 {
1171   Property::Value value;
1172
1173   Toolkit::WebView webView = Toolkit::WebView::DownCast(Dali::BaseHandle(object));
1174
1175   if(webView)
1176   {
1177     WebView& impl = GetImpl(webView);
1178     switch(propertyIndex)
1179     {
1180       case Toolkit::WebView::Property::URL:
1181       {
1182         value = impl.mUrl;
1183         break;
1184       }
1185       case Toolkit::WebView::Property::USER_AGENT:
1186       {
1187         value = impl.GetUserAgent();
1188         break;
1189       }
1190       case Toolkit::WebView::Property::SCROLL_POSITION:
1191       {
1192         value = impl.GetScrollPosition();
1193         break;
1194       }
1195       case Toolkit::WebView::Property::SCROLL_SIZE:
1196       {
1197         value = impl.GetScrollSize();
1198         break;
1199       }
1200       case Toolkit::WebView::Property::CONTENT_SIZE:
1201       {
1202         value = impl.GetContentSize();
1203         break;
1204       }
1205       case Toolkit::WebView::Property::TITLE:
1206       {
1207         value = impl.GetTitle();
1208         break;
1209       }
1210       case Toolkit::WebView::Property::VIDEO_HOLE_ENABLED:
1211       {
1212         value = impl.mVideoHoleEnabled;
1213         break;
1214       }
1215       case Toolkit::WebView::Property::MOUSE_EVENTS_ENABLED:
1216       {
1217         value = impl.mMouseEventsEnabled;
1218         break;
1219       }
1220       case Toolkit::WebView::Property::KEY_EVENTS_ENABLED:
1221       {
1222         value = impl.mKeyEventsEnabled;
1223         break;
1224       }
1225       case Toolkit::WebView::Property::SELECTED_TEXT:
1226       {
1227         value = impl.GetSelectedText();
1228         break;
1229       }
1230       case Toolkit::WebView::Property::PAGE_ZOOM_FACTOR:
1231       {
1232         value = impl.GetPageZoomFactor();
1233         break;
1234       }
1235       case Toolkit::WebView::Property::TEXT_ZOOM_FACTOR:
1236       {
1237         value = impl.GetTextZoomFactor();
1238         break;
1239       }
1240       case Toolkit::WebView::Property::LOAD_PROGRESS_PERCENTAGE:
1241       {
1242         value = impl.GetLoadProgressPercentage();
1243         break;
1244       }
1245       default:
1246         break;
1247     }
1248   }
1249
1250   return value;
1251 }
1252
1253 bool WebView::OnTouchEvent(Actor actor, const Dali::TouchEvent& touch)
1254 {
1255   bool result = false;
1256
1257   if(mWebEngine)
1258   {
1259     result = mWebEngine.SendTouchEvent(touch);
1260   }
1261   return result;
1262 }
1263
1264 bool WebView::OnKeyEvent(const Dali::KeyEvent& event)
1265 {
1266   bool result = false;
1267
1268   if(mWebEngine)
1269   {
1270     result = mWebEngine.SendKeyEvent(event);
1271   }
1272   return result;
1273 }
1274
1275 bool WebView::OnHoverEvent(Actor actor, const Dali::HoverEvent& hover)
1276 {
1277   bool result = false;
1278   if(mWebEngine && mMouseEventsEnabled)
1279   {
1280     result = mWebEngine.SendHoverEvent(hover);
1281   }
1282   return result;
1283 }
1284
1285 bool WebView::OnWheelEvent(Actor actor, const Dali::WheelEvent& wheel)
1286 {
1287   bool result = false;
1288   if(mWebEngine && mMouseEventsEnabled)
1289   {
1290     result = mWebEngine.SendWheelEvent(wheel);
1291   }
1292   return result;
1293 }
1294
1295 void WebView::OnKeyInputFocusGained()
1296 {
1297   if(mWebEngine)
1298   {
1299     mWebEngine.SetFocus(true);
1300   }
1301
1302   EmitKeyInputFocusSignal(true); // Calls back into the Control hence done last.
1303 }
1304
1305 void WebView::OnKeyInputFocusLost()
1306 {
1307   if(mWebEngine)
1308   {
1309     mWebEngine.SetFocus(false);
1310   }
1311
1312   EmitKeyInputFocusSignal(false); // Calls back into the Control hence done last.
1313 }
1314
1315 void WebView::SetScrollPosition(int32_t x, int32_t y)
1316 {
1317   if(mWebEngine)
1318   {
1319     mWebEngine.SetScrollPosition(x, y);
1320   }
1321 }
1322
1323 Dali::Vector2 WebView::GetScrollPosition() const
1324 {
1325   return mWebEngine ? mWebEngine.GetScrollPosition() : Dali::Vector2::ZERO;
1326 }
1327
1328 Dali::Vector2 WebView::GetScrollSize() const
1329 {
1330   return mWebEngine ? mWebEngine.GetScrollSize() : Dali::Vector2::ZERO;
1331 }
1332
1333 Dali::Vector2 WebView::GetContentSize() const
1334 {
1335   return mWebEngine ? mWebEngine.GetContentSize() : Dali::Vector2::ZERO;
1336 }
1337
1338 std::string WebView::GetTitle() const
1339 {
1340   return mWebEngine ? mWebEngine.GetTitle() : kEmptyString;
1341 }
1342
1343 void WebView::SetDocumentBackgroundColor(Dali::Vector4 color)
1344 {
1345   if(mWebEngine)
1346   {
1347     mWebEngine.SetDocumentBackgroundColor(color);
1348   }
1349 }
1350
1351 void WebView::ClearTilesWhenHidden(bool cleared)
1352 {
1353   if(mWebEngine)
1354   {
1355     mWebEngine.ClearTilesWhenHidden(cleared);
1356   }
1357 }
1358
1359 void WebView::SetTileCoverAreaMultiplier(float multiplier)
1360 {
1361   if(mWebEngine)
1362   {
1363     mWebEngine.SetTileCoverAreaMultiplier(multiplier);
1364   }
1365 }
1366
1367 void WebView::EnableCursorByClient(bool enabled)
1368 {
1369   if(mWebEngine)
1370   {
1371     mWebEngine.EnableCursorByClient(enabled);
1372   }
1373 }
1374
1375 std::string WebView::GetSelectedText() const
1376 {
1377   return mWebEngine ? mWebEngine.GetSelectedText() : kEmptyString;
1378 }
1379
1380 const std::string& WebView::GetUserAgent() const
1381 {
1382   return mWebEngine ? mWebEngine.GetUserAgent() : kEmptyString;
1383 }
1384
1385 void WebView::SetUserAgent(const std::string& userAgent)
1386 {
1387   if(mWebEngine)
1388   {
1389     mWebEngine.SetUserAgent(userAgent);
1390   }
1391 }
1392
1393 void WebView::EnableMouseEvents(bool enabled)
1394 {
1395   if(mWebEngine)
1396   {
1397     mMouseEventsEnabled = enabled;
1398     mWebEngine.EnableMouseEvents(enabled);
1399   }
1400 }
1401
1402 void WebView::EnableKeyEvents(bool enabled)
1403 {
1404   if(mWebEngine)
1405   {
1406     mKeyEventsEnabled = enabled;
1407     mWebEngine.EnableKeyEvents(enabled);
1408   }
1409 }
1410
1411 void WebView::SetPageZoomFactor(float zoomFactor)
1412 {
1413   if(mWebEngine)
1414   {
1415     mWebEngine.SetPageZoomFactor(zoomFactor);
1416   }
1417 }
1418
1419 float WebView::GetPageZoomFactor() const
1420 {
1421   return mWebEngine ? mWebEngine.GetPageZoomFactor() : 0.0f;
1422 }
1423
1424 void WebView::SetTextZoomFactor(float zoomFactor)
1425 {
1426   if(mWebEngine)
1427   {
1428     mWebEngine.SetTextZoomFactor(zoomFactor);
1429   }
1430 }
1431
1432 float WebView::GetTextZoomFactor() const
1433 {
1434   return mWebEngine ? mWebEngine.GetTextZoomFactor() : 0.0f;
1435 }
1436
1437 float WebView::GetLoadProgressPercentage() const
1438 {
1439   return mWebEngine ? mWebEngine.GetLoadProgressPercentage() : 0.0f;
1440 }
1441
1442 bool WebView::SetVisibility(bool visible)
1443 {
1444   return mWebEngine ? mWebEngine.SetVisibility(visible) : false;
1445 }
1446
1447 #undef GET_ENUM_STRING
1448 #undef GET_ENUM_VALUE
1449
1450 } // namespace Internal
1451
1452 } // namespace Toolkit
1453
1454 } // namespace Dali