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