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