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