Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-31 13:20:59 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWebView/ViewImplementation.h

323 lines
14 KiB
C
Raw Normal View History

LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 14:32:17 +02:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 13:19:50 +02:00
* Copyright (c) 2022, Andreas Kling <andreas@ladybird.org>
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 20:22:14 +00:00
* Copyright (c) 2023, Linus Groh <linusg@serenityos.org>
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 14:32:17 +02:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Forward.h>
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 12:37:31 -04:00
#include <AK/Function.h>
LibWebView: Parse inspector-related JSON strings sooner We currently receive serialized JSON values over IPC and forward them to them WebView callbacks, leaving it to the implementations of those callbacks to parse the strings as JSON objects. This patch hoists that parsing up to WebContentClient as soon as the IPC message is received. This is to reduce the work needed for secondary implementations of these callbacks (i.e. our Firefox DevTools server).
2025-02-21 12:39:43 -05:00
#include <AK/JsonObject.h>
LibWebView: Log the result of taking screenshots to Inspector's console It probably isn't obvious that screenshots are saved to the user's Downloads folder, so add a console message to inform them.
2023-12-09 16:57:57 -05:00
#include <AK/LexicalPath.h>
LibWeb+LibWebView: Migrate Browser's input event handling to LibWebView The Serenity chrome is the only chrome thus far that sends all input key and mouse events to WebContent, including shortcut activations. This is necessary for all chromes - we must give web pages a chance to intercept input events before handling them ourselves. To make this easier for other chromes, this patch moves Serenity's input event handling to LibWebView. To do so, we add the Web::InputEvent type, which models the event data we need within LibWeb. Chromes will then be responsible for converting between this type and their native events. This class lives in LibWeb (rather than LibWebView) because the plan is to use it wholesale throughout the Page's event handler and across IPC. Right now, we still send the individual fields of the event over IPC, but it will be an easy refactor to send the event itself. We just can't do this until all chromes have been ported to this event queueing. Also note that we now only handle key input events back in the chrome. WebContent handles all mouse events that it possibly can. If it was not able to handle a mouse event, there's nothing for the chrome to do (i.e. there is no clicking, scrolling, etc. the chrome is able to do if the WebContent couldn't).
2024-03-03 22:07:49 -05:00
#include <AK/Queue.h>
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 20:22:14 +00:00
#include <AK/String.h>
LibWeb+LibWebView+WebContent+UI: Port the document title to UTF-16
2025-07-28 16:51:01 -04:00
#include <AK/Utf16String.h>
Everywhere: Use IOSurface as backing store on macOS Using mmap-allocated memory for backing stores does not allow us to benefit from using GPU-accelerated painting, because all the performance increase we get is mostly negated by reading the GPU-allocated texture back into RAM, so it can be shared with the browser process. With IOSurface, we get a framebuffer that is both shareable between processes and can be used as underlying memory for an OpenGL/Metal texture. This change does not yet benefit from using IOSurface and merely wraps them into Gfx::Bitmap to be used by the CPU painter.
2024-06-20 21:34:51 +03:00
#include <LibCore/Forward.h>
Ladybird+LibWebView+WebContent: Make the screenshot IPCs async These IPCs are different than other IPCs in that we can't just set up a callback function to be invoked when WebContent sends us the screenshot data. There are multiple places that would set that callback, and they would step on each other's toes. Instead, the screenshot APIs on ViewImplementation now return a Promise which callers can interact with to receive the screenshot (or an error).
2023-12-31 09:51:02 -05:00
#include <LibCore/Promise.h>
LibGfx: Add ImageCursor type and Cursor variant Besides standard cursors, we also need to support custom images. For now, everything still uses StandardCursor.
2025-02-17 15:49:05 +00:00
#include <LibGfx/Cursor.h>
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 14:32:17 +02:00
#include <LibGfx/Forward.h>
#include <LibWeb/Forward.h>
WebContent+Everywhere: Add an option to not activate new tabs over IPC WebDriver, for example, will want to create new tabs without activating them.
2023-03-20 18:39:20 -04:00
#include <LibWeb/HTML/ActivateTab.h>
LibWeb+LibWebView+WebContent: Inform chromes when audio is played/paused Most browsers have some indicator when audio is playing in a tab, which makes it easier to find that tab and mute unwanted audio. This adds an IPC to allow the Ladybird chromes to do something similar.
2024-03-26 19:27:06 -04:00
#include <LibWeb/HTML/AudioPlayState.h>
LibWeb: Allow input color to give continuous updates
2023-12-11 06:53:10 +01:00
#include <LibWeb/HTML/ColorPickerUpdateState.h>
Ladybird+LibWeb+WebContent: Parse the <input type=file> accept attribute This parses the accept attribute value for file input types and passes it along to the browser chromes.
2024-03-14 12:26:00 -04:00
#include <LibWeb/HTML/FileFilter.h>
Ladybird+LibWeb: Add basic select element support
2023-12-07 15:53:49 +01:00
#include <LibWeb/HTML/SelectItem.h>
LibWeb+LibWebView+WebContent: Return a named enum from UI event handlers UI event handlers currently return a boolean where false means the event was cancelled by a script on the page, or otherwise dropped. It has been a point of confusion for some time now, as it's not particularly clear what should be returned in some special cases, or how the UI process should handle the response. This adds an enumeration with a few states that indicate exactly how the WebContent process handled the event. This should remove all ambiguity, and let us properly handle these states going forward. There should be no behavior change with this patch. It's meant to only introduce the enum, not change any of our decisions based on the result.
2024-09-12 12:56:31 -04:00
#include <LibWeb/Page/EventResult.h>
LibWeb+LibWebView: Migrate Browser's input event handling to LibWebView The Serenity chrome is the only chrome thus far that sends all input key and mouse events to WebContent, including shortcut activations. This is necessary for all chromes - we must give web pages a chance to intercept input events before handling them ourselves. To make this easier for other chromes, this patch moves Serenity's input event handling to LibWebView. To do so, we add the Web::InputEvent type, which models the event data we need within LibWeb. Chromes will then be responsible for converting between this type and their native events. This class lives in LibWeb (rather than LibWebView) because the plan is to use it wholesale throughout the Page's event handler and across IPC. Right now, we still send the individual fields of the event over IPC, but it will be an easy refactor to send the event itself. We just can't do this until all chromes have been ported to this event queueing. Also note that we now only handle key input events back in the chrome. WebContent handles all mouse events that it possibly can. If it was not able to handle a mouse event, there's nothing for the chrome to do (i.e. there is no clicking, scrolling, etc. the chrome is able to do if the WebContent couldn't).
2024-03-03 22:07:49 -05:00
#include <LibWeb/Page/InputEvent.h>
LibDevTools+LibWebView+WebContent: Selectively fetch DOM node properties When we inspect a DOM node, we currently serialize many properties for that node, including its layout, computed style, used fonts, etc. Now that we aren't piggy-backing on the Inspector interface, we can instead only serialize the specific information required by DevTools.
2025-03-19 15:50:56 -04:00
#include <LibWebView/DOMNodeProperties.h>
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 14:32:17 +02:00
#include <LibWebView/Forward.h>
LibWebView+WebContent+headless-browser: Make the page info IPCs async The IPCs to request a page's text, layout tree, etc. are currently all synchronous. This can result in a deadlock when WebContent also makes a synchronous IPC call, as both ends will be waiting on each other. This replaces the page info IPCs with a single, asynchronous IPC. This new IPC is promise-based, much like our screenshot IPC.
2024-09-19 10:40:00 -04:00
#include <LibWebView/PageInfo.h>
LibWebView+WebContent+UI: Migrate to the new autoplay settings This removes the old autoplay allowlist file in favor of the new site setting. We still support the command-line flag to enable autoplay globally, as this is needed for WPT.
2025-03-29 08:19:00 -04:00
#include <LibWebView/Settings.h>
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 19:27:17 +00:00
#include <LibWebView/WebContentClient.h>
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 14:32:17 +02:00
namespace WebView {
LibWebView: Enable EXPLICIT_SYMBOL_EXPORT
2025-07-01 20:55:11 -07:00
class WEBVIEW_API ViewImplementation : public SettingsObserver {
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 14:32:17 +02:00
public:
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 18:00:48 -07:00
virtual ~ViewImplementation();
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 14:32:17 +02:00
LibWebView: Add simple ID tracking to WebViews For Firefox DevTools, we will need to track WebViews by a numerical ID. Here, we just increment a static 64-bit counter. We can switch to using IDAllocator if we ever have an issue with this. This patch adds such an ID to the views and a couple of APIs to access WebViews after creation.
2025-02-15 08:06:36 -05:00
static void for_each_view(Function<IterationDecision(ViewImplementation&)>);
static Optional<ViewImplementation&> find_view_by_id(u64);
u64 view_id() const { return m_view_id; }
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 16:22:27 +13:00
void set_url(Badge<WebContentClient>, URL::URL url) { m_url = move(url); }
URL::URL const& url() const { return m_url; }
LibWebView+Ladybird: Move page loading to ViewImplementation
2023-01-12 20:30:06 +00:00
LibWeb+LibWebView+WebContent+UI: Port the document title to UTF-16
2025-07-28 16:51:01 -04:00
void set_title(Badge<WebContentClient>, Utf16String title) { m_title = move(title); }
Utf16String const& title() const { return m_title; }
LibWebView: Store the tab title on the ViewImplementation This will be needed for DevTools, to avoid the need to go into the UI layer for this information.
2025-02-17 06:43:06 -05:00
LibWebView: Add window handle in `ClientState` in `ViewImplementation` Add field for a handle that is going to be used by WebDriver to identify top-level browsing contexts. It is supposed to be populated by WebContent client during creation. Co-authored-by: Timothy Flynn <trflynn89@pm.me>
2023-03-16 18:24:30 +03:00
String const& handle() const { return m_client_state.client_handle; }
LibWeb+LibWebView+WebContent: Begin implementing simple site islotation Site isolation is a common technique to reduce the chance that malicious sites can access data from other sites. When the user navigates, we now check if the target site is the same as the current site. If not, we instruct the UI to perform the navigation in a new WebContent process. The phrase "site" here is defined as the public suffix of the URL plus one level. This means that navigating from "www.example.com" to "sub.example.com" remains in the same process. There's plenty of room for optimization around this. For example, we can create a spare WebContent process ahead of time to hot-swap the target site. We can also create a policy to keep the navigated-from process around, in case the user quickly navigates back.
2025-03-09 11:40:34 -04:00
void create_new_process_for_cross_site_navigation(URL::URL const&);
Ladybird+LibWebView: Move most of paint handling to LibWebView Storing the backup bitmap is the same across Browser and Ladybird. Just peform that work in LibWebView, and handle only the implementation- specific nuances within the browsers.
2023-05-20 10:50:05 -04:00
void server_did_paint(Badge<WebContentClient>, i32 bitmap_id, Gfx::IntSize size);
UI/AppKit: Inform WebContent of the UI window position/size This is required for APIs like window.screenX, as well as for WebDriver and WPT.
2024-10-28 07:48:49 -04:00
void set_window_position(Gfx::IntPoint);
void set_window_size(Gfx::IntSize);
LibWeb+WebContent+WebDriver+UI: Make window rect updates asynchronous It's currently possible for window size/position updates to hang, as the underlying IPCs are synchronous. This updates the WebDriver endpoint to be async, to unblock the WebContent process while the update is ongoing. The UI process is now responsible for informing WebContent when the update is complete.
2024-10-28 23:37:11 -04:00
void did_update_window_rect();
UI/AppKit: Inform WebContent of the UI window position/size This is required for APIs like window.screenX, as well as for WebDriver and WPT.
2024-10-28 07:48:49 -04:00
LibWebView+WebContent+UI: Remember the current system visibility state We will want to re-inform WebContent of the system visibility state when we create a new process after a crash. This changes the IPC to just send the enum value directly, instead of a boolean, so that we can just store that enum value directly on the ViewImplementation class.
2024-11-13 11:24:16 -05:00
void set_system_visibility_state(Web::HTML::VisibilityState);
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 16:22:27 +13:00
void load(URL::URL const&);
Userland+Ladybird: Always specify url to be about:srcdoc in load_html() After moving to navigables, we started reusing the code that populates session history entries with the srcdoc attribute value from iframes in `Page::load_html()` for loading HTML. This change addresses a crash in `determine_the_origin` which occurred because this method expected the URL to be `about:srcdoc` if we also provided HTML content (previously, it was the URL passed along with the HTML content into `load_html()`).
2023-09-17 17:12:17 +02:00
void load_html(StringView);
LibWebView+Ladybird: Move page loading to ViewImplementation
2023-01-12 20:30:06 +00:00
void load_empty_document();
LibWeb+LibWebView+WebContent: Add an IPC call for Navigable::reload()
2024-04-13 18:51:27 +02:00
void reload();
LibWeb+LibWebView+WebContent: Add traverse_history_by_delta() IPC call
2024-04-13 22:33:48 +02:00
void traverse_the_history_by_delta(int delta);
LibWebView+Ladybird: Move page loading to ViewImplementation
2023-01-12 20:30:06 +00:00
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 19:49:49 +00:00
void zoom_in();
void zoom_out();
LibWeb+UI: Add internals API to set browser zoom
2024-12-23 22:15:06 +01:00
void set_zoom(double zoom_level);
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 19:49:49 +00:00
void reset_zoom();
LibWebView: Expose getter for current zoom level
2023-03-26 19:41:56 +01:00
float zoom_level() const { return m_zoom_level; }
Ladybird/Qt: Open context menus at requested position
2023-12-12 22:33:36 +01:00
float device_pixel_ratio() const { return m_device_pixel_ratio; }
LibWebView+WebContent: Make it possible to change the painting interval This allows us to paint at the refresh rate of the screen. The default is 60, as before, in case it never gets set by anything.
2025-07-25 13:10:00 +01:00
double maximum_frames_per_second() const { return m_maximum_frames_per_second; }
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 20:22:14 +00:00
LibWeb+LibWebView: Migrate Browser's input event handling to LibWebView The Serenity chrome is the only chrome thus far that sends all input key and mouse events to WebContent, including shortcut activations. This is necessary for all chromes - we must give web pages a chance to intercept input events before handling them ourselves. To make this easier for other chromes, this patch moves Serenity's input event handling to LibWebView. To do so, we add the Web::InputEvent type, which models the event data we need within LibWeb. Chromes will then be responsible for converting between this type and their native events. This class lives in LibWeb (rather than LibWebView) because the plan is to use it wholesale throughout the Page's event handler and across IPC. Right now, we still send the individual fields of the event over IPC, but it will be an easy refactor to send the event itself. We just can't do this until all chromes have been ported to this event queueing. Also note that we now only handle key input events back in the chrome. WebContent handles all mouse events that it possibly can. If it was not able to handle a mouse event, there's nothing for the chrome to do (i.e. there is no clicking, scrolling, etc. the chrome is able to do if the WebContent couldn't).
2024-03-03 22:07:49 -05:00
void enqueue_input_event(Web::InputEvent);
LibWeb+LibWebView+WebContent: Return a named enum from UI event handlers UI event handlers currently return a boolean where false means the event was cancelled by a script on the page, or otherwise dropped. It has been a point of confusion for some time now, as it's not particularly clear what should be returned in some special cases, or how the UI process should handle the response. This adds an enumeration with a few states that indicate exactly how the WebContent process handled the event. This should remove all ambiguity, and let us properly handle these states going forward. There should be no behavior change with this patch. It's meant to only introduce the enum, not change any of our decisions based on the result.
2024-09-12 12:56:31 -04:00
void did_finish_handling_input_event(Badge<WebContentClient>, Web::EventResult event_result);
LibWeb+LibWebView: Migrate Browser's input event handling to LibWebView The Serenity chrome is the only chrome thus far that sends all input key and mouse events to WebContent, including shortcut activations. This is necessary for all chromes - we must give web pages a chance to intercept input events before handling them ourselves. To make this easier for other chromes, this patch moves Serenity's input event handling to LibWebView. To do so, we add the Web::InputEvent type, which models the event data we need within LibWeb. Chromes will then be responsible for converting between this type and their native events. This class lives in LibWeb (rather than LibWebView) because the plan is to use it wholesale throughout the Page's event handler and across IPC. Right now, we still send the individual fields of the event over IPC, but it will be an easy refactor to send the event itself. We just can't do this until all chromes have been ported to this event queueing. Also note that we now only handle key input events back in the chrome. WebContent handles all mouse events that it possibly can. If it was not able to handle a mouse event, there's nothing for the chrome to do (i.e. there is no clicking, scrolling, etc. the chrome is able to do if the WebContent couldn't).
2024-03-03 22:07:49 -05:00
LibWebView+Ladybird: Move preferred color scheme to ViewImplementation
2023-01-12 20:44:42 +00:00
void set_preferred_color_scheme(Web::CSS::PreferredColorScheme);
LibWeb: Add Contrast preference
2024-06-13 01:03:56 +02:00
void set_preferred_contrast(Web::CSS::PreferredContrast);
LibWeb: Add motion preference This adds a motion preference to the browser UI similar to the existing ones for color scheme and contrast. Both AppKit UI and Qt UI has this new preference. The auto value is currently the same as NoPreference, follow-ups can address wiring that up to the actual preference for the OS.
2024-06-13 16:15:59 +02:00
void set_preferred_motion(Web::CSS::PreferredMotion);
LibWeb: Support sending DNT header with requests
2024-07-02 20:29:43 +01:00
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
ByteString selected_text();
LibWebView: Add a helper to get selected text with collapsed whitespace
2023-10-23 16:52:57 -04:00
Optional<String> selected_text_with_whitespace_collapsed();
LibWebView+Ladybird: Move text selection to ViewImplementation
2023-01-12 20:42:42 +00:00
void select_all();
LibWeb+LibWebView+WebContent: Support case-insensitive find-in-page This allows searching for text with case-insensitivity. As this is probably what most users expect, the default behavior is changes to perform case-insensitive lookups. Chromes may add UI to change the behavior as they see fit.
2024-05-31 16:01:34 -04:00
void find_in_page(String const& query, CaseSensitivity = CaseSensitivity::CaseInsensitive);
LibWeb+LibWebView+WebContent: Add basic find in page functionality This allows the browser to send a query to the WebContent process, which will search the page for the given string and highlight any occurrences of that string.
2024-05-29 20:09:33 +01:00
void find_in_page_next_match();
void find_in_page_previous_match();
LibWeb+WebContent+Ladybird: Add ability to paste text from clipboard Text can be pasted by pressing Ctrl/Cmd+V or by using button in the context menu. For now only the Qt client is supported.
2024-03-22 11:56:49 +01:00
void paste(String const&);
LibWebView+Ladybird: Move text selection to ViewImplementation
2023-01-12 20:42:42 +00:00
LibWebView+Ladybird: Move get source request to ViewImplementation
2023-01-12 19:58:00 +00:00
void get_source();
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 19:49:49 +00:00
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 20:22:14 +00:00
void inspect_dom_tree();
void inspect_accessibility_tree();
LibWebView+WebContent: Make the hovered node retrieval IPC async
2023-12-30 09:42:24 -05:00
void get_hovered_node_id();
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 20:22:14 +00:00
LibWeb/CSS: Move and rename PseudoElement types to prep for code gen The upcoming generated types will match those for pseudo-classes: A PseudoElementSelector type, that then holds a PseudoElement enum defining what it is. That enum will be at the top level in the Web::CSS namespace. In order to keep the diffs clearer, this commit renames and moves the types, and then a following one will replace the handwritten enum with a generated one.
2025-03-20 16:56:46 +00:00
void inspect_dom_node(Web::UniqueNodeID node_id, DOMNodeProperties::Type, Optional<Web::CSS::PseudoElement> pseudo_element);
LibWeb+LibWebView+WebContent: Support both inspecting/highlighting nodes Our own Inspector differs from most other DevTools implementations with regard to highlighting DOM nodes as you hover elements in the inspected DOM tree. In other implementations, as you change the hovered node, the browser will render a box model overlay onto the page for that node. We currently don't do this; we wait until you click the node, at which point we both paint the overlay and inspect the node's properties. This patch does not change that behavior, but separates the IPCs and internal tracking of inspected nodes to support the standard DevTools behavior. So the DOM document now stores an inspected node and a highlighted node. The former is used for features such as "$0" in the JavaScript console, and the latter is used for the box model overlay. Our Inspector continues to set these to the same node.
2025-02-21 09:34:02 -05:00
void clear_inspected_dom_node();
LibWeb/CSS: Move and rename PseudoElement types to prep for code gen The upcoming generated types will match those for pseudo-classes: A PseudoElementSelector type, that then holds a PseudoElement enum defining what it is. That enum will be at the top level in the Web::CSS namespace. In order to keep the diffs clearer, this commit renames and moves the types, and then a following one will replace the handwritten enum with a generated one.
2025-03-20 16:56:46 +00:00
void highlight_dom_node(Web::UniqueNodeID node_id, Optional<Web::CSS::PseudoElement> pseudo_element);
LibWeb+LibWebView+WebContent: Support both inspecting/highlighting nodes Our own Inspector differs from most other DevTools implementations with regard to highlighting DOM nodes as you hover elements in the inspected DOM tree. In other implementations, as you change the hovered node, the browser will render a box model overlay onto the page for that node. We currently don't do this; we wait until you click the node, at which point we both paint the overlay and inspect the node's properties. This patch does not change that behavior, but separates the IPCs and internal tracking of inspected nodes to support the standard DevTools behavior. So the DOM document now stores an inspected node and a highlighted node. The former is used for features such as "$0" in the JavaScript console, and the latter is used for the box model overlay. Our Inspector continues to set these to the same node.
2025-02-21 09:34:02 -05:00
void clear_highlighted_dom_node();
LibWeb+LibWebView+WebContent: Inform the UI about DOM mutations This will allow our DevTools server to inform the Firefox DevTools client about DOM mutations.
2025-03-06 17:32:43 -05:00
void set_listen_for_dom_mutations(bool);
LibDevTools+LibWebView+WebContent: Implement getting DOM node inner HTML This is used by DevTools to copy the inner HTML to the clipboard.
2025-03-10 18:15:31 -04:00
void get_dom_node_inner_html(Web::UniqueNodeID node_id);
LibDevTools+LibWebView+WebContent: Implement editing DOM node HTML These commands are used for the "Edit As HTML" feature in DevTools. This renames our existing HTML getter IPC to indicate that it is for outer HTML. DevTools will need a separate inner HTML getter.
2025-03-10 17:36:41 -04:00
void get_dom_node_outer_html(Web::UniqueNodeID node_id);
void set_dom_node_outer_html(Web::UniqueNodeID node_id, String const& html);
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 11:00:03 -05:00
void set_dom_node_text(Web::UniqueNodeID node_id, String const& text);
void set_dom_node_tag(Web::UniqueNodeID node_id, String const& name);
void add_dom_node_attributes(Web::UniqueNodeID node_id, ReadonlySpan<Attribute> attributes);
void replace_dom_node_attribute(Web::UniqueNodeID node_id, String const& name, ReadonlySpan<Attribute> replacement_attributes);
LibWeb: Make DOM Node unique IDs strongly typed (and 64 bit) This is strictly nicer than passing them around as i32 everywhere, and by switching to i64 as the underlying type, ID allocation becomes as simple as incrementing an integer.
2024-10-20 10:37:44 +02:00
void create_child_element(Web::UniqueNodeID node_id);
void create_child_text_node(Web::UniqueNodeID node_id);
LibDevTools+LibWebView+WebContent: Implement moving DOM nodes This allows for click-and-dragging DOM nodes in DevTools to move them.
2025-03-10 18:01:29 -04:00
void insert_dom_node_before(Web::UniqueNodeID node_id, Web::UniqueNodeID parent_node_id, Optional<Web::UniqueNodeID> sibling_node_id);
LibWeb: Make DOM Node unique IDs strongly typed (and 64 bit) This is strictly nicer than passing them around as i32 everywhere, and by switching to i64 as the underlying type, ID allocation becomes as simple as incrementing an integer.
2024-10-20 10:37:44 +02:00
void clone_dom_node(Web::UniqueNodeID node_id);
void remove_dom_node(Web::UniqueNodeID node_id);
LibWebView+WebContent: Add APIs to manipulate DOM nodes This adds APIs to allow Ispector clients to: * Change a DOM text or comment node's text data. * Add, replace, or remove a DOM element's attribute. * Change a DOM element's tag.
2023-11-19 10:42:11 -05:00
Inspector: Add a basic style sheet inspector Choosing options from the `<select>` will load and display that style sheet's source text, with some checks to make sure that the text that just loaded is the one we currently want. The UI is a little goofy when scrolling, as it uses `position: sticky` which we don't implement yet. But that's just more motivation to implement it! :^)
2024-08-23 11:18:35 +01:00
void list_style_sheets();
void request_style_sheet_source(Web::CSS::StyleSheetIdentifier const&);
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
void debug_request(ByteString const& request, ByteString const& argument = {});
LibWebView+Ladybird: Move debug request to ViewImplementation
2023-01-12 20:34:08 +00:00
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 11:00:03 -05:00
void run_javascript(String const&);
void js_console_input(String const&);
Ladybird: Move ownership of the JS console/inspector to the tab object This is to match Browser, where ownership of all "subwidgets" is placed on the tab as well. This further lets us align the web view callbacks to match Browser's OOPWV as well, which will later let us move them into the base LibWebView class.
2023-05-17 11:54:36 -04:00
void js_console_request_messages(i32 start_index);
LibWebView+Ladybird: Move running JavaScript to ViewImplementation
2023-01-12 20:39:08 +00:00
Ladybird+LibWebView: Migrate dialog APIs to LibWebView callbacks
2023-05-17 14:23:34 -04:00
void alert_closed();
void confirm_closed(bool accepted);
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 11:00:03 -05:00
void prompt_closed(Optional<String> const& response);
LibWeb: Allow input color to give continuous updates
2023-12-11 06:53:10 +01:00
void color_picker_update(Optional<Color> picked_color, Web::HTML::ColorPickerUpdateState state);
LibWeb+LibWebView+WebContent: Implement more <input type=file> behavior We had previous implemented some plumbing for file input elements in commit 636602a54e55945f7394805975a69dc40934331c. This implements the return path for chromes to inform WebContent of the file(s) the user selected. This patch includes a dummy implementation for headless-browser to enable testing.
2024-02-25 13:02:47 -05:00
void file_picker_closed(Vector<Web::HTML::SelectedFile> selected_files);
LibWeb: Refactor SelectItem to allow selecting options without value Currently the `<select>` dropdown IPC uses the option value attr to find which option is selected. This won't work when options don't have values or when multiple options have the same value. Also the `SelectItem` contained so weird recursive structures that are impossible to create with HTML. So I refactored `SelectItem` as a variant, and gave the options a unique id. The id is send back to `HTMLSelectElement` so it can find out exactly which option element is selected.
2024-04-03 19:19:08 +02:00
void select_dropdown_closed(Optional<u32> const& selected_item_id);
Ladybird+LibWebView: Migrate dialog APIs to LibWebView callbacks
2023-05-17 14:23:34 -04:00
LibWeb+LibWebVew+WebContent+UI: Add IPC to retrieve the system clipboard We currently have a single IPC to set clipboard data. We will also need an IPC to retrieve that data from the UI. This defines system clipboard data in LibWeb to handle this transfer, and adds the IPC to provide it.
2025-05-01 11:38:31 -04:00
void retrieved_clipboard_entries(u64 request_id, ReadonlySpan<Web::Clipboard::SystemClipboardItem>);
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 10:51:38 -04:00
void toggle_media_play_state();
Ladybird+LibWeb+WebContent: Add context menu controls for muting audio
2023-06-16 11:29:54 -04:00
void toggle_media_mute_state();
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 10:51:38 -04:00
void toggle_media_loop_state();
void toggle_media_controls_state();
LibWeb+WebContent: Add APIs to control video playback state This allows for the browser process to control the play/pause state, whether we paint user agent controls on the video, and whether the video loops when it finishes playing.
2023-05-15 11:17:58 -04:00
LibWeb+LibWebView+WebContent: Support muting an entire page This adds an IPC for chromes to mute a tab. When muted, we trigger an internal volume change notification and indicate that the user agent has overriden the media volume.
2024-03-30 09:41:15 -04:00
Web::HTML::MuteState page_mute_state() const { return m_mute_state; }
void toggle_page_mute_state();
LibWeb+LibWebView+WebContent: Inform chromes when audio is played/paused Most browsers have some indicator when audio is playing in a tab, which makes it easier to find that tab and mute unwanted audio. This adds an IPC to allow the Ladybird chromes to do something similar.
2024-03-26 19:27:06 -04:00
void did_change_audio_play_state(Badge<WebContentClient>, Web::HTML::AudioPlayState);
Web::HTML::AudioPlayState audio_play_state() const { return m_audio_play_state; }
LibWeb+LibWebView+WebContent: Add did_update_navigation_buttons_state() It is going to be used to communicate whether it is possible to navigate back or forward after session history stored on browser side will no longer be used to driver navigation.
2024-04-13 23:12:55 +02:00
void did_update_navigation_buttons_state(Badge<WebContentClient>, bool back_enabled, bool forward_enabled) const;
LibWebView+WebContent: Move backing store allocation into WebContent In the upcoming changes, we are going to switch macOS to using an IOSurface for the backing store. This change will simplify the process of sharing an IOSurface between processes because we already have the MachPortServer running in the browser, and WebContent knows how to locate the corresponding server.
2024-06-17 18:50:57 +03:00
void did_allocate_backing_stores(Badge<WebContentClient>, i32 front_bitmap_id, Gfx::ShareableBitmap const&, i32 back_bitmap_id, Gfx::ShareableBitmap const&);
Everywhere: Use IOSurface as backing store on macOS Using mmap-allocated memory for backing stores does not allow us to benefit from using GPU-accelerated painting, because all the performance increase we get is mostly negated by reading the GPU-allocated texture back into RAM, so it can be shared with the browser process. With IOSurface, we get a framebuffer that is both shareable between processes and can be used as underlying memory for an OpenGL/Metal texture. This change does not yet benefit from using IOSurface and merely wraps them into Gfx::Bitmap to be used by the CPU painter.
2024-06-20 21:34:51 +03:00
#ifdef AK_OS_MACOS
void did_allocate_iosurface_backing_stores(i32 front_bitmap_id, Core::MachPort&&, i32 back_bitmap_id, Core::MachPort&&);
#endif
LibWebView+WebContent: Move backing store allocation into WebContent In the upcoming changes, we are going to switch macOS to using an IOSurface for the backing store. This change will simplify the process of sharing an IOSurface between processes because we already have the MachPortServer running in the browser, and WebContent knows how to locate the corresponding server.
2024-06-17 18:50:57 +03:00
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 09:53:13 -04:00
enum class ScreenshotType {
Visible,
Full,
};
Ladybird+LibWebView+WebContent: Make the screenshot IPCs async These IPCs are different than other IPCs in that we can't just set up a callback function to be invoked when WebContent sends us the screenshot data. There are multiple places that would set that callback, and they would step on each other's toes. Instead, the screenshot APIs on ViewImplementation now return a Promise which callers can interact with to receive the screenshot (or an error).
2023-12-31 09:51:02 -05:00
NonnullRefPtr<Core::Promise<LexicalPath>> take_screenshot(ScreenshotType);
LibWeb: Make DOM Node unique IDs strongly typed (and 64 bit) This is strictly nicer than passing them around as i32 everywhere, and by switching to i64 as the underlying type, ID allocation becomes as simple as incrementing an integer.
2024-10-20 10:37:44 +02:00
NonnullRefPtr<Core::Promise<LexicalPath>> take_dom_node_screenshot(Web::UniqueNodeID);
Ladybird+LibWebView+WebContent: Make the screenshot IPCs async These IPCs are different than other IPCs in that we can't just set up a callback function to be invoked when WebContent sends us the screenshot data. There are multiple places that would set that callback, and they would step on each other's toes. Instead, the screenshot APIs on ViewImplementation now return a Promise which callers can interact with to receive the screenshot (or an error).
2023-12-31 09:51:02 -05:00
virtual void did_receive_screenshot(Badge<WebContentClient>, Gfx::ShareableBitmap const&);
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 09:53:13 -04:00
LibWebView+WebContent+headless-browser: Make the page info IPCs async The IPCs to request a page's text, layout tree, etc. are currently all synchronous. This can result in a deadlock when WebContent also makes a synchronous IPC call, as both ends will be waiting on each other. This replaces the page info IPCs with a single, asynchronous IPC. This new IPC is promise-based, much like our screenshot IPC.
2024-09-19 10:40:00 -04:00
NonnullRefPtr<Core::Promise<String>> request_internal_page_info(PageInfoType);
void did_receive_internal_page_info(Badge<WebContentClient>, PageInfoType, String const&);
LibJS+LibWebView+WebContent+Ladybird: Output GC-graph into a file Instead of displaying a massive JSON in stdout, it's more practical to save the GC-graph to a file.
2023-12-12 13:25:06 +01:00
ErrorOr<LexicalPath> dump_gc_graph();
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 11:00:03 -05:00
void set_user_style_sheet(String const& source);
LibWebView: Allow using native/user style sheets on Lagom Move the methods to set the native/user style sheets to the base ViewImplementation class. We must also generate the native style sheet explicitly for now, as LibWebView on Lagom isn't able to include the main LibWebView CMakeLists.txt file yet.
2023-08-26 13:34:59 -04:00
// Load Native.css as the User style sheet, which attempts to make WebView content look as close to
// native GUI widgets as possible.
void use_native_user_style_sheet();
Ladybird+LibWebView: Move most of paint handling to LibWebView Storing the backup bitmap is the same across Browser and Ladybird. Just peform that work in LibWebView, and handle only the implementation- specific nuances within the browsers.
2023-05-20 10:50:05 -04:00
Function<void()> on_ready_to_paint;
Ladybird: Add IPC call for creating a new child tab This will be used for choosing a navigable that requires opening a new tab or new window. Such as calls to window.open(), or specific WebDriver calls.
2024-01-30 20:05:00 -07:00
Function<String(Web::HTML::ActivateTab, Web::HTML::WebViewHints, Optional<u64>)> on_new_web_view;
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 12:37:31 -04:00
Function<void()> on_activate_tab;
Function<void()> on_close;
Function<void(Gfx::IntPoint screen_position)> on_context_menu_request;
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-28 22:02:55 -04:00
Function<void(URL::URL const&, Gfx::IntPoint screen_position)> on_link_context_menu_request;
UI: Prevent crash when right clicking on an unloaded image
2025-01-10 20:33:27 +11:00
Function<void(URL::URL const&, Gfx::IntPoint screen_position, Optional<Gfx::ShareableBitmap> const&)> on_image_context_menu_request;
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 10:51:38 -04:00
Function<void(Gfx::IntPoint screen_position, Web::Page::MediaContextMenu const&)> on_media_context_menu_request;
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-28 22:02:55 -04:00
Function<void(URL::URL const&)> on_link_hover;
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 12:37:31 -04:00
Function<void()> on_link_unhover;
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-28 22:02:55 -04:00
Function<void(URL::URL const&, ByteString const& target, unsigned modifiers)> on_link_click;
Function<void(URL::URL const&, ByteString const& target, unsigned modifiers)> on_link_middle_click;
LibWeb+LibWebView+WebContent+UI: Port the document title to UTF-16
2025-07-28 16:51:01 -04:00
Function<void(Utf16String const&)> on_title_change;
LibWeb+LibWebView+WebContent: Add did_change_url() IPC call
2024-04-14 10:27:20 +02:00
Function<void(URL::URL const&)> on_url_change;
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-28 22:02:55 -04:00
Function<void(URL::URL const&, bool)> on_load_start;
Function<void(URL::URL const&)> on_load_finish;
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
Function<void(ByteString const& path, i32)> on_request_file;
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 12:37:31 -04:00
Function<void(Gfx::Bitmap const&)> on_favicon_change;
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 12:17:29 +00:00
Function<void(Gfx::Cursor const&)> on_cursor_change;
LibWeb+UI: Add tooltip overriding and use it for <video> tags This call is used to inform the chrome that it should display a tooltip now and avoid any hovering timers. This is used by <video> tags to display the volume percentage when it is changed.
2024-07-02 16:48:57 +02:00
Function<void(Gfx::IntPoint, ByteString const&)> on_request_tooltip_override;
Function<void()> on_stop_tooltip_override;
LibWeb+UI/Qt: Display 'title' tooltips only when the mouse stops moving Now instead of sending the position in which the user entered the tooltip area, send just the text, and let the chrome figure out how to display it. In the case of Qt, wait for 600 milliseconds of no mouse movement, then display it under the mouse cursor.
2024-07-02 14:16:24 +02:00
Function<void(ByteString const&)> on_enter_tooltip_area;
Ladybird+LibWebView: Migrate tooltip changes to LibWebView callbacks
2023-08-23 11:11:39 -04:00
Function<void()> on_leave_tooltip_area;
Ladybird+LibWebView: Migrate dialog APIs to LibWebView callbacks
2023-05-17 14:23:34 -04:00
Function<void(String const& message)> on_request_alert;
Function<void(String const& message)> on_request_confirm;
Function<void(String const& message, String const& default_)> on_request_prompt;
Function<void(String const& message)> on_request_set_prompt_text;
Function<void()> on_request_accept_dialog;
Function<void()> on_request_dismiss_dialog;
LibWebView: Generate hyperlinks for attributes that represent links On the view-source page, generate anchor tags for any 'href' or 'src' attribute value we come across. This handles both when the attribute contains an absolute URL and a URL relative to the page. This requires sending the document's base URL over IPC to resolve relative URLs.
2024-10-18 17:20:15 -04:00
Function<void(URL::URL const&, URL::URL const&, String const&)> on_received_source;
LibWebView: Parse inspector-related JSON strings sooner We currently receive serialized JSON values over IPC and forward them to them WebView callbacks, leaving it to the implementations of those callbacks to parse the strings as JSON objects. This patch hoists that parsing up to WebContentClient as soon as the IPC message is received. This is to reduce the work needed for secondary implementations of these callbacks (i.e. our Firefox DevTools server).
2025-02-21 12:39:43 -05:00
Function<void(JsonObject)> on_received_dom_tree;
Function<void(DOMNodeProperties)> on_received_dom_node_properties;
Function<void(JsonObject)> on_received_accessibility_tree;
LibWeb: Make DOM Node unique IDs strongly typed (and 64 bit) This is strictly nicer than passing them around as i32 everywhere, and by switching to i64 as the underlying type, ID allocation becomes as simple as incrementing an integer.
2024-10-20 10:37:44 +02:00
Function<void(Web::UniqueNodeID)> on_received_hovered_node_id;
LibWeb+LibWebView+WebContent: Inform the UI about DOM mutations This will allow our DevTools server to inform the Firefox DevTools client about DOM mutations.
2025-03-06 17:32:43 -05:00
Function<void(Mutation)> on_dom_mutation_received;
LibWeb: Fix typos - act II
2025-04-07 10:46:22 +00:00
Function<void(Optional<Web::UniqueNodeID> const& node_id)> on_finished_editing_dom_node;
LibDevTools+LibWebView+WebContent: Implement editing DOM node HTML These commands are used for the "Edit As HTML" feature in DevTools. This renames our existing HTML getter IPC to indicate that it is for outer HTML. DevTools will need a separate inner HTML getter.
2025-03-10 17:36:41 -04:00
Function<void(String)> on_received_dom_node_html;
LibWeb+LibWebView+WebContent: Remove the built-in Inspector
2025-03-14 16:22:16 -04:00
Function<void(Vector<Web::CSS::StyleSheetIdentifier>)> on_received_style_sheet_list;
Function<void(Web::CSS::StyleSheetIdentifier const&, URL::URL const&, String const&)> on_received_style_sheet_source;
LibWebView+WebContent: Begin supporting the DevTools JavaScript console This supports evaluating the script and replying with the result. We currently serialize JS objects to a string, but we will need to support dynamic interaction with the objects over IPC. This does not yet support sending console messages to DevTools.
2025-02-24 11:57:33 -05:00
Function<void(JsonValue)> on_received_js_console_result;
LibWebView: Rename a couple of console-related callbacks for clarity The "on_received_console_message" and "on_received_console_messages" were indistinguishable in purpose based on their name. This renames them to: on_console_message_available - WebContent has output a console message and it is available for the client to retrieve. on_received_styled_console_messages - WebContent has replied to a request for the available console messages. The "styled" qualifier is used here to indicate that the messages have been styled with CSS for display in a WebView. This is to prepare for an upcoming patch where DevToolsConsoleClient will not stylize the output; DevTools will want the raw JS values.
2025-03-04 07:56:42 -05:00
Function<void(i32 message_id)> on_console_message_available;
LibWebView+WebContent: Remove "styled" JS console IPC hooks This was used by the built-in Inspector to send HTML-ified JS console messages to the browser. It is no longer used.
2025-03-25 10:11:17 -04:00
Function<void(i32 start_index, Vector<ConsoleOutput>)> on_received_console_messages;
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 12:37:31 -04:00
Function<void(i32 count_waiting)> on_resource_status_change;
Function<void()> on_restore_window;
LibWeb+WebContent+WebDriver+UI: Make window rect updates asynchronous It's currently possible for window size/position updates to hang, as the underlying IPCs are synchronous. This updates the WebDriver endpoint to be async, to unblock the WebContent process while the update is ongoing. The UI process is now responsible for informing WebContent when the update is complete.
2024-10-28 23:37:11 -04:00
Function<void(Gfx::IntPoint)> on_reposition_window;
Function<void(Gfx::IntSize)> on_resize_window;
LibWeb+WebContent+WebDriver+UI: Make window min/maximize asynchronous This follows suit of previous changes to never block the WebContent process in WebDriver endpoints.
2024-10-28 23:45:18 -04:00
Function<void()> on_maximize_window;
Function<void()> on_minimize_window;
Function<void()> on_fullscreen_window;
LibWeb+LibWebView+WebContent: Add support for <input type="color"> This commit introduces 3 things: - Support for the color type in HTMLInputElement itself - A mechanism for handling non event loop blocking dialogs in Page - The associated plumbing up to ViewImplementation Frontends may add support for the color picker with the ViewImplementation.on_request_color_picker function
2023-09-04 11:32:40 +02:00
Function<void(Color current_color)> on_request_color_picker;
Ladybird+LibWeb+WebContent: Parse the <input type=file> accept attribute This parses the accept attribute value for file input types and passes it along to the browser chromes.
2024-03-14 12:26:00 -04:00
Function<void(Web::HTML::FileFilter const& accepted_file_types, Web::HTML::AllowMultipleFiles)> on_request_file_picker;
Ladybird+LibWeb: Add basic select element support
2023-12-07 15:53:49 +01:00
Function<void(Gfx::IntPoint content_position, i32 minimum_width, Vector<Web::HTML::SelectItem> items)> on_request_select_dropdown;
LibWeb+LibWebView: Migrate Browser's input event handling to LibWebView The Serenity chrome is the only chrome thus far that sends all input key and mouse events to WebContent, including shortcut activations. This is necessary for all chromes - we must give web pages a chance to intercept input events before handling them ourselves. To make this easier for other chromes, this patch moves Serenity's input event handling to LibWebView. To do so, we add the Web::InputEvent type, which models the event data we need within LibWeb. Chromes will then be responsible for converting between this type and their native events. This class lives in LibWeb (rather than LibWebView) because the plan is to use it wholesale throughout the Page's event handler and across IPC. Right now, we still send the individual fields of the event over IPC, but it will be an easy refactor to send the event itself. We just can't do this until all chromes have been ported to this event queueing. Also note that we now only handle key input events back in the chrome. WebContent handles all mouse events that it possibly can. If it was not able to handle a mouse event, there's nothing for the chrome to do (i.e. there is no clicking, scrolling, etc. the chrome is able to do if the WebContent couldn't).
2024-03-03 22:07:49 -05:00
Function<void(Web::KeyEvent const&)> on_finish_handling_key_event;
LibWeb+LibWebView+WebContent: Add IPC to send drag-and-drop events This adds the IPC and related hooks to allow the UI to send drag-and- drop events from the UI process to the WebContent process.
2024-08-17 13:36:28 -04:00
Function<void(Web::DragEvent const&)> on_finish_handling_drag_event;
LibWeb: Rename internals.signalTextTestIsDone() to signalTestIsDone() In upcoming change this function will be used for ref-tests as well.
2025-03-18 17:37:32 +01:00
Function<void(String const&)> on_test_finish;
headless-browser: Let tests set their own timeout duration Some tests take longer than others, and so may want to set a custom timeout so that they pass, without increasing the timeout for all other tests. For example, this is done in WPT. Add an `internals.setTestTimeout(milliseconds)` method that overrides the test runner's default timeout for the currently-run test.
2024-12-19 14:16:05 +00:00
Function<void(double milliseconds)> on_set_test_timeout;
Tests: Replace `load-reference-page` debug action with internals method WPT reference tests can add metadata to tests to instruct the test runner how to interpret the results. Because of this, it is not enough to have an action that starts loading the (mis)match reference: we need the test runner to receive the metadata so it can act accordingly. This sets our test runner up for potentially supporting multiple (mis)match references, and fuzzy rendering matches - the latter will be implemented in the following commit.
2025-07-16 10:24:15 +02:00
Function<void(JsonValue)> on_reference_test_metadata;
LibWeb+UI: Add internals API to set browser zoom
2024-12-23 22:15:06 +01:00
Function<void(double factor)> on_set_browser_zoom;
LibWeb+WebContent: Provide feedback on find in page requests This change allows the results of a find in page query to be reported back to the user interface. Currently, the number of results found and the current match index are reported.
2024-06-09 18:35:32 +01:00
Function<void(size_t current_match_index, Optional<size_t> const& total_match_count)> on_find_in_page;
LibWeb+LibWebView+WebContent: Add support for meta theme-color
2023-09-19 01:51:48 +02:00
Function<void(Gfx::Color)> on_theme_color_change;
LibWeb+LibWebVew+WebContent+UI: Add IPC to retrieve the system clipboard We currently have a single IPC to set clipboard data. We will also need an IPC to retrieve that data from the UI. This defines system clipboard data in LibWeb to handle this transfer, and adds the IPC to provide it.
2025-05-01 11:38:31 -04:00
Function<void(Web::Clipboard::SystemClipboardRepresentation, String const&)> on_insert_clipboard_entry;
LibWebView+UI: Extract some UI-specific displays to Application helpers This is preparation for moving application menus to LibWebView. We will need a way to display these dialogs from outside of the UI layer.
2025-09-04 08:53:57 -04:00
Function<String()> on_request_clipboard_text;
LibWeb+LibWebVew+WebContent+UI: Add IPC to retrieve the system clipboard We currently have a single IPC to set clipboard data. We will also need an IPC to retrieve that data from the UI. This defines system clipboard data in LibWeb to handle this transfer, and adds the IPC to provide it.
2025-05-01 11:38:31 -04:00
Function<void(u64 request_id)> on_request_clipboard_entries;
LibWeb+LibWebView+WebContent: Inform chromes when audio is played/paused Most browsers have some indicator when audio is playing in a tab, which makes it easier to find that tab and mute unwanted audio. This adds an IPC to allow the Ladybird chromes to do something similar.
2024-03-26 19:27:06 -04:00
Function<void(Web::HTML::AudioPlayState)> on_audio_play_state_changed;
LibWeb+LibWebView+WebContent: Add did_update_navigation_buttons_state() It is going to be used to communicate whether it is possible to navigate back or forward after session history stored on browser side will no longer be used to driver navigation.
2024-04-13 23:12:55 +02:00
Function<void(bool, bool)> on_navigation_buttons_state_changed;
LibWebView+UI: Handle common WebView client initialization in LibWebView No need to have every UI manually implement these common steps.
2024-11-13 16:35:17 -05:00
Function<void()> on_web_content_crashed;
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 19:27:17 +00:00
LibWeb+WebContent: Move scrollbar painting into WebContent The main intention of this change is to have a consistent look and behavior across all scrollbars, including elements with `overflow: scroll` and `overflow: auto`, iframes, and a page. Before: - Page's scrollbar is painted by Browser (Qt/AppKit) using the corresponding UI framework style, - Both WebContent and Browser know the scroll position offset. - WebContent uses did_request_scroll_to() IPC call to send updates. - Browser uses set_viewport_rect() to send updates. After: - Page's scrollbar is painted on WebContent side using the same style as currently used for elements with `overflow: scroll` and `overflow: auto`. A nice side effects: scrollbars are now painted for iframes, and page's scrollbar respects scrollbar-width CSS property. - Only WebContent knows scroll position offset. - did_request_scroll_to() is no longer used. - set_viewport_rect() is changed to set_viewport_size().
2024-06-03 17:53:55 +03:00
virtual Web::DevicePixelSize viewport_size() const = 0;
Browser+Ladybird+LibWebView: Virtualize computing content/widget points This will allow moving some copy-pasted functionality from web view implementations to the base LibWebView class.
2023-05-17 10:12:13 -04:00
virtual Gfx::IntPoint to_content_position(Gfx::IntPoint widget_position) const = 0;
virtual Gfx::IntPoint to_widget_position(Gfx::IntPoint content_position) const = 0;
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 07:59:51 +02:00
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 19:27:17 +00:00
protected:
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 19:49:49 +00:00
static constexpr auto ZOOM_MIN_LEVEL = 0.3f;
static constexpr auto ZOOM_MAX_LEVEL = 5.0f;
static constexpr auto ZOOM_STEP = 0.1f;
Ladybird+LibWebView+Browser: Remove ability to run with AST interpreter
2023-08-07 16:44:20 +02:00
ViewImplementation();
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 07:59:51 +02:00
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 19:27:17 +00:00
WebContentClient& client();
WebContentClient const& client() const;
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 18:00:48 -07:00
u64 page_id() const;
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 19:49:49 +00:00
virtual void update_zoom() = 0;
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 19:27:17 +00:00
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 07:59:51 +02:00
void handle_resize();
Ladybird: Add ability to create a tab without creating a new WebContent
2024-01-30 09:12:14 -07:00
enum class CreateNewClient {
No,
Yes,
};
LibWebView+UI: Handle common WebView client initialization in LibWebView No need to have every UI manually implement these common steps.
2024-11-13 16:35:17 -05:00
virtual void initialize_client(CreateNewClient = CreateNewClient::Yes);
Ladybird+LibWebView: Add -P/--enable-callgrind-profiling option This adds a -P option to run Ladybird under callgrind. It starts with instrumentation disabled. To start capturing a profile (once Ladybird has launched) run `callgrind_control -i on` and to stop it again run `callgrind_control -i off`. P.s. This is pretty much stolen from Andreas (and is based on the patch everyone [that wants a profile] have been manually applying).
2023-04-15 01:04:28 +01:00
LibWebView: Make loading an error page after a crash optional We won't need this in headless-browser (who isn't calling this helper yet).
2024-11-12 08:43:37 -05:00
enum class LoadErrorPage {
No,
Yes,
};
void handle_web_content_process_crash(LoadErrorPage = LoadErrorPage::Yes);
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 09:53:13 -04:00
LibWebView: Add defaultZoomLevelFactor setting and necessary plumbing
2025-08-23 11:15:31 -05:00
virtual void default_zoom_level_factor_changed() override;
LibWeb+LibWebView+UI: Migrate to LibWebView's language settings
2025-04-03 13:53:02 -04:00
virtual void languages_changed() override;
LibWebView+WebContent+UI: Migrate to the new autoplay settings This removes the old autoplay allowlist file in favor of the new site setting. We still support the command-line flag to enable autoplay globally, as this is needed for WPT.
2025-03-29 08:19:00 -04:00
virtual void autoplay_settings_changed() override;
LibWebView: Add do-not-track setting to about:settings
2025-04-02 09:47:44 -04:00
virtual void do_not_track_changed() override;
LibWebView+WebContent+UI: Migrate to the new autoplay settings This removes the old autoplay allowlist file in favor of the new site setting. We still support the command-line flag to enable autoplay globally, as this is needed for WPT.
2025-03-29 08:19:00 -04:00
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 19:27:17 +00:00
struct SharedBitmap {
i32 id { -1 };
LibWeb: Refactor int types in WebContentServer to DevicePixels
2023-12-14 07:17:00 +01:00
Web::DevicePixelSize last_painted_size;
LibGfx+LibWebView+UI: Store Gfx::Bitmap in RefPtr to const
2025-04-15 15:50:18 -06:00
RefPtr<Gfx::Bitmap const> bitmap;
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 19:27:17 +00:00
};
struct ClientState {
RefPtr<WebContentClient> client;
LibWebView: Add window handle in `ClientState` in `ViewImplementation` Add field for a handle that is going to be used by WebDriver to identify top-level browsing contexts. It is supposed to be populated by WebContent client during creation. Co-authored-by: Timothy Flynn <trflynn89@pm.me>
2023-03-16 18:24:30 +03:00
String client_handle;
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 19:27:17 +00:00
SharedBitmap front_bitmap;
SharedBitmap back_bitmap;
Ladybird: Add ability to create a tab without creating a new WebContent
2024-01-30 09:12:14 -07:00
u64 page_index { 0 };
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 19:27:17 +00:00
bool has_usable_bitmap { false };
} m_client_state;
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 19:49:49 +00:00
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 16:22:27 +13:00
URL::URL m_url;
LibWeb+LibWebView+WebContent+UI: Port the document title to UTF-16
2025-07-28 16:51:01 -04:00
Utf16String m_title;
LibWebView+Ladybird: Move page loading to ViewImplementation
2023-01-12 20:30:06 +00:00
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 19:49:49 +00:00
float m_zoom_level { 1.0 };
float m_device_pixel_ratio { 1.0 };
LibWebView+WebContent: Make it possible to change the painting interval This allows us to paint at the refresh rate of the screen. The default is 60, as before, in case it never gets set by anything.
2025-07-25 13:10:00 +01:00
double m_maximum_frames_per_second { 60.0 };
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 07:59:51 +02:00
LibWeb+LibWebView: Migrate Browser's input event handling to LibWebView The Serenity chrome is the only chrome thus far that sends all input key and mouse events to WebContent, including shortcut activations. This is necessary for all chromes - we must give web pages a chance to intercept input events before handling them ourselves. To make this easier for other chromes, this patch moves Serenity's input event handling to LibWebView. To do so, we add the Web::InputEvent type, which models the event data we need within LibWeb. Chromes will then be responsible for converting between this type and their native events. This class lives in LibWeb (rather than LibWebView) because the plan is to use it wholesale throughout the Page's event handler and across IPC. Right now, we still send the individual fields of the event over IPC, but it will be an easy refactor to send the event itself. We just can't do this until all chromes have been ported to this event queueing. Also note that we now only handle key input events back in the chrome. WebContent handles all mouse events that it possibly can. If it was not able to handle a mouse event, there's nothing for the chrome to do (i.e. there is no clicking, scrolling, etc. the chrome is able to do if the WebContent couldn't).
2024-03-03 22:07:49 -05:00
Queue<Web::InputEvent> m_pending_input_events;
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 07:59:51 +02:00
RefPtr<Core::Timer> m_backing_store_shrink_timer;
LibGfx+LibWebView+UI: Store Gfx::Bitmap in RefPtr to const
2025-04-15 15:50:18 -06:00
RefPtr<Gfx::Bitmap const> m_backup_bitmap;
LibWeb: Refactor int types in WebContentServer to DevicePixels
2023-12-14 07:17:00 +01:00
Web::DevicePixelSize m_backup_bitmap_size;
LibWebView: Don't re-create WebContent proceses when repeatedly crashing Serenity handles this in the SystemServer already, but the simplest place to put this logic is the ViewImplementation base class. This is trivial to see when running Ladybird without SERENTIY_SOURCE_DIR set, or set improperly.
2023-05-27 10:46:45 -06:00
size_t m_crash_count = 0;
RefPtr<Core::Timer> m_repeated_crash_timer;
Ladybird+LibWebView+WebContent: Make the screenshot IPCs async These IPCs are different than other IPCs in that we can't just set up a callback function to be invoked when WebContent sends us the screenshot data. There are multiple places that would set that callback, and they would step on each other's toes. Instead, the screenshot APIs on ViewImplementation now return a Promise which callers can interact with to receive the screenshot (or an error).
2023-12-31 09:51:02 -05:00
RefPtr<Core::Promise<LexicalPath>> m_pending_screenshot;
LibWebView+WebContent+headless-browser: Make the page info IPCs async The IPCs to request a page's text, layout tree, etc. are currently all synchronous. This can result in a deadlock when WebContent also makes a synchronous IPC call, as both ends will be waiting on each other. This replaces the page info IPCs with a single, asynchronous IPC. This new IPC is promise-based, much like our screenshot IPC.
2024-09-19 10:40:00 -04:00
RefPtr<Core::Promise<String>> m_pending_info_request;
LibWeb+LibWebView+WebContent: Inform chromes when audio is played/paused Most browsers have some indicator when audio is playing in a tab, which makes it easier to find that tab and mute unwanted audio. This adds an IPC to allow the Ladybird chromes to do something similar.
2024-03-26 19:27:06 -04:00
LibWebView+WebContent+UI: Remember the current system visibility state We will want to re-inform WebContent of the system visibility state when we create a new process after a crash. This changes the IPC to just send the enum value directly, instead of a boolean, so that we can just store that enum value directly on the ViewImplementation class.
2024-11-13 11:24:16 -05:00
Web::HTML::VisibilityState m_system_visibility_state { Web::HTML::VisibilityState::Hidden };
LibWeb+LibWebView+WebContent: Inform chromes when audio is played/paused Most browsers have some indicator when audio is playing in a tab, which makes it easier to find that tab and mute unwanted audio. This adds an IPC to allow the Ladybird chromes to do something similar.
2024-03-26 19:27:06 -04:00
Web::HTML::AudioPlayState m_audio_play_state { Web::HTML::AudioPlayState::Paused };
LibWebView: Handle mutliple audio tracks when audio play state changes For example, if a page has multiple audio elements all actively playing audio, we don't want to broadcast a play state change when only one of them stop playing.
2024-03-30 09:34:23 -04:00
size_t m_number_of_elements_playing_audio { 0 };
LibWeb+LibWebView+WebContent: Support muting an entire page This adds an IPC for chromes to mute a tab. When muted, we trigger an internal volume change notification and indicate that the user agent has overriden the media volume.
2024-03-30 09:41:15 -04:00
Web::HTML::MuteState m_mute_state { Web::HTML::MuteState::Unmuted };
LibWebView: Add simple ID tracking to WebViews For Firefox DevTools, we will need to track WebViews by a numerical ID. Here, we just increment a static 64-bit counter. We can switch to using IDAllocator if we ever have an issue with this. This patch adds such an ID to the views and a couple of APIs to access WebViews after creation.
2025-02-15 08:06:36 -05:00
// FIXME: Reconcile this ID with `page_id`. The latter is only unique per WebContent connection, whereas the view ID
// is required to be globally unique for Firefox DevTools.
u64 m_view_id { 0 };
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 14:32:17 +02:00
};
}
Reference in a new issue Copy permalink