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

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