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

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