wxruby3 1.7.0 → 1.8.0

data/lib/wx/doc/gen/web/web_view.rb

@@ -0,0 +1,1136 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  module WEB
+
+    # Zoom levels available in {Wx::WEB::WebView}.
+    # 
+    # 
+    # 
+    # @wxrb_require USE_WEBVIEW
+    class WebViewZoom < Wx::Enum
+    
+      # 
+      # 
+      WEBVIEW_ZOOM_TINY = Wx::WEB::WebViewZoom.new(0)
+      
+      # 
+      # 
+      WEBVIEW_ZOOM_SMALL = Wx::WEB::WebViewZoom.new(1)
+      
+      # default size
+      # 
+      WEBVIEW_ZOOM_MEDIUM = Wx::WEB::WebViewZoom.new(2)
+      
+      # 
+      # 
+      WEBVIEW_ZOOM_LARGE = Wx::WEB::WebViewZoom.new(3)
+      
+      # 
+      # 
+      WEBVIEW_ZOOM_LARGEST = Wx::WEB::WebViewZoom.new(4)
+      
+    end # WebViewZoom
+    
+    # The type of zooming that the web view control can perform.
+    # 
+    # 
+    # 
+    # @wxrb_require USE_WEBVIEW
+    class WebViewZoomType < Wx::Enum
+    
+      # The entire layout scales when zooming, including images.
+      # 
+      WEBVIEW_ZOOM_TYPE_LAYOUT = Wx::WEB::WebViewZoomType.new(0)
+      
+      # Only the text changes in size when zooming, images and other layout elements retain their initial size.
+      # 
+      WEBVIEW_ZOOM_TYPE_TEXT = Wx::WEB::WebViewZoomType.new(1)
+      
+    end # WebViewZoomType
+    
+    # Types of errors that can cause navigation to fail.
+    # 
+    # 
+    # 
+    # @wxrb_require USE_WEBVIEW
+    class WebViewNavigationError < Wx::Enum
+    
+      # Connection error (timeout, etc.).
+      # 
+      WEBVIEW_NAV_ERR_CONNECTION = Wx::WEB::WebViewNavigationError.new(0)
+      
+      # Invalid certificate.
+      # 
+      WEBVIEW_NAV_ERR_CERTIFICATE = Wx::WEB::WebViewNavigationError.new(1)
+      
+      # Authentication required.
+      # 
+      WEBVIEW_NAV_ERR_AUTH = Wx::WEB::WebViewNavigationError.new(2)
+      
+      # Other security error.
+      # 
+      WEBVIEW_NAV_ERR_SECURITY = Wx::WEB::WebViewNavigationError.new(3)
+      
+      # Requested resource not found.
+      # 
+      WEBVIEW_NAV_ERR_NOT_FOUND = Wx::WEB::WebViewNavigationError.new(4)
+      
+      # Invalid request/parameters (e.g.
+      # 
+      WEBVIEW_NAV_ERR_REQUEST = Wx::WEB::WebViewNavigationError.new(5)
+      
+      # The user cancelled (e.g.
+      # 
+      WEBVIEW_NAV_ERR_USER_CANCELLED = Wx::WEB::WebViewNavigationError.new(6)
+      
+      # Another (exotic) type of error that didn't fit in other categories.
+      # 
+      WEBVIEW_NAV_ERR_OTHER = Wx::WEB::WebViewNavigationError.new(7)
+      
+    end # WebViewNavigationError
+    
+    # Type of refresh.
+    # 
+    # 
+    # 
+    # @wxrb_require USE_WEBVIEW
+    class WebViewReloadFlags < Wx::Enum
+    
+      # Default reload, will access cache.
+      # 
+      WEBVIEW_RELOAD_DEFAULT = Wx::WEB::WebViewReloadFlags.new(0)
+      
+      # Reload the current view without accessing the cache.
+      # 
+      WEBVIEW_RELOAD_NO_CACHE = Wx::WEB::WebViewReloadFlags.new(1)
+      
+    end # WebViewReloadFlags
+    
+    # Find flags used when searching for text on page.
+    # 
+    # 
+    # 
+    # @wxrb_require USE_WEBVIEW
+    class WebViewFindFlags < Wx::Enum
+    
+      # Causes the search to restart when end or beginning reached.
+      # 
+      WEBVIEW_FIND_WRAP = Wx::WEB::WebViewFindFlags.new(1)
+      
+      # Matches an entire word when searching.
+      # 
+      WEBVIEW_FIND_ENTIRE_WORD = Wx::WEB::WebViewFindFlags.new(2)
+      
+      # Match case, i.e.
+      # 
+      WEBVIEW_FIND_MATCH_CASE = Wx::WEB::WebViewFindFlags.new(4)
+      
+      # Highlights the search results.
+      # 
+      WEBVIEW_FIND_HIGHLIGHT_RESULT = Wx::WEB::WebViewFindFlags.new(8)
+      
+      # Searches for phrase in backward direction.
+      # 
+      WEBVIEW_FIND_BACKWARDS = Wx::WEB::WebViewFindFlags.new(16)
+      
+      # The default flag, which is simple searching.
+      # 
+      WEBVIEW_FIND_DEFAULT = Wx::WEB::WebViewFindFlags.new(0)
+      
+    end # WebViewFindFlags
+    
+    # Navigation action types.
+    # 
+    # 
+    # 
+    # @wxrb_require USE_WEBVIEW
+    class WebViewNavigationActionFlags < Wx::Enum
+    
+      # No navigation action.
+      # 
+      WEBVIEW_NAV_ACTION_NONE = Wx::WEB::WebViewNavigationActionFlags.new(0)
+      
+      # The navigation was started by the user.
+      # 
+      WEBVIEW_NAV_ACTION_USER = Wx::WEB::WebViewNavigationActionFlags.new(1)
+      
+      # The navigation was started but not by the user.
+      # 
+      WEBVIEW_NAV_ACTION_OTHER = Wx::WEB::WebViewNavigationActionFlags.new(2)
+      
+    end # WebViewNavigationActionFlags
+    
+    # Specifies at which place of documents an user script will be inserted.
+    # 
+    # 
+    # 
+    # @wxrb_require USE_WEBVIEW
+    class WebViewUserScriptInjectionTime < Wx::Enum
+    
+      # Insert the code of the user script at the beginning of loaded documents.
+      # 
+      WEBVIEW_INJECT_AT_DOCUMENT_START = Wx::WEB::WebViewUserScriptInjectionTime.new(0)
+      
+      # Insert the code of the user script at the end of the loaded documents.
+      # 
+      WEBVIEW_INJECT_AT_DOCUMENT_END = Wx::WEB::WebViewUserScriptInjectionTime.new(1)
+      
+    end # WebViewUserScriptInjectionTime
+    
+    # Types of browsing data that can be cleared.
+    # 
+    # Note that different constants can be combined using the bitwise OR operator and that {Wx::WEB::WebViewBrowsingDataTypes::WEBVIEW_BROWSING_DATA_ALL} is a shorthand for specifying all of them.
+    # 
+    # @wxrb_require USE_WEBVIEW
+    class WebViewBrowsingDataTypes < Wx::Enum
+    
+      # All stored and session cookies.
+      # 
+      WEBVIEW_BROWSING_DATA_COOKIES = Wx::WEB::WebViewBrowsingDataTypes.new(1)
+      
+      # Cached data from disk and memory.
+      # 
+      WEBVIEW_BROWSING_DATA_CACHE = Wx::WEB::WebViewBrowsingDataTypes.new(2)
+      
+      # All DOM Storage: File Systems, Indexed DB, Local Storage, Web SQL, Cache Storage.
+      # 
+      WEBVIEW_BROWSING_DATA_DOM_STORAGE = Wx::WEB::WebViewBrowsingDataTypes.new(4)
+      
+      # Other browsing data like history, settings, auto fill, passwords, etc.
+      # 
+      WEBVIEW_BROWSING_DATA_OTHER = Wx::WEB::WebViewBrowsingDataTypes.new(8)
+      
+      # All browsing data, including data corresponding to all the other constants.
+      # 
+      WEBVIEW_BROWSING_DATA_ALL = Wx::WEB::WebViewBrowsingDataTypes.new(15)
+      
+    end # WebViewBrowsingDataTypes
+    
+    # Types of settings that can be applied to print operations.
+    # 
+    # 
+    # 
+    # @wxrb_require USE_WEBVIEW
+    class WebViewPrintFlags < Wx::Enum
+    
+      # Do not apply any custom settings.
+      # 
+      WEBVIEW_PRINT_DEFAULT = Wx::WEB::WebViewPrintFlags.new(0)
+      
+      # Explicitly prevents headers and footers from appearing in print operations.
+      # 
+      WEBVIEW_PRINT_HIDE_HEADER_FOOTER = Wx::WEB::WebViewPrintFlags.new(1)
+      
+    end # WebViewPrintFlags
+    
+    # 
+    # 
+    EVT_WEBVIEW_CREATED = 10464
+    
+    # 
+    # 
+    EVT_WEBVIEW_NAVIGATING = 10465
+    
+    # 
+    # 
+    EVT_WEBVIEW_NAVIGATED = 10466
+    
+    # 
+    # 
+    EVT_WEBVIEW_LOADED = 10467
+    
+    # 
+    # 
+    EVT_WEBVIEW_ERROR = 10468
+    
+    # 
+    # 
+    EVT_WEBVIEW_NEWWINDOW = 10469
+    
+    # 
+    # 
+    EVT_WEBVIEW_NEWWINDOW_FEATURES = 10470
+    
+    # 
+    # 
+    EVT_WEBVIEW_TITLE_CHANGED = 10472
+    
+    # 
+    # 
+    EVT_WEBVIEW_FULLSCREEN_CHANGED = 10473
+    
+    # 
+    # 
+    EVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED = 10474
+    
+    # 
+    # 
+    EVT_WEBVIEW_SCRIPT_RESULT = 10475
+    
+    # 
+    # 
+    EVT_WEBVIEW_WINDOW_CLOSE_REQUESTED = 10471
+    
+    # 
+    # 
+    EVT_WEBVIEW_BROWSING_DATA_CLEARED = 10476
+    
+    # This control may be used to render web (HTML / CSS / JavaScript) documents.
+    # 
+    # It is designed to allow the creation of multiple backends for each port. It differs from {Wx::HTML::HtmlWindow} in that each backend is actually a full web engine, provided by a 3rd party (e.g., WebView2 on MSW or WebKit on macOS and GTK). This allows the correct viewing of complex pages with JavaScript and CSS.
+    # 
+    # ## Backend Descriptions
+    # 
+    # This class supports using multiple backends, corresponding to different implementations of the same functionality. {Wx::WebViewChrome} is available on all three major platforms and each platform also has its own default native backend. Backends are identified by their names, documented in the backend descriptions below.
+    # 
+    # ## Wx::WEB::WEBVIEW_BACKEND_IE (MSW)
+    # 
+    # The IE backend uses Microsoft's WebBrowser control, which depends the locally installed version of Internet Explorer. By default this backend emulates Internet Explorer 11. This can be changed with a registry setting by {Wx::WEB::WebView#msw_set_ie_emulation_level} see this article for more information.
+    # This backend has full support for custom schemes and virtual file systems.
+    # The predefined {Wx::WEB::WEBVIEW_BACKEND_IE} constant contains the name of this backend and can be used to explicitly select it when using {Wx::WEB::WebView.new}.
+    # 
+    # <div class="wxrb-note">
+    # <b>Note:</b>
+    # <p>If you plan to display any modern web content you should consider using Wx::WEB::WEBVIEW_BACKEND_EDGE (MSW), as Internet Explorer is not supported anymore by Microsoft.
+    # </p>
+    # </div>
+    # 
+    # ## Wx::WEB::WEBVIEW_BACKEND_EDGE (MSW)
+    # 
+    # The Edge backend uses Microsoft's Edge WebView2. It is available for Windows 7 (newer versions require Windows 10+) and newer.
+    # This backend does not support custom schemes. When using handlers, see {Wx::WEB::WebViewHandler#set_virtual_host} for more details on how to access handler provided URLs.
+    # This backend is enabled by default for WXMSW.
+    # 
+    # If enabled and available at runtime, Edge will be selected as the default backend. If you require the IE backend use {Wx::WEB::WEBVIEW_BACKEND_IE} when using {Wx::WEB::WebView.new}.
+    # 
+    # The predefined {Wx::WEB::WEBVIEW_BACKEND_EDGE} constant contains the name of this backend.
+    # 
+    # ## Wx::WEB::WEBVIEW_BACKEND_WEBKIT (GTK)
+    # 
+    # Under GTK the WebKit backend uses WebKitGTK+. The current minimum version required is 1.3.1 which ships by default with Ubuntu Natty and Debian Wheezy and has the package name libwebkitgtk-dev.
+    # Custom schemes and virtual files systems are supported under this backend, however embedded resources such as images and stylesheets are currently loaded using the data:// scheme.
+    # The predefined {Wx::WEBVIEW_BACKEND_WEBKIT} constant contains the name of this backend.
+    # 
+    # ## Wx::WEB::WEBVIEW_BACKEND_WEBKIT2 (GTK3)
+    # 
+    # Under GTK3 the WebKit2 version of WebKitGTK+ is used. In Ubuntu the required package name is libwebkit2gtk-4.0-dev and under Fedora it is webkitgtk4-devel.
+    # All features are supported except for clearing and enabling / disabling the history.
+    # The predefined {Wx::WEBVIEW_BACKEND_WEBKIT} constant contains the name of this backend.
+    # 
+    # <div class="wxrb-note">
+    # <b>Note:</b>
+    # <p>WebKitGTK 2.42+ may fail to render content due to DMA-BUF hardware acceleration issues. This can be resolved by calling 
+    # 
+    # ```ruby
+    #  ENV['WEBKIT_DISABLE_DMABUF_RENDERER'] = '1'
+    # ```
+    #  before creating a {Wx::WEB::WebView} instance.
+    # </p>
+    # </div>
+    # 
+    # ## Wx::WEB::WEBVIEW_BACKEND_WEBKIT (macOS)
+    # 
+    # The macOS WebKit backend uses Apple's WKWebView class.
+    # This backend has full support for custom schemes and virtual file systems on macOS 10.13+. In order to use handlers, two-step creation has to be used and {Wx::WEB::WebView#register_handler} has to be called before {Wx::WEB::WebView#create}.
+    # Starting with macOS 10.11 and iOS 9 an application cannot create unsecure connections (this includes HTTP and unverified HTTPS). You have to include additional fields in your Info.plist to enable such connections. For further details see the documentation on NSAppTransportSecurity here
+    # The predefined {Wx::WEBVIEW_BACKEND_WEBKIT} constant contains the name of this backend.
+    # 
+    # ## Wx::WEB::WEBVIEW_BACKEND_CHROMIUM (MSW, macOS, GTK)
+    # 
+    # The Chromium Embedded Framework backend has to be enabled when building wxWidgets, see the wxWidgets documentation for wxWebViewChromium for additional usage and build instructions.
+    # This backend can not be automatically build by the wxRuby3 build scripts but requires a custom wxWidgets installation.
+    # See the wxRuby3 INSTALL documentation for details on how to build with a custom wxWidgets setup.
+    # 
+    # The predefined {Wx::WEB::WEBVIEW_BACKEND_CHROMIUM} constant contains the name of this backend.
+    # 
+    # ## Asynchronous Notifications
+    # 
+    # Many of the methods in {Wx::WEB::WebView} are asynchronous, i.e. they return immediately and perform their work in the background. This includes functions such as {Wx::WEB::WebView#load_url} and {Wx::WEB::WebView#reload}. To receive notification of the progress and completion of these functions you need to handle the events that are provided. Specifically {Wx::WEB::EVT_WEBVIEW_LOADED} notifies when the page or a sub-frame has finished loading and {Wx::WEB::EVT_WEBVIEW_ERROR} notifies that an error has occurred.
+    # 
+    # ## Virtual File Systems and Custom Schemes
+    # 
+    # {Wx::WEB::WebView} supports the registering of custom scheme handlers, for example file or http. To do this create a new class which inherits from {Wx::WEB::WebViewHandler}, where {Wx::WEB::WebViewHandler#get_file} returns a pointer to a {Wx::FSFile} which represents the given url or {Wx::WEB::WebViewHandler#start_request} for more complex requests. You can then register your handler with {Wx::WEB::WebView#register_handler} it will be called for all pages and resources.
+    # {Wx::WEB::WebViewFSHandler} is provided to access the virtual file system encapsulated by {Wx::FileSystem}. The {Wx::MemoryFSHandler} documentation gives an example of how this may be used.
+    # {Wx::WEB::WebViewArchiveHandler} is provided to allow the navigation of pages inside a zip archive. It supports paths of the form: <code>scheme:///C:/example/docs.zip;protocol=zip/main.htm</code>
+    # ### Events emitted by this class
+    # 
+    # The following event-handler methods redirect the events to member method or handler blocks for {Wx::WEB::WebViewEvent} events.
+    # Event handler methods for events emitted by this class:
+    # 
+    # - {Wx::EvtHandler#evt_webview_created}(id, meth = nil, &block): Process a {Wx::WEB::EVT_WEBVIEW_CREATED} event, generated when the object is fully initialized. For the backends using asynchronous initialization, such as {Wx::WebViewChromium}, most of this class member functions can be only used once this event is received. Available only in wxWidgets 3.3.0 or later. 
+    # 
+    # - {Wx::EvtHandler#evt_webview_navigating}(id, meth = nil, &block): Process a {Wx::WEB::EVT_WEBVIEW_NAVIGATING} event, generated before trying to get a resource. This event may be vetoed to prevent navigating to this resource. Note that if the displayed HTML document has several frames, one such event will be generated per frame. 
+    # 
+    # - {Wx::EvtHandler#evt_webview_navigated}(id, meth = nil, &block): Process a {Wx::WEB::EVT_WEBVIEW_NAVIGATED} event generated after it was confirmed that a resource would be requested. This event may not be vetoed. Note that if the displayed HTML document has several frames, one such event will be generated per frame. 
+    # 
+    # - {Wx::EvtHandler#evt_webview_loaded}(id, meth = nil, &block): Process a {Wx::WEB::EVT_WEBVIEW_LOADED} event generated when the document is fully loaded and displayed. Note that if the displayed HTML document has several frames, one such event will be generated per frame. 
+    # 
+    # - {Wx::EvtHandler#evt_webview_error}(id, meth = nil, &block): Process a {Wx::WEB::EVT_WEBVIEW_ERROR} event generated when a navigation error occurs. The integer associated with this event will be a {Wx::WebNavigationError} item. The string associated with this event may contain a backend-specific more precise error message/code. 
+    # 
+    # - {Wx::EvtHandler#evt_webview_newwindow}(id, meth = nil, &block): Process a {Wx::WEB::EVT_WEBVIEW_NEWWINDOW} event, generated when a new window is created. You must handle this event if you want anything to happen, for example to load the page in a new window or tab. For usage details see {Wx::WEB::WebViewWindowFeatures}. 
+    # 
+    # - {Wx::EvtHandler#evt_webview_newwindow_features}(id, meth = nil, &block): Process a {Wx::WEB::EVT_WEBVIEW_NEWWINDOW_FEATURES} event, generated when window features are available for the new window. For usage details see {Wx::WEB::WebViewWindowFeatures}. Available only in wxWidgets 3.3.0 or later. 
+    # 
+    # - {Wx::EvtHandler#evt_webview_window_close_requested}(id, meth = nil, &block): Process a {Wx::WEB::EVT_WEBVIEW_WINDOW_CLOSE_REQUESTED} event, generated when a window is requested to be closed. Available only in wxWidgets 3.3.0 or later. 
+    # 
+    # - {Wx::EvtHandler#evt_webview_title_changed}(id, meth = nil, &block): Process a {Wx::WEB::EVT_WEBVIEW_TITLE_CHANGED} event, generated when the page title changes. Use GetString to get the title. 
+    # 
+    # - {Wx::EvtHandler#evt_webview_fullscreen_changed}(id, meth = nil, &block): Process a {Wx::WEB::EVT_WEBVIEW_FULLSCREEN_CHANGED} event, generated when the page wants to enter or leave fullscreen. Use GetInt to get the status. Not implemented for the IE backend. Available only in wxWidgets 3.1.5 or later. 
+    # 
+    # - {Wx::EvtHandler#evt_webview_script_message_received}(id, meth = nil, &block): Process a {Wx::WEB::EVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED} event. Available only in wxWidgets 3.1.5 or later. For usage details see {Wx::WEB::WebView#add_script_message_handler}. 
+    # 
+    # - {Wx::EvtHandler#evt_webview_script_result}(id, meth = nil, &block): Process a {Wx::WEB::EVT_WEBVIEW_SCRIPT_RESULT} event. Available only in wxWidgets 3.1.6 or later. For usage details see {Wx::WEB::WebView#run_script_async}. 
+    # 
+    # - wxEVT_WEBVIEW_BROWSING_DATA_CLEARED(id,  func): Process a {Wx::WEB::EVT_WEBVIEW_BROWSING_DATA_CLEARED} event only available in wxWidgets 3.3.0 or later. For usage details see {Wx::WEB::WebView#clear_browsing_data}. 
+    # 
+    # Library:  {Wx::WEB::WebView}
+    # Category:  {Wx::Controls}, {Wx::WEB::WebView}
+    # @see Wx::WEB::WebViewEvent
+    # @see  Wx::WEB::WebViewConfiguration
+    # @see  Wx::WEB::WebViewHandler 
+    # 
+    # 
+    # @wxrb_require USE_WEBVIEW
+    class WebView < Control
+    
+      # Runs the given JavaScript code.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>Because of various potential issues it's recommended to use {Wx::WEB::WebView#run_script_async} instead of this method. This is especially true if you plan to run code from a webview event and will also prevent unintended side effects on the UI outside of the webview.
+      # </p>
+      # </div>
+      # 
+      # JavaScript code is executed inside the browser control and has full access to DOM and other browser-provided functionality. For example, this code 
+      # 
+      # ```ruby
+      #  webview.run_script('document.write('Hello from wxWidgets!')')
+      # ```
+      #  will replace the current page contents with the provided string.
+      # This method returns the result of executing this code on success (or nil if no result or on failure), e.g. a JavaScript value such as a string, a number (integer or floating point), a boolean or JSON representation for non-primitive types such as arrays and objects. For example: 
+      # 
+      # ```ruby
+      #    if (result = webview.run_script('document.getElementById('some_id').innerHTML'))
+      #        #... result contains the contents of the given element ...
+      #    # else: the element with this ID probably doesn't exist.
+      #    end
+      # ```
+      # 
+      # This function has a few platform-specific limitations:
+      # 
+      # - When using WebKit v1 in WXGTK2, retrieving the result of JavaScript execution is unsupported and this function will always return nil if output is non-null to indicate this. This functionality is fully supported when using WebKit v2 or later in WXGTK3.
+      # - When using WebKit under macOS, code execution is limited to at most 10MiB of memory and 10 seconds of execution time.
+      # - When using Chromium backend, retrieving the result of JavaScript execution is unsupported and this function will always return nil if output is non-null to indicate this.
+      # - When using IE backend under MSW, scripts can only be executed when the current page is fully loaded (i.e. {Wx::WEB::EVT_WEBVIEW_LOADED} event was received). A script tag inside the page HTML is required in order to run JavaScript.
+      # 
+      # Also notice that with the IE backend converting JavaScript objects to JSON is not supported in the default emulation mode, it implements its own object-to-JSON conversion as a fallback for this case, however it is not as full-featured, well-tested or performing as the implementation of this functionality in the browser control itself, so it is recommended to use Wx::WEB::WebView::msw_set_ie_emulation_level to change emulation level to a more modern one in which JSON conversion is done by the control itself.
+      # @see Wx::WEB::WebView#run_script_async 
+      # @param javascript [String]  JavaScript code to execute.
+      # @return [String,nil]
+      def run_script(javascript) end
+      
+      # Runs the given JavaScript code asynchronously and returns the result via a {Wx::WEB::EVT_WEBVIEW_SCRIPT_RESULT}.
+      # 
+      # The script result value can be retrieved via {Wx::WEB::WebViewEvent#get_string}. If the execution fails {Wx::WEB::WebViewEvent#is_error} will return true. In this case additional script execution error information maybe available via {Wx::WEB::WebViewEvent#get_string}.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>The IE backend does not support async script execution.
+      # </p>
+      # </div>
+      # @see Wx::WEB::WebView#run_script 
+      # @param javascript [String]  JavaScript code to execute.
+      # @return [void]
+      def run_script_async(javascript) end
+      
+      # Add a script message handler with the given name.
+      # 
+      # To use the script message handler from javascript use <code>window.<name>.postMessage(<messageBody>)</code> where <code><name></code> corresponds the value of the name parameter. The <code><messageBody></code> will be available to the application via a {Wx::WEB::EVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED} event.
+      # Sample code receiving a script message: 
+      # 
+      # ```ruby
+      #    # Install message handler with the name wx_msg
+      #    @webView.add_script_message_handler("wx_msg")
+      #    # Bind handler
+      #    @webView.evt_webview_script_message_received(Wx::ID_ANY) { |evt|
+      #        Wx.log_message("Script message received; value = %s, handler = %s", evt.get_string, evt.get_message_handler)
+      #    }
+      # ```
+      # 
+      # Sample JavaScript sending a script message: 
+      # ```
+      #   // Send sample message body
+      #   window.wx_msg.postMessage('This is a message body');
+      # ```
+      # 
+      # true if the handler could be added, false if it could not be added.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>The Edge backend only supports a single message handler and the Chromium and IE backends do not support script message handlers.
+      # </p>
+      # </div>
+      # @see Wx::WEB::WebView#remove_script_message_handler
+      # @param name [String]  Name of the message handler that can be used from JavaScript
+      # @return [Boolean]
+      def add_script_message_handler(name) end
+      
+      # Remove a script message handler with the given name that was previously added via {Wx::WEB::WebView#add_script_message_handler}.
+      # 
+      # true if the handler could be removed, false if it could not be removed.
+      # @see Wx::WEB::WebView#add_script_message_handler
+      # @param name [String] 
+      # @return [Boolean]
+      def remove_script_message_handler(name) end
+      
+      # Injects the specified script into the webpage's content.
+      # 
+      # true if the script was added successfully.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>Please note that this is unsupported by the IE backend and the Edge backend does only support {Wx::WEB::WebViewUserScriptInjectionTime::WEBVIEW_INJECT_AT_DOCUMENT_START}.
+      # </p>
+      # </div>
+      # @see Wx::WEB::WebView#remove_all_user_scripts
+      # @param javascript [String]  The JavaScript code to add.
+      # @param injectionTime [Wx::WebViewUserScriptInjectionTime]  Specifies when the script will be executed.
+      # @return [Boolean]
+      def add_user_script(javascript, injectionTime=Wx::WEB::WebViewUserScriptInjectionTime::WEBVIEW_INJECT_AT_DOCUMENT_START) end
+      
+      # Removes all user scripts from the web view.
+      # 
+      # 
+      # @see Wx::WEB::WebView#add_user_script
+      # @return [void]
+      def remove_all_user_scripts; end
+      
+      # Returns true if the current selection can be copied.
+      # @return [Boolean]
+      def can_copy; end
+      alias_method :can_copy?, :can_copy
+      
+      # Returns true if the current selection can be cut.
+      # @return [Boolean]
+      def can_cut; end
+      alias_method :can_cut?, :can_cut
+      
+      # Returns true if data can be pasted.
+      # @return [Boolean]
+      def can_paste; end
+      alias_method :can_paste?, :can_paste
+      
+      # Copies the current selection.
+      # @return [void]
+      def copy; end
+      
+      # Cuts the current selection.
+      # @return [void]
+      def cut; end
+      
+      # Pastes the current data.
+      # @return [void]
+      def paste; end
+      
+      # Enable or disable the right click context menu.
+      # 
+      # By default the standard context menu is enabled, this method can be used to disable it or re-enable it later.
+      # @param enable [Boolean] 
+      # @return [void]
+      def enable_context_menu(enable=true) end
+      
+      # Returns true if a context menu will be shown on right click.
+      # @return [Boolean]
+      def is_context_menu_enabled; end
+      alias_method :context_menu_enabled?, :is_context_menu_enabled
+      
+      # Enable or disable access to dev tools for the user.
+      # 
+      # Dev tools are disabled by default.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>This is not implemented for the IE backend.
+      # </p>
+      # </div>
+      # @see Wx::WEB::WebView#show_dev_tools 
+      # @param enable [Boolean] 
+      # @return [void]
+      def enable_access_to_dev_tools(enable=true) end
+      
+      # Returns true if dev tools are available to the user.
+      # @return [Boolean]
+      def is_access_to_dev_tools_enabled; end
+      alias_method :access_to_dev_tools_enabled?, :is_access_to_dev_tools_enabled
+      
+      # Show the dev tools window.
+      # 
+      # Immediately open the dev tools window. Does nothing if this window was already open.
+      # Unlike {Wx::WEB::WebView#enable_access_to_dev_tools}, which allows the user to open the dev tools window from the context menu, this function opens the same window programmatically.
+      # Please note that while {Wx::WEB::WebView#show_dev_tools} can be used whether access to the dev tools from the context menu was enabled or not, in WebKit2GTK+ backend calling it also enables interactive access to the dev tools from the context menu as a side effect.
+      # true if the dev tools window is shown (even if it had been already shown before this function was called), false if it could not be shown for some reason, most likely because the backend does not provide this functionality.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>This function is not implemented in the IE and WebKit (GTK/macOS) backends (but is implemented for WebKit2 GTK backend).
+      # </p>
+      # </div>
+      # @return [Boolean]
+      def show_dev_tools; end
+      
+      # Enable or disable if browser accelerator keys are enabled.
+      # 
+      # Browser accelerator keys are enabled by default.
+      # The webview might implement various accelerator keys. This includes allowing accelerator key access to features such as printing and navigation. In many cases this might not be desired and the default keys can be disabled with this setting.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>This is only implemented for the Edge backend.
+      # </p>
+      # </div>
+      # @param enable [Boolean] 
+      # @return [void]
+      def enable_browser_accelerator_keys(enable=true) end
+      
+      # Returns true if browser accelerator keys are enabled.
+      # @return [Boolean]
+      def are_browser_accelerator_keys_enabled; end
+      
+      # Returns true if it is possible to navigate backward in the history of visited pages.
+      # @return [Boolean]
+      def can_go_back; end
+      alias_method :can_go_back?, :can_go_back
+      
+      # Returns true if it is possible to navigate forward in the history of visited pages.
+      # @return [Boolean]
+      def can_go_forward; end
+      alias_method :can_go_forward?, :can_go_forward
+      
+      # Clear the history, this will also remove the visible page.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>This is not implemented on the WebKit2GTK+ backend and macOS. 
+      # </p>
+      # </div>
+      # @return [void]
+      def clear_history; end
+      
+      # Enable or disable the history.
+      # 
+      # This will also clear the history.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>This is not implemented on the WebKit2GTK+ backend and macOS. 
+      # </p>
+      # </div>
+      # @param enable [Boolean] 
+      # @return [void]
+      def enable_history(enable=true) end
+      
+      # Returns a list of items in the back history.
+      # 
+      # The first item in the vector is the first page that was loaded by the control.
+      # @return [Array<Wx::WEB::WebViewHistoryItem>]
+      def get_backward_history; end
+      alias_method :backward_history, :get_backward_history
+      
+      # Returns a list of items in the forward history.
+      # 
+      # The first item in the vector is the next item in the history with respect to the currently loaded page.
+      # @return [Array<Wx::WEB::WebViewHistoryItem>]
+      def get_forward_history; end
+      alias_method :forward_history, :get_forward_history
+      
+      # Navigate back in the history of visited pages.
+      # 
+      # Only valid if {Wx::WEB::WebView#can_go_back} returns true.
+      # @return [void]
+      def go_back; end
+      
+      # Navigate forward in the history of visited pages.
+      # 
+      # Only valid if {Wx::WEB::WebView#can_go_forward} returns true.
+      # @return [void]
+      def go_forward; end
+      
+      # Loads a history item.
+      # @param item [Wx::WEB::WebViewHistoryItem] 
+      # @return [void]
+      def load_history_item(item) end
+      
+      # Clears the current selection.
+      # @return [void]
+      def clear_selection; end
+      
+      # Deletes the current selection.
+      # 
+      # Note that for {Wx::WEBVIEW_BACKEND_WEBKIT} the selection must be editable, either through SetEditable or the correct HTML attribute.
+      # @return [void]
+      def delete_selection; end
+      
+      # Returns the currently selected source, if any.
+      # @return [String]
+      def get_selected_source; end
+      alias_method :selected_source, :get_selected_source
+      
+      # Returns the currently selected text, if any.
+      # @return [String]
+      def get_selected_text; end
+      alias_method :selected_text, :get_selected_text
+      
+      # Returns true if there is a current selection.
+      # @return [Boolean]
+      def has_selection; end
+      alias_method :has_selection?, :has_selection
+      
+      # Selects the entire page.
+      # @return [void]
+      def select_all; end
+      
+      # Returns true if there is an action to redo.
+      # @return [Boolean]
+      def can_redo; end
+      alias_method :can_redo?, :can_redo
+      
+      # Returns true if there is an action to undo.
+      # @return [Boolean]
+      def can_undo; end
+      alias_method :can_undo?, :can_undo
+      
+      # Redos the last action.
+      # @return [void]
+      def redo_; end
+      
+      # Undos the last action.
+      # @return [void]
+      def undo; end
+      
+      # Finds a phrase on the current page and if found, the control will scroll the phrase into view and select it.
+      # 
+      # If search phrase was not found in combination with the flags then {Wx::NOT_FOUND} is returned. If called for the first time with search phrase then the total number of results will be returned. Then for every time its called with the same search phrase it will return the number of the current match. 
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>This function will restart the search if the flags {Wx::WEB::WebViewFindFlags::WEBVIEW_FIND_ENTIRE_WORD} or {Wx::WEB::WebViewFindFlags::WEBVIEW_FIND_MATCH_CASE} are changed, since this will require a new search. To reset the search, for example resetting the highlights call the function with an empty search phrase. 
+      # </p>
+      # </div>
+      # @param text [String]  The phrase to search for.
+      # @param flags [Wx::WebViewFindFlags]  The flags for the search.
+      # @return [Integer]
+      def find(text, flags=Wx::WEB::WebViewFindFlags::WEBVIEW_FIND_DEFAULT) end
+      
+      # Retrieve whether a zoom type is supported.
+      # 
+      # true if this type of zoom is supported by this backend (and thus can be set through {Wx::WEB::WebView#set_zoom_type}).
+      # @param type [Wx::WebViewZoomType]  The zoom type to test.
+      # @return [Boolean]
+      def can_set_zoom_type(type) end
+      alias_method :can_set_zoom_type?, :can_set_zoom_type
+      
+      # Get the zoom level of the page.
+      # 
+      # See {Wx::WEB::WebView#get_zoom_factor} to get more precise zoom scale value other than as provided by {Wx::WEB::WebViewZoom}. The current level of zoom.
+      # @return [Wx::WebViewZoom]
+      def get_zoom; end
+      alias_method :zoom, :get_zoom
+      
+      # Get the zoom factor of the page.
+      # 
+      # The current factor of zoom.
+      # @return [Float]
+      def get_zoom_factor; end
+      alias_method :zoom_factor, :get_zoom_factor
+      
+      # Get how the zoom factor is currently interpreted.
+      # 
+      # How the zoom factor is currently interpreted by the backend.
+      # @return [Wx::WebViewZoomType]
+      def get_zoom_type; end
+      alias_method :zoom_type, :get_zoom_type
+      
+      # Set the zoom level of the page.
+      # 
+      # See {Wx::WEB::WebView#set_zoom_factor} for more precise scaling other than the measured steps provided by {Wx::WEB::WebViewZoom}.
+      # @param zoom [Wx::WebViewZoom]  How much to zoom (scale) the HTML document.
+      # @return [void]
+      def set_zoom(zoom) end
+      alias_method :zoom=, :set_zoom
+      
+      # Set the zoom factor of the page.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>zoom scale in IE will be converted into {Wx::WEB::WebViewZoom} levels for {Wx::WEB::WebViewZoomType} of {Wx::WEB::WebViewZoomType::WEBVIEW_ZOOM_TYPE_TEXT}. 
+      # </p>
+      # </div>
+      # @param zoom [Float]  How much to zoom (scale) the HTML document in arbitrary number.
+      # @return [void]
+      def set_zoom_factor(zoom) end
+      alias_method :zoom_factor=, :set_zoom_factor
+      
+      # Set how to interpret the zoom factor.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>invoke {Wx::WEB::WebView#can_set_zoom_type} first, some backends may not support all zoom types. 
+      # </p>
+      # </div>
+      # @param zoomType [Wx::WebViewZoomType]  How the zoom factor should be interpreted by the backend.
+      # @return [void]
+      def set_zoom_type(zoomType) end
+      alias_method :zoom_type=, :set_zoom_type
+      
+      # Creation function for two-step creation.
+      # 
+      # Please note that the object creation may be asynchronous when using some backends (e.g., {Wx::WebViewEdge} or {Wx::WebViewChromium}) and the object is not really created until {Wx::WEB::EVT_WEBVIEW_CREATED} event is received, so any non-trivial calls to its member functions should be delayed until then.
+      # @param parent [Wx::Window] 
+      # @param id [Integer] 
+      # @param url [String] 
+      # @param pos [Array(Integer, Integer), Wx::Point] 
+      # @param size [Array(Integer, Integer), Wx::Size] 
+      # @param style [Integer] 
+      # @param name [String] 
+      # @return [Boolean]
+      def create(parent, id, url=Wx::WEB_VIEW_DEFAULT_URL_STR, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::WEB_VIEW_NAME_STR) end
+      
+      # Get the title of the current web page, or its URL/path if title is not available.
+      # @return [String]
+      def get_current_title; end
+      alias_method :current_title, :get_current_title
+      
+      # Get the URL of the currently displayed document.
+      # @return [String]
+      def get_current_url; end
+      alias_method :current_url, :get_current_url
+      
+      # Get the HTML source code of the currently displayed document.
+      # 
+      # The HTML source code, or an empty string if no page is currently shown.
+      # @return [String]
+      def get_page_source; end
+      alias_method :page_source, :get_page_source
+      
+      # Get the text of the current page.
+      # @return [String]
+      def get_page_text; end
+      alias_method :page_text, :get_page_text
+      
+      # Returns whether the web control is currently busy (e.g. loading a page).
+      # @return [Boolean]
+      def is_busy; end
+      alias_method :busy?, :is_busy
+      
+      # Returns whether the web control is currently editable.
+      # @return [Boolean]
+      def is_editable; end
+      alias_method :editable?, :is_editable
+      
+      # Load a web page from a URL.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>Web engines generally report errors asynchronously, so if you wish to know whether loading the URL was successful, register to receive navigation error events. 
+      # </p>
+      # </div>
+      # @param url [String]  The URL of the page to be loaded.
+      # @return [void]
+      def load_url(url) end
+      
+      # @overload print()
+      #   Opens a print dialog (with the backend's default settings) so that the user may print the currently displayed page.
+      #   @return [void]
+      # @overload print(printData, flags=Wx::WEB::WebViewPrintFlags::WEBVIEW_PRINT_HIDE_HEADER_FOOTER)
+      #   Prints the currently displayed page using the given print settings.
+      #   
+      #   The printData parameter allows specifying paper size, orientation, number of copies, duplex mode and colour/greyscale output.
+      #   The flags parameter is a combination of {Wx::WEB::WebViewPrintFlags} values. By default, headers and footers are shown (where supported by the backend). Pass {Wx::WEB::WebViewPrintFlags::WEBVIEW_PRINT_HIDE_HEADER_FOOTER} to suppress them.
+      #   This overload is only available when {Wx::Setup::USE_PRINTING_ARCHITECTURE} is set to 1. Backends that do not support programmatic print settings will fall back to the parameterless {Wx::WEB::WebView#print}.
+      #   Currently the Edge backend (MSW) has full support for all {Wx::PRT::PrintData} settings including header/footer control. The GTK and macOS backends support paper size, orientation, and copies but ignore flags. The IE and Chromium backends fall back to {Wx::WEB::WebView#print}.
+      #   @param printData [Wx::PRT::PrintData]  The print settings to use.
+      #   @param flags [Integer]  A combination of {Wx::WEB::WebViewPrintFlags} values.
+      #   @return [void]
+      def print(*args) end
+      
+      # Registers a custom scheme handler.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>On macOS in order to use handlers two-step creation has to be used and {Wx::WEB::WebView#register_handler} has to be called before {Wx::WEB::WebView#create}. With the other backends it has to be called after {Wx::WEB::WebView#create}.
+      # </p>
+      # </div>
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>The Edge backend does not support custom schemes, but the handler is available as a virtual host under <code>https://scheme.wxsite</code>. To customize this virtual host call {Wx::WEB::WebViewHandler#set_virtual_host} before registering the handler. 
+      # </p>
+      # </div>
+      # @param handler [Wx::WebViewHandler>]  A shared pointer to a {Wx::WebHandler}.
+      # @return [void]
+      def register_handler(handler) end
+      
+      # Reload the currently displayed URL.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>The flags are ignored by the Edge backend. 
+      # </p>
+      # </div>
+      # @param flags [Wx::WebViewReloadFlags]  A bit array that may optionally contain reload options.
+      # @return [void]
+      def reload(flags=Wx::WEB::WebViewReloadFlags::WEBVIEW_RELOAD_DEFAULT) end
+      
+      # Set the editable property of the web control.
+      # 
+      # Enabling allows the user to edit the page even if the contenteditable attribute is not set. The exact capabilities vary with the backend being used.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>This is not implemented for macOS and the Edge backend. 
+      # </p>
+      # </div>
+      # @param enable [Boolean] 
+      # @return [void]
+      def set_editable(enable=true) end
+      alias_method :editable=, :set_editable
+      
+      # @overload set_page(html, baseUrl)
+      #   Set the displayed page source to the contents of the given string.
+      #   
+      #   <div class="wxrb-note">
+      #   <b>Note:</b>
+      #   <p>When using {Wx::WEB::WEBVIEW_BACKEND_IE} you must wait for the current page to finish loading before calling {Wx::WEB::WebView#set_page}. The baseURL parameter is not used in this backend and the Edge backend. 
+      #   </p>
+      #   </div>
+      #   @param html [String]  The string that contains the HTML data to display.
+      #   @param baseUrl [String]  URL assigned to the HTML data, to be used to resolve relative paths, for instance.
+      #   @return [void]
+      # @overload set_page(html, baseUrl)
+      #   Set the displayed page source to the contents of the given stream.
+      #   @param html [IO,Wx::InputStream]  The stream to read HTML data from.
+      #   @param baseUrl [String]  URL assigned to the HTML data, to be used to resolve relative paths, for instance.
+      #   @return [void]
+      def set_page(*args) end
+      
+      # Stop the current page loading process, if any.
+      # 
+      # May trigger an error event of type {Wx::WEB::WebViewNavigationError::WEBVIEW_NAV_ERR_USER_CANCELLED}. TODO: make {Wx::WEB::WebViewNavigationError::WEBVIEW_NAV_ERR_USER_CANCELLED} errors uniform across ports.
+      # @return [void]
+      def stop; end
+      
+      # Specify a custom user agent string for the web view.
+      # 
+      # Returns true the user agent could be set.
+      # If your first request should already use the custom user agent please use two step creation and call {Wx::WEB::WebView#set_user_agent} before {Wx::WEB::WebView#create}.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>This is not implemented for IE.
+      # </p>
+      # </div>
+      # @param userAgent [String] 
+      # @return [Boolean]
+      def set_user_agent(userAgent) end
+      alias_method :user_agent=, :set_user_agent
+      
+      # Returns the current user agent string for the web view.
+      # @return [String]
+      def get_user_agent; end
+      alias_method :user_agent, :get_user_agent
+      
+      # Set the proxy to use for all requests.
+      # 
+      # The proxy string must be a valid proxy specification, e.g. <code>http://my.local.proxy.corp:8080</code> 
+      # Currently this function is only implemented in WebKit2, Edge and Chromium backends and only WebKit2 backend allows to set the proxy after creating the webview, so it is recommended to call it before {Wx::WEB::WebView#create}: 
+      # 
+      # ```ruby
+      #   webview = Wx::WEB::WebView.new
+      #   unless webview.set_proxy("http://127.0.0.1:8080")
+      #       Wx.log_warning("Setting proxy failed!")
+      #   end
+      #   webview.create(parent, Wx::ID_ANY)
+      # ```
+      # 
+      # true if proxy was set successfully or false if it failed, e.g. because this is not supported by the currently used backend.
+      # @param proxy [String] 
+      # @return [Boolean]
+      def set_proxy(proxy) end
+      alias_method :proxy=, :set_proxy
+      
+      # Clears the browsing data of the web view.
+      # 
+      # This function clears the browsing data of the web view, such as cookies, cache, history, etc. The exact data that is cleared depends on the backend used.
+      # This operation is asynchronous and may take some time to complete. When finished {Wx::WEB::EVT_WEBVIEW_BROWSING_DATA_CLEARED} event is generated.
+      # 
+      # false if backend doesn't support clearing browsing data or an error occurred. Otherwise, true is returned and the browsing data will be cleared asynchronously and the application will receive a {Wx::WEB::EVT_WEBVIEW_BROWSING_DATA_CLEARED} event when it is done (or if doing it fails later).
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>This is only implemented in the Edge, WebKit2GTK+ and macOS backends.
+      # </p>
+      # </div>
+      # @see Wx::WEB::WebViewBrowsingDataTypes 
+      # @param types [Integer]  The types of browsing data to clear. By default, it clears all types of browsing data.
+      # @param since [Time,Date,DateTime]  The time since when the browsing data should be cleared. By default, it clears all browsing data.
+      # @return [Boolean]
+      def clear_browsing_data(types=Wx::WEB::WebViewBrowsingDataTypes::WEBVIEW_BROWSING_DATA_ALL, since=({})) end
+      
+      # @overload self.new(backend=Wx::WEB_VIEW_BACKEND_DEFAULT)
+      #   Factory function to create a new {Wx::WEB::WebView} with two-step creation, {Wx::WEB::WebView#create} should be called on the returned object.
+      #   
+      #   The created {Wx::WEB::WebView}.
+      #   @param backend [String]  The backend to use.
+      #   @return [Wx::WEB::WebView]
+      # @overload self.new(config)
+      #   Factory function to create a new {Wx::WEB::WebView} with two-step creation, {Wx::WEB::WebView#create} should be called on the returned object.
+      #   
+      #   The created {Wx::WEB::WebView}
+      #   @param config [Wx::WEB::WebViewConfiguration]  a configuration object create with {Wx::WEB::WebView.new_configuration}.
+      #   @return [Wx::WEB::WebView]
+      # @overload self.new(parent, id, url=Wx::WEB_VIEW_DEFAULT_URL_STR, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, backend=Wx::WEB_VIEW_BACKEND_DEFAULT, style=0, name=Wx::WEB_VIEW_NAME_STR)
+      #   Factory function to create a new {Wx::WEB::WebView} using a {Wx::WebViewFactory}.
+      #   
+      #   Note that the returned object may not be immediately usable yet, see {Wx::WEB::WebView#create} and {Wx::WEB::EVT_WEBVIEW_CREATED}.
+      #   
+      #   The created {Wx::WEB::WebView}, or nil if the requested backend is not available
+      #   @param parent [Wx::Window]  Parent window for the control
+      #   @param id [Integer]  ID of this control
+      #   @param url [String]  Initial URL to load
+      #   @param pos [Array(Integer, Integer), Wx::Point]  Position of the control
+      #   @param size [Array(Integer, Integer), Wx::Size]  Size of the control
+      #   @param backend [String]  The backend web engine to use. {Wx::WebViewBackendDefault} and other backend names constants in format <code>wxWebViewBackend<Name></code> (e.g., {Wx::WebViewBackendWebKit}) are predefined where appropriate. See Backend descriptions.
+      #   @param style [Integer]  Window style. For generic window styles, please see {Wx::Window}.
+      #   @param name [String]  Window name.
+      #   @return [Wx::WEB::WebView]
+      def self.new(*args) end
+      
+      # Allows to check if a specific backend is currently available.
+      # 
+      # For example, to check for Edge backend availability: 
+      # 
+      # ```ruby
+      #   if Wx::WEB::WebView::is_backend_available(Wx::WEB::WEBVIEW_BACKEND_EDGE)
+      #       #... enable some extra functionality not available with the IE backend ...
+      #   end
+      # ```
+      # @param backend [String] 
+      # @return [Boolean]
+      def self.is_backend_available(backend) end
+      
+      # Retrieve the version information about the backend implementation.
+      # @param backend [String]  The name of the backend to retrieve the version information for, can be left unspecified to use the default backend.
+      # @param context [Wx::VersionContext]  The context in which the version information is requested, by default it is the run-time version. Currently only GTK WebKit and CEF backends support returning compile-time version information, all the other backends return an empty {Wx::VersionInfo} object in this case.
+      # @return [Wx::VersionInfo]
+      def self.get_backend_version_info(backend=Wx::WEB_VIEW_BACKEND_DEFAULT, context=VersionContext::RunTime) end
+      
+      # Create a new {Wx::WEB::WebViewConfiguration} object.
+      # @param backend [String] 
+      # @return [Wx::WEB::WebViewConfiguration]
+      def self.new_configuration(backend=Wx::WEB_VIEW_BACKEND_DEFAULT) end
+      
+    end # WebView
+    
+    # A simple class that contains the URL and title of an element of the history of a {Wx::WEB::WebView}.
+    # 
+    # Category:  {Wx::WEB::WebView}
+    # @see Wx::WEB::WebView 
+    # 
+    # 
+    # 
+    # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+    # @wxrb_require USE_WEBVIEW
+    class WebViewHistoryItem < ::Object
+    
+      # Constructor.
+      # @param url [String] 
+      # @param title [String] 
+      # @return [Wx::WEB::WebViewHistoryItem]
+      def initialize(url, title) end
+      
+      # 
+      # 
+      # The url of the page.
+      # @return [String]
+      def get_url; end
+      alias_method :url, :get_url
+      
+      # 
+      # 
+      # The title of the page.
+      # @return [String]
+      def get_title; end
+      alias_method :title, :get_title
+      
+    end # WebViewHistoryItem
+    
+    # This class allows access to web view configuration options and settings, that have to be specified before placing a webview in a window with {Wx::WEB::WebView#create}.
+    # 
+    # Category:  {Wx::WEB::WebView}
+    # @see Wx::WEB::WebView.new_configuration 
+    # 
+    # 
+    # @wxrb_require USE_WEBVIEW
+    class WebViewConfiguration < ::Object
+    
+      # Returns the backend identifier for which this configuration was created.
+      # @return [String]
+      def get_backend; end
+      alias_method :backend, :get_backend
+      
+      # Set the data path for the webview.
+      # 
+      # This is the path where the webview stores its data, such as cookies, local storage, etc. 
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>This is used by Edge, WebKit2GTK+ and Chromium backends (the latter creates "UserData" subdirectory under the given path). 
+      # </p>
+      # </div>
+      # @param path [String]  The path to the data directory.
+      # @return [void]
+      def set_data_path(path) end
+      alias_method :data_path=, :set_data_path
+      
+      # Returns the data path for the webview.
+      # 
+      # This is the path where the webview stores its data, such as cookies, local storage, etc. The path to the data directory.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>This is used by Edge, WebKit2GTK+ and Chromium backends and always returns empty string for the other ones. 
+      # </p>
+      # </div>
+      # @return [String]
+      def get_data_path; end
+      alias_method :data_path, :get_data_path
+      
+      # Allows to disable persistent storage for the webview.
+      # 
+      # The default is to enable it. When the webview is created without persistent storage the data is stored in memory and is lost when the webview is destroyed. In browsers this is equivalent to "private browsing" or "incognito mode".
+      # true if the backend supports to modify this setting. false if the setting is not supported by the backend.
+      # 
+      # <div class="wxrb-note">
+      # <b>Note:</b>
+      # <p>This is only implemented on the Edge, WebKit2GTK+ and macOS backends.
+      # </p>
+      # </div>
+      # @param enable [Boolean] 
+      # @return [Boolean]
+      def enable_persistent_storage(enable) end
+      
+      
+      protected
+      
+    end # WebViewConfiguration
+    
+
+  end
+
+end