dali/devel-api/adaptor-framework/web-engine/web-engine-plugin.h

   1 #ifndef DALI_WEB_ENGINE_PLUGIN_H
   2 #define DALI_WEB_ENGINE_PLUGIN_H
   3
   4 /*
   5  * Copyright (c) 2024 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/public-api/images/native-image-interface.h>
  23 #include <dali/public-api/math/rect.h>
  24 #include <functional>
  25 #include <memory>
  26
  27 // INTERNAL INCLUDES
  28 #include <dali/devel-api/adaptor-framework/accessibility.h>
  29 #include <dali/devel-api/adaptor-framework/web-engine/web-engine-hit-test.h>
  30 #include <dali/devel-api/common/bitwise-enum.h>
  31 #include <dali/public-api/adaptor-framework/native-image-source.h>
  32
  33 namespace Dali
  34 {
  35 class KeyEvent;
  36 class PixelData;
  37 class TouchEvent;
  38 class WebEngineBackForwardList;
  39 class WebEngineCertificate;
  40 class WebEngineConsoleMessage;
  41 class WebEngineContextMenu;
  42 class WebEngineFormRepostDecision;
  43 class WebEngineHitTest;
  44 class WebEngineHttpAuthHandler;
  45 class WebEngineLoadError;
  46 class WebEnginePolicyDecision;
  47 class WebEngineSettings;
  48 class HoverEvent;
  49 class WheelEvent;
  50
  51 /**
  52  * @brief WebEnginePlugin is an abstract interface, used by dali-adaptor to access WebEngine plugin.
  53  * A concrete implementation must be created for each platform and provided as dynamic library.
  54  */
  55 class WebEnginePlugin
  56 {
  57 public:
  58   /**
  59    * @brief WebEngine callback related with page loading.
  60    */
  61   using WebEnginePageLoadCallback = std::function<void(const std::string&)>;
  62
  63   /**
  64    * @brief WebView callback related with page loading error.
  65    */
  66   using WebEnginePageLoadErrorCallback = std::function<void(std::unique_ptr<Dali::WebEngineLoadError>)>;
  67
  68   // forward declaration.
  69   enum class ScrollEdge;
  70
  71   /**
  72    * @brief WebView callback related with scroll edge reached.
  73    */
  74   using WebEngineScrollEdgeReachedCallback = std::function<void(const ScrollEdge)>;
  75
  76   /**
  77    * @brief WebView callback related with page url changed.
  78    */
  79   using WebEngineUrlChangedCallback = std::function<void(const std::string&)>;
  80
  81   /**
  82    * @brief WebView callback related with screen captured.
  83    */
  84   using ScreenshotCapturedCallback = std::function<void(Dali::PixelData)>;
  85
  86   /**
  87    * @brief WebView callback related with geolocation permission.
  88    *  Host and protocol of security origin will be provided when requesting
  89    *  geolocation permission.
  90    *  It returns true if a pop-up is created successfully, false otherwise.
  91    */
  92   using GeolocationPermissionCallback = std::function<bool(const std::string&, const std::string&)>;
  93
  94   /**
  95    * @brief WebView callback related with video playing.
  96    */
  97   using VideoPlayingCallback = std::function<void(bool)>;
  98
  99   /**
 100    * @brief WebView callback related with console message logged.
 101    */
 102   using WebEngineConsoleMessageReceivedCallback = std::function<void(std::unique_ptr<Dali::WebEngineConsoleMessage>)>;
 103
 104   /**
 105    * @brief WebView callback related with certificate changed.
 106    */
 107   using WebEngineCertificateCallback = std::function<void(std::unique_ptr<Dali::WebEngineCertificate>)>;
 108
 109   /**
 110    * @brief WebView callback related with http authentication.
 111    */
 112   using WebEngineHttpAuthHandlerCallback = std::function<void(std::unique_ptr<Dali::WebEngineHttpAuthHandler>)>;
 113
 114   /**
 115    * @brief WebView callback related with context menu shown.
 116    */
 117   using WebEngineContextMenuShownCallback = std::function<void(std::unique_ptr<Dali::WebEngineContextMenu>)>;
 118
 119   /**
 120    * @brief WebView callback related with context menu hidden.
 121    */
 122   using WebEngineContextMenuHiddenCallback = std::function<void(std::unique_ptr<Dali::WebEngineContextMenu>)>;
 123
 124   /**
 125    * @brief Message result callback when JavaScript is executed with a message.
 126    */
 127   using JavaScriptMessageHandlerCallback = std::function<void(const std::string&)>;
 128
 129   /**
 130    * @brief Alert callback when JavaScript alert is called with a message.
 131    *  It returns true if a pop-up is created successfully, false otherwise.
 132    */
 133   using JavaScriptAlertCallback = std::function<bool(const std::string&)>;
 134
 135   /**
 136    * @brief Confirm callback when JavaScript confirm is called with a message.
 137    *  It returns true if a pop-up is created successfully, false otherwise.
 138    */
 139   using JavaScriptConfirmCallback = std::function<bool(const std::string&)>;
 140
 141   /**
 142    * @brief Prompt callback when JavaScript prompt is called with a message
 143    *  and an optional value that is the default value for the input field.
 144    *  It returns true if a pop-up is created successfully, false otherwise.
 145    */
 146   using JavaScriptPromptCallback = std::function<bool(const std::string&, const std::string&)>;
 147
 148   /**
 149    * @brief WebView callback related with form repost decision.
 150    */
 151   using WebEngineFormRepostDecidedCallback = std::function<void(std::unique_ptr<Dali::WebEngineFormRepostDecision>)>;
 152
 153   /**
 154    * @brief WebView callback related with frame rendered.
 155    */
 156   using WebEngineFrameRenderedCallback = std::function<void(void)>;
 157
 158   /**
 159    * @brief WebView callback related with response policy would be decided.
 160    */
 161   using WebEngineResponsePolicyDecidedCallback = std::function<void(std::unique_ptr<Dali::WebEnginePolicyDecision>)>;
 162
 163   /**
 164    * @brief WebView callback related with navigation policy would be decided.
 165    */
 166   using WebEngineNavigationPolicyDecidedCallback = std::function<void(std::unique_ptr<Dali::WebEnginePolicyDecision>)>;
 167
 168   /**
 169    * @brief WebView callback related with new window policy would be decided.
 170    */
 171   using WebEngineNewWindowPolicyDecidedCallback = std::function<void(std::unique_ptr<Dali::WebEnginePolicyDecision>)>;
 172
 173   /**
 174    * @brief WebView callback related with a new window would be created.
 175    */
 176   using WebEngineNewWindowCreatedCallback = std::function<void(Dali::WebEnginePlugin*&)>;
 177
 178   /**
 179    * @brief Hit test callback called after hit test is created asynchronously.
 180    */
 181   using WebEngineHitTestCreatedCallback = std::function<bool(std::unique_ptr<Dali::WebEngineHitTest>)>;
 182
 183   /**
 184    * @brief WebView callback called after fullscreen is entered.
 185    */
 186   using WebEngineFullscreenEnteredCallback = std::function<void(void)>;
 187
 188   /**
 189    * @brief WebView callback called after fullscreen is exited.
 190    */
 191   using WebEngineFullscreenExitedCallback = std::function<void(void)>;
 192
 193   /**
 194    * @brief WebView callback called after text is found.
 195    */
 196   using WebEngineTextFoundCallback = std::function<void(uint32_t)>;
 197
 198   /**
 199    * @brief The callback to be called when the web engine received a plain text of current web page.
 200    */
 201   using PlainTextReceivedCallback = std::function<void(const std::string&)>;
 202
 203   /**
 204    * @brief Enumeration for the scroll edge.
 205    */
 206   enum class ScrollEdge
 207   {
 208     LEFT,   ///< Left edge reached.
 209     RIGHT,  ///< Right edge reached.
 210     TOP,    ///< Top edge reached.
 211     BOTTOM, ///< Bottom edge reached.
 212   };
 213
 214   /**
 215    * @brief Enumeration that provides the option to find text.
 216    */
 217   enum class FindOption
 218   {
 219     NONE                               = 0,      ///<  No search flags, this means a case sensitive, no wrap, forward only search
 220     CASE_INSENSITIVE                   = 1 << 0, ///<  Case insensitive search
 221     AT_WORD_STARTS                     = 1 << 1, ///<  Search text only at the beginning of the words
 222     TREAT_MEDIAL_CAPITAL_AS_WORD_START = 1 << 2, ///<  Treat capital letters in the middle of words as word start
 223     BACKWARDS                          = 1 << 3, ///<  Search backwards
 224     WRAP_AROUND                        = 1 << 4, ///<  If not present the search stops at the end of the document
 225     SHOW_OVERLAY                       = 1 << 5, ///<  Show overlay
 226     SHOW_FIND_INDICATOR                = 1 << 6, ///<  Show indicator
 227     SHOW_HIGHLIGHT                     = 1 << 7, ///<  Show highlight
 228   };
 229
 230   /**
 231    * @brief Constructor.
 232    */
 233   WebEnginePlugin() = default;
 234
 235   /**
 236    * @brief Destructor.
 237    */
 238   virtual ~WebEnginePlugin() = default;
 239
 240   /**
 241    * @brief Create WebEngine instance.
 242    *
 243    * @param [in] width The width of Web
 244    * @param [in] height The height of Web
 245    * @param [in] locale The locale of Web
 246    * @param [in] timezoneId The timezoneID of Web
 247    */
 248   virtual void Create(uint32_t width, uint32_t height, const std::string& locale, const std::string& timezoneId) = 0;
 249
 250   /**
 251    * @brief Create WebEngine instance.
 252    *
 253    * @param [in] width The width of Web
 254    * @param [in] height The height of Web
 255    * @param [in] argc The count of application arguments
 256    * @param [in] argv The string array of application arguments
 257    */
 258   virtual void Create(uint32_t width, uint32_t height, uint32_t argc, char** argv) = 0;
 259
 260   /**
 261    * @brief Destroy WebEngine instance.
 262    */
 263   virtual void Destroy() = 0;
 264
 265   /**
 266    * @brief Get settings of WebEngine.
 267    */
 268   virtual WebEngineSettings& GetSettings() const = 0;
 269
 270   /**
 271    * @brief Get back-forward list of WebEngine.
 272    */
 273   virtual WebEngineBackForwardList& GetBackForwardList() const = 0;
 274
 275   /**
 276    * @brief Load a web page based on a given URL.
 277    *
 278    * @param [in] url The URL of the resource to load
 279    */
 280   virtual void LoadUrl(const std::string& url) = 0;
 281
 282   /**
 283    * @brief Return the title of the Web.
 284    *
 285    * @return The title of web page
 286    */
 287   virtual std::string GetTitle() const = 0;
 288
 289   /**
 290    * @brief Return the Favicon of the Web.
 291    *
 292    * @return Favicon of Dali::PixelData& type
 293    */
 294   virtual Dali::PixelData GetFavicon() const = 0;
 295
 296   /**
 297    * @brief Get image to render.
 298    */
 299   virtual NativeImageSourcePtr GetNativeImageSource() = 0;
 300
 301   /**
 302    * @brief Change orientation.
 303    */
 304   virtual void ChangeOrientation(int orientation) = 0;
 305
 306   /**
 307    * @brief Return the URL of the Web.
 308    *
 309    * @return Url of string type
 310    */
 311   virtual std::string GetUrl() const = 0;
 312
 313   /**
 314    * @brief Load a given string as web contents.
 315    *
 316    * @param [in] htmlString The string to use as the contents of the web page
 317    */
 318   virtual void LoadHtmlString(const std::string& htmlString) = 0;
 319
 320   /**
 321    * @brief Load the specified html string as the content of the view overriding current history entry
 322    *
 323    * @param[in] html HTML data to load
 324    * @param[in] basicUri Base URL used for relative paths to external objects
 325    * @param[in] unreachableUrl URL that could not be reached
 326    *
 327    * @return true if successfully loaded, false otherwise
 328    */
 329   virtual bool LoadHtmlStringOverrideCurrentEntry(const std::string& html, const std::string& basicUri, const std::string& unreachableUrl) = 0;
 330
 331   /**
 332    * @brief Request loading the given contents by MIME type into the view object
 333    *
 334    * @param[in] contents The content to load
 335    * @param[in] contentSize The size of contents (in bytes)
 336    * @param[in] mimeType The type of contents, if 0 is given "text/html" is assumed
 337    * @param[in] encoding The encoding for contents, if 0 is given "UTF-8" is assumed
 338    * @param[in] baseUri The base URI to use for relative resources
 339    *
 340    * @return true if successfully request, false otherwise
 341    */
 342   virtual bool LoadContents(const int8_t* contents, uint32_t contentSize, const std::string& mimeType, const std::string& encoding, const std::string& baseUri) = 0;
 343
 344   /**
 345    * @brief Reload the Web.
 346    */
 347   virtual void Reload() = 0;
 348
 349   /**
 350    * @brief Reload the current page's document without cache
 351    */
 352   virtual bool ReloadWithoutCache() = 0;
 353
 354   /**
 355    * @brief Stop loading web contents on the current page.
 356    */
 357   virtual void StopLoading() = 0;
 358
 359   /**
 360    * @brief Suspend the operation associated with the view.
 361    */
 362   virtual void Suspend() = 0;
 363
 364   /**
 365    * @brief Resume the operation associated with the view object after calling Suspend().
 366    */
 367   virtual void Resume() = 0;
 368
 369   /**
 370    * @brief To suspend all url loading
 371    */
 372   virtual void SuspendNetworkLoading() = 0;
 373
 374   /**
 375    * @brief To resume new url network loading
 376    */
 377   virtual void ResumeNetworkLoading() = 0;
 378
 379   /**
 380    * @brief Add custom header
 381    *
 382    * @param[in] name custom header name to add the custom header
 383    * @param[in] value custom header value to add the custom header
 384    *
 385    * @return true if succeeded, false otherwise
 386    */
 387   virtual bool AddCustomHeader(const std::string& name, const std::string& value) = 0;
 388
 389   /**
 390    * @brief Remove custom header
 391    *
 392    * @param[in] name custom header name to remove the custom header
 393    *
 394    * @return true if succeeded, false otherwise
 395    */
 396   virtual bool RemoveCustomHeader(const std::string& name) = 0;
 397
 398   /**
 399    * @brief Start the inspector server
 400    *
 401    * @param[in] port port number
 402    *
 403    * @return the port number
 404    */
 405   virtual uint32_t StartInspectorServer(uint32_t port) = 0;
 406
 407   /**
 408    * @brief Stop the inspector server
 409    *
 410    * @return true if succeeded, false otherwise
 411    */
 412   virtual bool StopInspectorServer() = 0;
 413
 414   /**
 415    * @brief Scroll web page of view by deltaX and deltaY.
 416    *
 417    * @param[in] deltaX horizontal offset to scroll
 418    * @param[in] deltaY vertical offset to scroll
 419    */
 420   virtual void ScrollBy(int32_t deltaX, int32_t deltaY) = 0;
 421
 422   /**
 423    * @brief Scroll edge of view by deltaX and deltaY.
 424    *
 425    * @param[in] deltaX horizontal offset to scroll
 426    * @param[in] deltaY vertical offset to scroll
 427    *
 428    * @return true if succeeded, false otherwise
 429    */
 430   virtual bool ScrollEdgeBy(int32_t deltaX, int32_t deltaY) = 0;
 431
 432   /**
 433    * @brief Scroll to the specified position of the given view.
 434    */
 435   virtual void SetScrollPosition(int32_t x, int32_t y) = 0;
 436
 437   /**
 438    * @brief Get the current scroll position of the given view.
 439    */
 440   virtual Dali::Vector2 GetScrollPosition() const = 0;
 441
 442   /**
 443    * @brief Get the possible scroll size of the given view.
 444    */
 445   virtual Dali::Vector2 GetScrollSize() const = 0;
 446
 447   /**
 448    * @brief Get the last known content's size.
 449    */
 450   virtual Dali::Vector2 GetContentSize() const = 0;
 451
 452   /**
 453    * @brief Return whether forward is possible.
 454    *
 455    * @return True if forward is possible, false otherwise
 456    */
 457   virtual bool CanGoForward() = 0;
 458
 459   /**
 460    * @brief Go to forward.
 461    */
 462   virtual void GoForward() = 0;
 463
 464   /**
 465    * @brief Return whether backward is possible.
 466    *
 467    * @return True if backward is possible, false otherwise
 468    */
 469   virtual bool CanGoBack() = 0;
 470
 471   /**
 472    * @brief Go to back.
 473    */
 474   virtual void GoBack() = 0;
 475
 476   /**
 477    * @brief Evaluate JavaScript code represented as a string.
 478    *
 479    * @param[in] script The JavaScript code
 480    * @param[in] resultHandler The callback function to be called by the JavaScript runtime. This carries evaluation result.
 481    */
 482   virtual void EvaluateJavaScript(const std::string& script, JavaScriptMessageHandlerCallback resultHandler) = 0;
 483
 484   /**
 485    * @brief Add a message handler into JavaScript.
 486    *
 487    * @param[in] exposedObjectName The name of exposed object
 488    * @param[in] handler The callback function
 489    */
 490   virtual void AddJavaScriptMessageHandler(const std::string& exposedObjectName, JavaScriptMessageHandlerCallback handler) = 0;
 491
 492   /**
 493    * @brief Register a callback for JavaScript alert.
 494    *
 495    * @param[in] callback The callback function
 496    */
 497   virtual void RegisterJavaScriptAlertCallback(JavaScriptAlertCallback callback) = 0;
 498
 499   /**
 500    * @brief Reply for JavaScript alert.
 501    */
 502   virtual void JavaScriptAlertReply() = 0;
 503
 504   /**
 505    * @brief Register a callback for JavaScript confirm.
 506    *
 507    * @param[in] callback The callback function
 508    */
 509   virtual void RegisterJavaScriptConfirmCallback(JavaScriptConfirmCallback callback) = 0;
 510
 511   /**
 512    * @brief Reply for JavaScript confirm.
 513    */
 514   virtual void JavaScriptConfirmReply(bool confirmed) = 0;
 515
 516   /**
 517    * @brief Register a callback for JavaScript prompt.
 518    *
 519    * @param[in] callback The callback function
 520    */
 521   virtual void RegisterJavaScriptPromptCallback(JavaScriptPromptCallback callback) = 0;
 522
 523   /**
 524    * @brief Reply for JavaScript prompt.
 525    */
 526   virtual void JavaScriptPromptReply(const std::string& result) = 0;
 527
 528   /**
 529    * @brief Create a new hit test.
 530    *
 531    * @param[in] x the horizontal position to query
 532    * @param[in] y the vertical position to query
 533    * @param[in] mode the mode of hit test
 534    *
 535    * @return a new hit test object.
 536    */
 537   virtual std::unique_ptr<Dali::WebEngineHitTest> CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode) = 0;
 538
 539   /**
 540    * @brief create a hit test asynchronously.
 541    *
 542    * @param[in] x the horizontal position to query
 543    * @param[in] y the vertical position to query
 544    * @param[in] mode the mode of hit test
 545    * @param[in] callback The callback function
 546    *
 547    * @return true if succeeded, false otherwise
 548    */
 549   virtual bool CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, WebEngineHitTestCreatedCallback callback) = 0;
 550
 551   /**
 552    * @brief Clear the history of Web.
 553    */
 554   virtual void ClearHistory() = 0;
 555
 556   /**
 557    * @brief Clear all tiles resources of Web.
 558    */
 559   virtual void ClearAllTilesResources() = 0;
 560
 561   /**
 562    * @brief Get user agent string.
 563    *
 564    * @return The string value of user agent
 565    */
 566   virtual std::string GetUserAgent() const = 0;
 567
 568   /**
 569    * @brief Set user agent string.
 570    *
 571    * @param[in] userAgent The string value of user agent
 572    */
 573   virtual void SetUserAgent(const std::string& userAgent) = 0;
 574
 575   /**
 576    * @brief Set size of Web Page.
 577    */
 578   virtual void SetSize(uint32_t width, uint32_t height) = 0;
 579
 580   /**
 581    * @brief Set background color of web page.
 582    *
 583    * @param[in] color Background color
 584    */
 585   virtual void SetDocumentBackgroundColor(Dali::Vector4 color) = 0;
 586
 587   /**
 588    * @brief Clear tiles when hidden.
 589    *
 590    * @param[in] cleared Whether tiles are cleared or not
 591    */
 592   virtual void ClearTilesWhenHidden(bool cleared) = 0;
 593
 594   /**
 595    * @brief Set multiplier of cover area of tile.
 596    *
 597    * @param[in] multiplier The multiplier of cover area
 598    */
 599   virtual void SetTileCoverAreaMultiplier(float multiplier) = 0;
 600
 601   /**
 602    * @brief Enable cursor by client.
 603    *
 604    * @param[in] enabled Whether cursor is enabled or not
 605    */
 606   virtual void EnableCursorByClient(bool enabled) = 0;
 607
 608   /**
 609    * @brief Get the selected text.
 610    *
 611    * @return the selected text
 612    */
 613   virtual std::string GetSelectedText() const = 0;
 614
 615   /**
 616    * @brief Send Touch Events.
 617    */
 618   virtual bool SendTouchEvent(const TouchEvent& touch) = 0;
 619
 620   /**
 621    * @brief Send Key Events.
 622    */
 623   virtual bool SendKeyEvent(const KeyEvent& event) = 0;
 624
 625   /**
 626    * @brief Support mouse events or not.
 627    * @param[in] enabled True if enabled, false othewise.
 628    */
 629   virtual void EnableMouseEvents(bool enabled) = 0;
 630
 631   /**
 632    * @brief Support key events or not.
 633    * @param[in] enabled True if enabled, false othewise.
 634    */
 635   virtual void EnableKeyEvents(bool enabled) = 0;
 636
 637   /**
 638    * @brief Set focus.
 639    * @param[in] focused True if focus is gained, false lost.
 640    */
 641   virtual void SetFocus(bool focused) = 0;
 642
 643   /**
 644    * @brief Set zoom factor of the current page.
 645    * @param[in] zoomFactor a new factor to be set.
 646    */
 647   virtual void SetPageZoomFactor(float zoomFactor) = 0;
 648
 649   /**
 650    * @brief Query the current zoom factor of the page。
 651    * @return The current page zoom factor.
 652    */
 653   virtual float GetPageZoomFactor() const = 0;
 654
 655   /**
 656    * @brief Set the current text zoom level。.
 657    * @param[in] zoomFactor a new factor to be set.
 658    */
 659   virtual void SetTextZoomFactor(float zoomFactor) = 0;
 660
 661   /**
 662    * @brief Get the current text zoom level.
 663    * @return The current text zoom factor.
 664    */
 665   virtual float GetTextZoomFactor() const = 0;
 666
 667   /**
 668    * @brief Get the current load progress of the page.
 669    * @return The load progress of the page.
 670    */
 671   virtual float GetLoadProgressPercentage() const = 0;
 672
 673   /**
 674    * @brief Scale the current page, centered at the given point.
 675    * @param[in] scaleFactor a new factor to be scaled.
 676    * @param[in] point a center coordinate.
 677    */
 678   virtual void SetScaleFactor(float scaleFactor, Dali::Vector2 point) = 0;
 679
 680   /**
 681    * @brief Get the current scale factor of the page.
 682    * @return The current scale factor.
 683    */
 684   virtual float GetScaleFactor() const = 0;
 685
 686   /**
 687    * @brief Request to activate/deactivate the accessibility usage set by web app.
 688    * @param[in] activated Activate accessibility or not.
 689    */
 690   virtual void ActivateAccessibility(bool activated) = 0;
 691
 692   /**
 693    * @brief Get the accessibility address (bus and path) for embedding.
 694    * @return Accessibility address of the root web content element.
 695    */
 696   virtual Accessibility::Address GetAccessibilityAddress() = 0;
 697
 698   /**
 699    * @brief Request to set the current page's visibility.
 700    * @param[in] visible Visible or not.
 701    *
 702    * @return true if succeeded, false otherwise
 703    */
 704   virtual bool SetVisibility(bool visible) = 0;
 705
 706   /**
 707    * @brief Search and highlight the given string in the document.
 708    * @param[in] text The text to find
 709    * @param[in] options The options to find
 710    * @param[in] maxMatchCount The maximum match count to find
 711    *
 712    * @return true if found & highlighted, false otherwise
 713    */
 714   virtual bool HighlightText(const std::string& text, FindOption options, uint32_t maxMatchCount) = 0;
 715
 716   /**
 717    * @brief Add dynamic certificate path.
 718    * @param[in] host host that required client authentication
 719    * @param[in] certPath the file path stored certificate
 720    */
 721   virtual void AddDynamicCertificatePath(const std::string& host, const std::string& certPath) = 0;
 722
 723   /**
 724    * @brief Get snapshot of the specified viewArea of page.
 725    *
 726    * @param[in] viewArea The rectangle of screen shot
 727    * @param[in] scaleFactor The scale factor
 728    *
 729    * @return pixel data of screen shot
 730    */
 731   virtual Dali::PixelData GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor) = 0;
 732
 733   /**
 734    * @brief Request to get snapshot of the specified viewArea of page asynchronously.
 735    *
 736    * @param[in] viewArea The rectangle of screen shot
 737    * @param[in] scaleFactor The scale factor
 738    * @param[in] callback The callback for screen shot
 739    *
 740    * @return true if requested successfully, false otherwise
 741    */
 742   virtual bool GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, ScreenshotCapturedCallback callback) = 0;
 743
 744   /**
 745    * @brief Asynchronously request to check if there is a video playing in the given view.
 746    *
 747    * @param[in] callback The callback called after checking if video is playing or not
 748    *
 749    * @return true if requested successfully, false otherwise
 750    */
 751   virtual bool CheckVideoPlayingAsynchronously(VideoPlayingCallback callback) = 0;
 752
 753   /**
 754    * @brief Set callback which will be called upon geolocation permission request.
 755    *
 756    * @param[in] callback The callback for requesting geolocation permission
 757    */
 758   virtual void RegisterGeolocationPermissionCallback(GeolocationPermissionCallback callback) = 0;
 759
 760   /**
 761    * @brief Update display area.
 762    * @param[in] displayArea The display area need be updated.
 763    */
 764   virtual void UpdateDisplayArea(Dali::Rect<int32_t> displayArea) = 0;
 765
 766   /**
 767    * @brief Enable video hole.
 768    * @param[in] enabled True if enabled, false othewise.
 769    */
 770   virtual void EnableVideoHole(bool enabled) = 0;
 771
 772   /**
 773    * @brief Send Hover Events.
 774    * @param[in] event The hover event would be sent.
 775    */
 776   virtual bool SendHoverEvent(const HoverEvent& event) = 0;
 777
 778   /**
 779    * @brief Send Wheel Events.
 780    * @param[in] event The wheel event would be sent.
 781    */
 782   virtual bool SendWheelEvent(const WheelEvent& event) = 0;
 783
 784   /**
 785    * @brief Exit fullscreen.
 786    */
 787   virtual void ExitFullscreen() = 0;
 788
 789   /**
 790    * @brief Callback to be called when frame would be rendered.
 791    *
 792    * @param[in] callback
 793    */
 794   virtual void RegisterFrameRenderedCallback(WebEngineFrameRenderedCallback callback) = 0;
 795
 796   /**
 797    * @brief Callback to be called when page loading is started.
 798    *
 799    * @param[in] callback
 800    */
 801   virtual void RegisterPageLoadStartedCallback(WebEnginePageLoadCallback callback) = 0;
 802
 803   /**
 804    * @brief Callback to be called when page loading is in progress.
 805    *
 806    * @param[in] callback
 807    */
 808   virtual void RegisterPageLoadInProgressCallback(WebEnginePageLoadCallback callback) = 0;
 809
 810   /**
 811    * @brief Callback to be called when page loading is finished.
 812    *
 813    * @param[in] callback
 814    */
 815   virtual void RegisterPageLoadFinishedCallback(WebEnginePageLoadCallback callback) = 0;
 816
 817   /**
 818    * @brief Callback to be called when an error occurs in page loading.
 819    *
 820    * @param[in] callback
 821    */
 822   virtual void RegisterPageLoadErrorCallback(WebEnginePageLoadErrorCallback callback) = 0;
 823
 824   /**
 825    * @brief Callback to be called when scroll edge is reached.
 826    *
 827    * @param[in] callback
 828    */
 829   virtual void RegisterScrollEdgeReachedCallback(WebEngineScrollEdgeReachedCallback callback) = 0;
 830
 831   /**
 832    * @brief Callback to be called when url is changed.
 833    *
 834    * @param[in] callback
 835    */
 836   virtual void RegisterUrlChangedCallback(WebEngineUrlChangedCallback callback) = 0;
 837
 838   /**
 839    * @brief Callback to be called when form repost decision is requested.
 840    *
 841    * @param[in] callback
 842    */
 843   virtual void RegisterFormRepostDecidedCallback(WebEngineFormRepostDecidedCallback callback) = 0;
 844
 845   /**
 846    * @brief Callback to be called when console message will be logged.
 847    *
 848    * @param[in] callback
 849    */
 850   virtual void RegisterConsoleMessageReceivedCallback(WebEngineConsoleMessageReceivedCallback callback) = 0;
 851
 852   /**
 853    * @brief Callback to be called when response policy would be decided.
 854    *
 855    * @param[in] callback
 856    */
 857   virtual void RegisterResponsePolicyDecidedCallback(WebEngineResponsePolicyDecidedCallback callback) = 0;
 858
 859   /**
 860    * @brief Callback to be called when navigation policy would be decided.
 861    *
 862    * @param[in] callback
 863    */
 864   virtual void RegisterNavigationPolicyDecidedCallback(WebEngineNavigationPolicyDecidedCallback callback) = 0;
 865
 866   /**
 867    * @brief Callback to be called when new window policy would be decided.
 868    *
 869    * @param[in] callback
 870    */
 871   virtual void RegisterNewWindowPolicyDecidedCallback(WebEngineNewWindowPolicyDecidedCallback callback) = 0;
 872
 873   /**
 874    * @brief Callback to be called when a new window would be created.
 875    *
 876    * @param[in] callback
 877    */
 878   virtual void RegisterNewWindowCreatedCallback(WebEngineNewWindowCreatedCallback callback) = 0;
 879
 880   /**
 881    * @brief Callback to be called when certificate need be confirmed.
 882    *
 883    * @param[in] callback
 884    */
 885   virtual void RegisterCertificateConfirmedCallback(WebEngineCertificateCallback callback) = 0;
 886
 887   /**
 888    * @brief Callback to be called when ssl certificate is changed.
 889    *
 890    * @param[in] callback
 891    */
 892   virtual void RegisterSslCertificateChangedCallback(WebEngineCertificateCallback callback) = 0;
 893
 894   /**
 895    * @brief Callback to be called when http authentication need be confirmed.
 896    *
 897    * @param[in] callback
 898    */
 899   virtual void RegisterHttpAuthHandlerCallback(WebEngineHttpAuthHandlerCallback callback) = 0;
 900
 901   /**
 902    * @brief Callback to be called when context menu would be shown.
 903    *
 904    * @param[in] callback
 905    */
 906   virtual void RegisterContextMenuShownCallback(WebEngineContextMenuShownCallback callback) = 0;
 907
 908   /**
 909    * @brief Callback to be called when context menu would be hidden.
 910    *
 911    * @param[in] callback
 912    */
 913   virtual void RegisterContextMenuHiddenCallback(WebEngineContextMenuHiddenCallback callback) = 0;
 914
 915   /**
 916    * @brief Callback to be called when fullscreen would be entered.
 917    *
 918    * @param[in] callback
 919    */
 920   virtual void RegisterFullscreenEnteredCallback(WebEngineFullscreenEnteredCallback callback) = 0;
 921
 922   /**
 923    * @brief Callback to be called when fullscreen would be exited.
 924    *
 925    * @param[in] callback
 926    */
 927   virtual void RegisterFullscreenExitedCallback(WebEngineFullscreenExitedCallback callback) = 0;
 928
 929   /**
 930    * @brief Callback to be called when text would be found.
 931    *
 932    * @param[in] callback
 933    */
 934   virtual void RegisterTextFoundCallback(WebEngineTextFoundCallback callback) = 0;
 935
 936   /**
 937    * @brief Get a plain text of current web page asynchronously.
 938    *
 939    * @param[in] callback The callback function called asynchronously.
 940    */
 941   virtual void GetPlainTextAsynchronously(PlainTextReceivedCallback callback) = 0;
 942 };
 943
 944 // specialization has to be done in the same namespace
 945 template<>
 946 struct EnableBitMaskOperators<WebEnginePlugin::FindOption>
 947 {
 948   static const bool ENABLE = true;
 949 };
 950
 951 } // namespace Dali
 952
 953 #endif