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