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