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