beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-26 01:20:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Libraries/LibWeb/Page/Page.h

411 lines
19 KiB
C
Raw Normal View History

LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 11:19:50 +00:00
* Copyright (c) 2020-2023, Andreas Kling <andreas@ladybird.org>
LibWeb+WebContent: Add plumbing for 'webdriver-active flag'
2022-10-12 21:49:23 +00:00
* Copyright (c) 2021-2022, Linus Groh <linusg@serenityos.org>
LibWeb+WebContent+headless-browser: Make Page aware of the display scale For now, we just report it as "1" everywhere. Replaced `screen_rect()` with `web_exposed_screen_area()` from the spec.
2022-11-25 17:07:19 +00:00
* Copyright (c) 2022, Sam Atkins <atkinssj@serenityos.org>
LibWeb: Make Web::Page GC-allocated This is a first step towards removing the various Page& and Page* we have littering the engine with "trust me bro" safety guarantees. Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-12-04 08:57:13 +00:00
* Copyright (c) 2023, Shannon Booth <shannon@serenityos.org>
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
*/
#pragma once
#include <AK/Noncopyable.h>
#include <AK/OwnPtr.h>
#include <AK/RefPtr.h>
LibWeb: Remove low-hanging LibGUI fruit from LibWeb We'll want to remove the LibGUI dependency from the WebContent process. This is the first basic step of removing unnecessary LibGUI includes and swapping out GUI::Painter for Gfx::Painter.
2021-02-10 07:25:35 +00:00
#include <AK/WeakPtr.h>
#include <AK/Weakable.h>
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
#include <LibGC/Heap.h>
#include <LibGC/Root.h>
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
#include <LibGfx/Forward.h>
#include <LibGfx/Palette.h>
LibWeb+LibWebView+WebContent: Add IPC to receive window position/size This information will have to come from the Browser application. This adds IPCs to receive that information when it is available or changes.
2022-11-01 18:55:53 +00:00
#include <LibGfx/Point.h>
LibWeb+WebContent: Virtualize methods needed for WebDriver in PageClient WebDriver currently uses the WebContent::ConnectionFromClient IPC class directly for these features. To support headless-browser, WebDriver will instead need to rely on PageClient to provide these.
2022-11-21 21:10:57 +00:00
#include <LibGfx/Rect.h>
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 15:50:57 +00:00
#include <LibGfx/ShareableBitmap.h>
LibWeb+LibWebView+WebContent: Add IPC to receive window position/size This information will have to come from the Browser application. This adds IPCs to receive that information when it is available or changes.
2022-11-01 18:55:53 +00:00
#include <LibGfx/Size.h>
LibWeb: Remove low-hanging LibGUI fruit from LibWeb We'll want to remove the LibGUI dependency from the WebContent process. This is the first basic step of removing unnecessary LibGUI includes and swapping out GUI::Painter for Gfx::Painter.
2021-02-10 07:25:35 +00:00
#include <LibGfx/StandardCursor.h>
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 14:51:38 +00:00
#include <LibIPC/Forward.h>
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 03:22:27 +00:00
#include <LibURL/URL.h>
LibWeb+WebContent: Add set_preferred_color_scheme IPC call This allows the owner of a WebView to override whether to use a dark theme or not, instead of just using the system theme's IsDark property.
2021-10-26 16:00:10 +00:00
#include <LibWeb/CSS/PreferredColorScheme.h>
LibWeb: Add Contrast preference
2024-06-12 23:03:56 +00:00
#include <LibWeb/CSS/PreferredContrast.h>
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 14:15:59 +00:00
#include <LibWeb/CSS/PreferredMotion.h>
LibWeb+LibWebView+WebContent: Add an Inspector IDL object to the Window This is an internal object that must be explicitly enabled by the chrome before it is added to the Window. The Inspector object will be used by a special WebView that will replace all chrome-specific inspector windows. The IDL defines methods that this WebView will need to inform the chrome of various events, such as the user clicking a DOM node.
2023-11-23 17:22:23 +00:00
#include <LibWeb/CSS/Selector.h>
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 10:18:35 +00:00
#include <LibWeb/CSS/StyleSheetIdentifier.h>
LibWeb+WebContent: Virtualize methods needed for WebDriver in PageClient WebDriver currently uses the WebContent::ConnectionFromClient IPC class directly for these features. To support headless-browser, WebDriver will instead need to rely on PageClient to provide these.
2022-11-21 21:10:57 +00:00
#include <LibWeb/Cookie/Cookie.h>
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
#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 22:39:20 +00: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 23:27:06 +00:00
#include <LibWeb/HTML/AudioPlayState.h>
LibWeb: Allow input color to give continuous updates
2023-12-11 05:53:10 +00: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 16:26:00 +00:00
#include <LibWeb/HTML/FileFilter.h>
Ladybird+LibWeb: Add basic select element support
2023-12-07 14:53:49 +00:00
#include <LibWeb/HTML/SelectItem.h>
LibWeb: Create a new WebView for window.open()'d top level traversables
2024-01-31 03:55:24 +00:00
#include <LibWeb/HTML/TokenizedFeatures.h>
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-31 03:05:00 +00:00
#include <LibWeb/HTML/WebViewHints.h>
Browser+LibWeb+WebContent: Allow Browser to load local files To achieve this goal: - The Browser unveils "/tmp/portal/filesystemaccess" - Pass the page through LoadRequest => ResourceLoader - ResourceLoader requests a file to the FileSystemAccessServer via IPC - OutOfProcessWebView handles it and sends a file descriptor back to the Page.
2022-02-26 16:50:31 +00:00
#include <LibWeb/Loader/FileRequest.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 16:56:31 +00:00
#include <LibWeb/Page/EventResult.h>
LibWeb: Begin implementing the drag-and-drop processing model The drag-and-drop processing model allows for users to drag around either elements within the DOM or objects completely outside the DOM. This drag event can either end without action (via cancellation or user input), or in a drop event, where the dragged object is dropped onto another element within the DOM. The processing model is rather large. This implements enough of it to allow the UI process to specifically handle dragging objects outside of the DOM onto the DOM. For example, dragging an image from the OS file manager onto a file-upload input element. This does not implement the ability to drag DOM elements.
2024-08-17 17:29:55 +00:00
#include <LibWeb/Page/InputEvent.h>
LibWeb+WebContent+headless-browser: Make Page aware of the display scale For now, we just report it as "1" everywhere. Replaced `screen_rect()` with `web_exposed_screen_area()` from the spec.
2022-11-25 17:07:19 +00:00
#include <LibWeb/PixelUnits.h>
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 19:29:08 +00:00
#include <LibWeb/UIEvents/KeyCode.h>
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
namespace Web {
class PageClient;
LibWeb: Remove Weakable from Web::Page Nothing requires this any more.
2023-12-03 03:56:32 +00:00
class Page final : public JS::Cell {
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
GC_CELL(Page, JS::Cell);
GC_DECLARE_ALLOCATOR(Page);
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
public:
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
static GC::Ref<Page> create(JS::VM&, GC::Ref<PageClient>);
LibWeb: Make Web::Page GC-allocated This is a first step towards removing the various Page& and Page* we have littering the engine with "trust me bro" safety guarantees. Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-12-04 08:57:13 +00:00
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
~Page();
PageClient& client() { return m_client; }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
PageClient const& client() const { return m_client; }
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
void set_top_level_traversable(GC::Ref<HTML::TraversableNavigable>);
LibWeb+WebContent: Plumb ability for WebContent process to hold N pages In order for same-origin NavigableContainers (iframe, frame, embed, ...) and window.open() WindowProxies to have the proper JS access to their embedder/opener, we need to host multiple top level traversables in the same WebContent process. As a first step, make WebContent::PageHost hold a HashMap of PageClient objects, each holding their own Web::Page that represents a TraversableNavigable's API surface with the UI process.
2023-11-29 16:34:38 +00:00
LibWeb: Protect against null deref during Web::Page initialization BrowsingContext::set_active_document() may end up asking for the Page's top level browsing context before Page has one. Do a workaround for now where we have an API to ask if it's initialized. Long-term we should find a cleaner solution.
2023-05-27 16:37:02 +00:00
// FIXME: This is a hack.
LibWeb: Update Page to use navigables
2023-08-27 15:06:39 +00:00
bool top_level_traversable_is_initialized() const;
LibWeb: Protect against null deref during Web::Page initialization BrowsingContext::set_active_document() may end up asking for the Page's top level browsing context before Page has one. Do a workaround for now where we have an API to ask if it's initialized. Long-term we should find a cleaner solution.
2023-05-27 16:37:02 +00:00
LibWeb: Make BrowsingContext GC-allocated (And BrowsingContextGroup had to come along for the ride as well.) This solves a number of nasty reference cycles between browsing contexts, history items, and their documents.
2022-10-17 09:06:50 +00:00
HTML::BrowsingContext& top_level_browsing_context();
HTML::BrowsingContext const& top_level_browsing_context() const;
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
GC::Ref<HTML::TraversableNavigable> top_level_traversable() const;
LibWeb: Update Page to use navigables
2023-08-27 15:06:39 +00:00
LibWeb: Move event handling & cursor from BrowsingContext to Navigable This was a long standing FIXME since the introduction of navigables.
2024-04-26 14:59:04 +00:00
HTML::Navigable& focused_navigable();
HTML::Navigable const& focused_navigable() const { return const_cast<Page*>(this)->focused_navigable(); }
LibWeb: Add "focused frame" concept, one focused Frame per Page Focus currently only moves when doing a mousedown in a frame.
2020-08-14 09:33:20 +00:00
LibWeb: Move event handling & cursor from BrowsingContext to Navigable This was a long standing FIXME since the introduction of navigables.
2024-04-26 14:59:04 +00:00
void set_focused_navigable(Badge<EventHandler>, HTML::Navigable&);
LibWeb: Add "focused frame" concept, one focused Frame per Page Focus currently only moves when doing a mousedown in a frame.
2020-08-14 09:33:20 +00:00
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-29 02:02:55 +00:00
void load(URL::URL const&);
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
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 15:12:17 +00:00
void load_html(StringView);
LibWeb: Add OutOfProcessWebView::load_html()
2020-10-08 20:11:01 +00:00
LibWeb+LibWebView+WebContent: Add an IPC call for Navigable::reload()
2024-04-13 16:51:27 +00:00
void reload();
LibWeb+LibWebView+WebContent: Add traverse_history_by_delta() IPC call
2024-04-13 20:33:48 +00:00
void traverse_the_history_by_delta(int delta);
LibWeb+WebContent+headless-browser: Make Page aware of the display scale For now, we just report it as "1" everywhere. Replaced `screen_rect()` with `web_exposed_screen_area()` from the spec.
2022-11-25 17:07:19 +00:00
CSSPixelPoint device_to_css_point(DevicePixelPoint) const;
DevicePixelPoint css_to_device_point(CSSPixelPoint) const;
LibWebView+WebContent: Drive repainting from WebContent process With this change, chrome no longer has to ask the WebContent process to paint the next frame into a specified bitmap. Instead, it allocates bitmaps and sends them to WebContent, which then lets chrome know when the painting is done. This work is a preparation to move the execution of painting commands into a separate thread. Now, it is much easier to start working on the next frame while the current one is still rendering. This is because WebContent does not have to inform chrome that the current frame is ready before it can request the next frame. Additionally, as a side bonus, we can now eliminate the did_invalidate_content_rect and did_change_selection IPC calls. These were used solely for the purpose of informing chrome that it needed to request a repaint.
2023-12-21 21:58:54 +00:00
DevicePixelRect css_to_device_rect(CSSPixelRect) const;
LibWeb+WebContent+headless-browser: Make Page aware of the display scale For now, we just report it as "1" everywhere. Replaced `screen_rect()` with `web_exposed_screen_area()` from the spec.
2022-11-25 17:07:19 +00:00
CSSPixelRect device_to_css_rect(DevicePixelRect) const;
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 14:53:55 +00:00
CSSPixelSize device_to_css_size(DevicePixelSize) const;
LibWeb+WebContent+headless-browser: Make Page aware of the display scale For now, we just report it as "1" everywhere. Replaced `screen_rect()` with `web_exposed_screen_area()` from the spec.
2022-11-25 17:07:19 +00:00
DevicePixelRect enclosing_device_rect(CSSPixelRect) const;
DevicePixelRect rounded_device_rect(CSSPixelRect) const;
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 16:56:31 +00:00
EventResult handle_mouseup(DevicePixelPoint, DevicePixelPoint screen_position, unsigned button, unsigned buttons, unsigned modifiers);
EventResult handle_mousedown(DevicePixelPoint, DevicePixelPoint screen_position, unsigned button, unsigned buttons, unsigned modifiers);
EventResult handle_mousemove(DevicePixelPoint, DevicePixelPoint screen_position, unsigned buttons, unsigned modifiers);
EventResult handle_mousewheel(DevicePixelPoint, DevicePixelPoint screen_position, unsigned button, unsigned buttons, unsigned modifiers, DevicePixels wheel_delta_x, DevicePixels wheel_delta_y);
EventResult handle_doubleclick(DevicePixelPoint, DevicePixelPoint screen_position, unsigned button, unsigned buttons, unsigned modifiers);
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
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 16:56:31 +00:00
EventResult handle_drag_and_drop_event(DragEvent::Type, DevicePixelPoint, DevicePixelPoint screen_position, unsigned button, unsigned buttons, unsigned modifiers, Vector<HTML::SelectedFile> files);
LibWeb: Begin implementing the drag-and-drop processing model The drag-and-drop processing model allows for users to drag around either elements within the DOM or objects completely outside the DOM. This drag event can either end without action (via cancellation or user input), or in a drop event, where the dragged object is dropped onto another element within the DOM. The processing model is rather large. This implements enough of it to allow the UI process to specifically handle dragging objects outside of the DOM onto the DOM. For example, dragging an image from the OS file manager onto a file-upload input element. This does not implement the ability to drag DOM elements.
2024-08-17 17:29:55 +00:00
UI+LibWeb+WebContent: Implement KeyEvent repeat property When a platform key press or release event is repeated, we now pass along a `repeat` flag to indicate that auto-repeating is happening. This flag eventually ends up in `KeyboardEvent.repeat`.
2024-10-22 13:32:42 +00:00
EventResult handle_keydown(UIEvents::KeyCode, unsigned modifiers, u32 code_point, bool repeat);
EventResult handle_keyup(UIEvents::KeyCode, unsigned modifiers, u32 code_point, bool repeat);
LibWeb: Allow inserting text at the cursor by typing characters :^) This works everywhere right now, but it's obviously not going to stay that way forever. :^) Note that this does not advance the cursor correctly for whitespace since the cursor is DOM-based and doesn't take whitespace collapsing into account yet.
2020-08-02 10:10:01 +00:00
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
Gfx::Palette palette() const;
LibWeb+WebContent+headless-browser: Make Page aware of the display scale For now, we just report it as "1" everywhere. Replaced `screen_rect()` with `web_exposed_screen_area()` from the spec.
2022-11-25 17:07:19 +00:00
CSSPixelRect web_exposed_screen_area() const;
LibWeb+WebContent: Add set_preferred_color_scheme IPC call This allows the owner of a WebView to override whether to use a dark theme or not, instead of just using the system theme's IsDark property.
2021-10-26 16:00:10 +00:00
CSS::PreferredColorScheme preferred_color_scheme() const;
LibWeb: Add Contrast preference
2024-06-12 23:03:56 +00:00
CSS::PreferredContrast preferred_contrast() const;
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 14:15:59 +00:00
CSS::PreferredMotion preferred_motion() const;
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
LibWeb+Browser: Add Debug menu action for toggling Same-Origin Policy Sometimes it's useful to turn off the SOP for testing purposes. Let's make that easy by having a Debug menu item for it. :^)
2021-09-12 00:10:43 +00:00
bool is_same_origin_policy_enabled() const { return m_same_origin_policy_enabled; }
void set_same_origin_policy_enabled(bool b) { m_same_origin_policy_enabled = b; }
LibWeb: Add 'is scripting enabled' concept to EnvironmentSettingsObject This is now the source of truth for 'user enabled/disabled scripting', but it has to ask the window's page, which actually stores the setting. Also use this new functionality in two places where it was previously marked as a FIXME.
2022-03-30 21:42:09 +00:00
bool is_scripting_enabled() const { return m_is_scripting_enabled; }
void set_is_scripting_enabled(bool b) { m_is_scripting_enabled = b; }
LibWeb: Add 'should block pop ups' user config to Page This will also be used by the window.open algorithm steps.
2022-11-15 00:01:13 +00:00
bool should_block_pop_ups() const { return m_should_block_pop_ups; }
void set_should_block_pop_ups(bool b) { m_should_block_pop_ups = b; }
LibWeb+WebContent: Add plumbing for 'webdriver-active flag'
2022-10-12 21:49:23 +00:00
bool is_webdriver_active() const { return m_is_webdriver_active; }
void set_is_webdriver_active(bool b) { m_is_webdriver_active = b; }
LibWeb+WebContent: Convert BrowsingContext to new pixel units This fixes a few glitches. We no longer give the page double the width it should have, and we mark the correct area of the page as needing repainting.
2022-11-03 12:49:54 +00:00
DevicePixelPoint window_position() const { return m_window_position; }
void set_window_position(DevicePixelPoint position) { m_window_position = position; }
LibWeb+LibWebView+WebContent: Add IPC to receive window position/size This information will have to come from the Browser application. This adds IPCs to receive that information when it is available or changes.
2022-11-01 18:55:53 +00:00
LibWeb+WebContent: Convert BrowsingContext to new pixel units This fixes a few glitches. We no longer give the page double the width it should have, and we mark the correct area of the page as needing repainting.
2022-11-03 12:49:54 +00:00
DevicePixelSize window_size() const { return m_window_size; }
void set_window_size(DevicePixelSize size) { m_window_size = size; }
LibWeb+LibWebView+WebContent: Add IPC to receive window position/size This information will have to come from the Browser application. This adds IPCs to receive that information when it is available or changes.
2022-11-01 18:55:53 +00:00
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-29 03:37:11 +00:00
void did_update_window_rect();
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
void set_window_rect_observer(GC::Ptr<GC::Function<void(DevicePixelRect)>> window_rect_observer) { m_window_rect_observer = window_rect_observer; }
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-29 03:37:11 +00:00
LibWeb+Ladybird+Userland: Port window.[alert,confirm,prompt] to String LibGUI and WebDriver (read: JSON) API boundaries use DeprecatedString, so that is as far as these changes can reach. The one change which isn't just a DeprecatedString to String replacement is handling the "null" prompt response. We previously checked for the null DeprecatedString, whereas we now represent this as an empty Optional<String>.
2023-03-13 21:30:51 +00:00
void did_request_alert(String const& message);
LibWeb+WebContent: Move pending dialog handling from PageHost to Page Currently, all handling of pending dialogs occurs in PageHost. In order to re-use this functionality to run WebDriver in a headless move, move it to Page.
2022-11-21 20:18:42 +00:00
void alert_closed();
LibWeb+Ladybird+Userland: Port window.[alert,confirm,prompt] to String LibGUI and WebDriver (read: JSON) API boundaries use DeprecatedString, so that is as far as these changes can reach. The one change which isn't just a DeprecatedString to String replacement is handling the "null" prompt response. We previously checked for the null DeprecatedString, whereas we now represent this as an empty Optional<String>.
2023-03-13 21:30:51 +00:00
bool did_request_confirm(String const& message);
LibWeb+WebContent: Move pending dialog handling from PageHost to Page Currently, all handling of pending dialogs occurs in PageHost. In order to re-use this functionality to run WebDriver in a headless move, move it to Page.
2022-11-21 20:18:42 +00:00
void confirm_closed(bool accepted);
LibWeb+Ladybird+Userland: Port window.[alert,confirm,prompt] to String LibGUI and WebDriver (read: JSON) API boundaries use DeprecatedString, so that is as far as these changes can reach. The one change which isn't just a DeprecatedString to String replacement is handling the "null" prompt response. We previously checked for the null DeprecatedString, whereas we now represent this as an empty Optional<String>.
2023-03-13 21:30:51 +00:00
Optional<String> did_request_prompt(String const& message, String const& default_);
void prompt_closed(Optional<String> response);
LibWeb+WebContent: Move pending dialog handling from PageHost to Page Currently, all handling of pending dialogs occurs in PageHost. In order to re-use this functionality to run WebDriver in a headless move, move it to Page.
2022-11-21 20:18:42 +00:00
enum class PendingDialog {
None,
Alert,
Confirm,
Prompt,
};
bool has_pending_dialog() const { return m_pending_dialog != PendingDialog::None; }
PendingDialog pending_dialog() const { return m_pending_dialog; }
LibWeb+Ladybird+Userland: Port window.[alert,confirm,prompt] to String LibGUI and WebDriver (read: JSON) API boundaries use DeprecatedString, so that is as far as these changes can reach. The one change which isn't just a DeprecatedString to String replacement is handling the "null" prompt response. We previously checked for the null DeprecatedString, whereas we now represent this as an empty Optional<String>.
2023-03-13 21:30:51 +00:00
Optional<String> const& pending_dialog_text() const { return m_pending_dialog_text; }
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
void dismiss_dialog(GC::Ref<GC::Function<void()>> on_dialog_closed);
void accept_dialog(GC::Ref<GC::Function<void()>> on_dialog_closed);
LibWeb+WebContent: Move pending dialog handling from PageHost to Page Currently, all handling of pending dialogs occurs in PageHost. In order to re-use this functionality to run WebDriver in a headless move, move it to Page.
2022-11-21 20:18:42 +00:00
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 09:32:40 +00:00
void did_request_color_picker(WeakPtr<HTML::HTMLInputElement> target, Color current_color);
LibWeb: Allow input color to give continuous updates
2023-12-11 05:53:10 +00:00
void color_picker_update(Optional<Color> picked_color, HTML::ColorPickerUpdateState state);
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 09:32:40 +00:00
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 16:26:00 +00:00
void did_request_file_picker(WeakPtr<HTML::HTMLInputElement> target, HTML::FileFilter accepted_file_types, HTML::AllowMultipleFiles);
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 18:02:47 +00:00
void file_picker_closed(Span<HTML::SelectedFile> selected_files);
LibWeb: Make request_select_dropdown more similar to context menu api
2023-12-12 21:35:37 +00:00
void did_request_select_dropdown(WeakPtr<HTML::HTMLSelectElement> target, Web::CSSPixelPoint content_position, Web::CSSPixels minimum_width, Vector<Web::HTML::SelectItem> items);
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 17:19:08 +00:00
void select_dropdown_closed(Optional<u32> const& selected_item_id);
Ladybird+LibWeb: Add basic select element support
2023-12-07 14:53:49 +00:00
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 09:32:40 +00:00
enum class PendingNonBlockingDialog {
None,
ColorPicker,
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 18:02:47 +00:00
FilePicker,
Ladybird+LibWeb: Add basic select element support
2023-12-07 14:53:49 +00:00
Select,
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 09:32:40 +00:00
};
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 08:37:44 +00:00
void register_media_element(Badge<HTML::HTMLMediaElement>, UniqueNodeID media_id);
void unregister_media_element(Badge<HTML::HTMLMediaElement>, UniqueNodeID media_id);
LibWeb: Store the ID of all media elements on a page This will be used to inform the media elements when the user has muted the page.
2024-03-30 13:38:00 +00:00
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 14:51:38 +00:00
struct MediaContextMenu {
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 03:22:27 +00:00
URL::URL media_url;
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 14:51:38 +00:00
bool is_video { false };
bool is_playing { false };
Ladybird+LibWeb+WebContent: Add context menu controls for muting audio
2023-06-16 15:29:54 +00:00
bool is_muted { false };
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 14:51:38 +00:00
bool has_user_agent_controls { false };
bool is_looping { false };
};
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 08:37:44 +00:00
void did_request_media_context_menu(UniqueNodeID media_id, CSSPixelPoint, ByteString const& target, unsigned modifiers, MediaContextMenu);
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 14:51:38 +00:00
WebIDL::ExceptionOr<void> toggle_media_play_state();
Ladybird+LibWeb+WebContent: Add context menu controls for muting audio
2023-06-16 15:29:54 +00: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 14:51:38 +00:00
WebIDL::ExceptionOr<void> toggle_media_loop_state();
WebIDL::ExceptionOr<void> toggle_media_controls_state();
Browser+LibWeb+WebContent: Broadcast video element context menu requests This just sets up the IPC to notify the browser process of context menu requests on video elements. The IPC contains a few pieces of information about the state of the video element.
2023-05-15 13:42:56 +00: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 13:41:15 +00:00
HTML::MuteState page_mute_state() const { return m_mute_state; }
void toggle_page_mute_state();
LibWeb: Add support for "User" CascadeOrigin User styles are applied after the UserAgent's built-in styles, and before the Author styles that are part of the web page. Because they're neither part of the page, but can still be modified while the page is open, caching is a little tricky. The approach here is to piggy-back on the StyleComputer's rule caches, which already get rebuilt whenever the styles change. This is not the smartest approach, since it means re-parsing the style sheet more often than is necessary, but it's simple and works. :^)
2023-08-21 14:50:01 +00:00
Optional<String> const& user_style() const { return m_user_style_sheet_source; }
void set_user_style(String source);
LibWeb: Move pdfViewerSupported's answer to Page This will also be accessed by navigator.{plugins,mimeTypes} to determine if they should expose any information.
2023-02-28 00:20:09 +00:00
bool pdf_viewer_supported() const { return m_pdf_viewer_supported; }
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 19:09:33 +00:00
void clear_selection();
LibWeb: Add WrapAround option to find in page This allows `Page::find_in_page()` to optionally not return a result if the start or end of the document has been reached.
2024-06-25 21:18:49 +00:00
enum class WrapAround {
Yes,
No,
};
LibWeb: Rerun find in page query when navigating between URLs Previously, the "Find Next Match" and "Find Previous Match" actions simply updated the match index of the last query to be performed. This led to incorrect results if the page had been modified after the last query had been run. `Page::find_in_page_next_match()` and `Page::find_in_page_previous_match()` both now rerun the last query to ensure the results are up to date before updating the match index. The match index is also reset if the URL of the active document has changed since the last query. The current match index is maintained if only the URL fragment changes.
2024-06-14 15:56:38 +00:00
struct FindInPageQuery {
String string {};
CaseSensitivity case_sensitivity { CaseSensitivity::CaseInsensitive };
LibWeb: Add WrapAround option to find in page This allows `Page::find_in_page()` to optionally not return a result if the start or end of the document has been reached.
2024-06-25 21:18:49 +00:00
WrapAround wrap_around { WrapAround::Yes };
LibWeb: Rerun find in page query when navigating between URLs Previously, the "Find Next Match" and "Find Previous Match" actions simply updated the match index of the last query to be performed. This led to incorrect results if the page had been modified after the last query had been run. `Page::find_in_page_next_match()` and `Page::find_in_page_previous_match()` both now rerun the last query to ensure the results are up to date before updating the match index. The match index is also reset if the URL of the active document has changed since the last query. The current match index is maintained if only the URL fragment changes.
2024-06-14 15:56:38 +00:00
};
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 17:35:32 +00:00
struct FindInPageResult {
size_t current_match_index { 0 };
Optional<size_t> total_match_count {};
};
LibWeb: Rerun find in page query when navigating between URLs Previously, the "Find Next Match" and "Find Previous Match" actions simply updated the match index of the last query to be performed. This led to incorrect results if the page had been modified after the last query had been run. `Page::find_in_page_next_match()` and `Page::find_in_page_previous_match()` both now rerun the last query to ensure the results are up to date before updating the match index. The match index is also reset if the URL of the active document has changed since the last query. The current match index is maintained if only the URL fragment changes.
2024-06-14 15:56:38 +00:00
FindInPageResult find_in_page(FindInPageQuery const&);
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 17:35:32 +00:00
FindInPageResult find_in_page_next_match();
FindInPageResult find_in_page_previous_match();
LibWeb: Implement a minimal version of `Window.find()` This is a non-standard API that other browsers implement, which highlights matching text in the current window. This is just a thin wrapper around our find in page functionality, the main motivation for adding this API is that it allows us to write tests for our find in page implementation.
2024-06-25 21:52:01 +00:00
Optional<FindInPageQuery> last_find_in_page_query() const { return m_last_find_in_page_query; }
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 19:09:33 +00:00
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
private:
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
explicit Page(GC::Ref<PageClient>);
LibWeb: Make Web::Page GC-allocated This is a first step towards removing the various Page& and Page* we have littering the engine with "trust me bro" safety guarantees. Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-12-04 08:57:13 +00:00
virtual void visit_edges(Visitor&) override;
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
GC::Ptr<HTML::HTMLMediaElement> media_context_menu_element();
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 15:17:58 +00:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
Vector<GC::Root<DOM::Document>> documents_in_active_window() const;
LibWeb: Limit find in page query to documents in the active window Previously, refreshing the current page and doing a new find in page query would result in duplicate matches being returned.
2024-06-14 13:56:56 +00:00
LibWeb: Update current find in page match after performing query Previously, the `Page::find_in_page_next_match()` needed to be called twice before the match index would be updated.
2024-06-19 11:15:00 +00:00
enum class SearchDirection {
Forward,
Backward,
};
FindInPageResult perform_find_in_page_query(FindInPageQuery const&, Optional<SearchDirection> = {});
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
void update_find_in_page_selection(Vector<GC::Root<DOM::Range>> matches);
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 19:09:33 +00:00
LibWeb+WebContent+WebDriver: Asynchronously wait for dialog dismissal There was a timing issue here where WebDriver would dismiss a dialog, and then invoke another endpoint before the dialog was actually closed. This is because the dismissal first has to hop over to the UI process to close the graphical dialog, which then asynchronously informs WebContent of the result. It's not until WebContent receives that result that the dialog is considered closed, thus those subsequent endpoints would abort due a dialog being "open". We now wait for dialogs to be fully closed before returning from the dismissal endpoints.
2024-10-25 16:31:07 +00:00
void on_pending_dialog_closed();
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
GC::Ref<PageClient> m_client;
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
LibWeb: Move event handling & cursor from BrowsingContext to Navigable This was a long standing FIXME since the introduction of navigables.
2024-04-26 14:59:04 +00:00
WeakPtr<HTML::Navigable> m_focused_navigable;
LibWeb+Browser: Add Debug menu action for toggling Same-Origin Policy Sometimes it's useful to turn off the SOP for testing purposes. Let's make that easy by having a Debug menu item for it. :^)
2021-09-12 00:10:43 +00:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
GC::Ptr<HTML::TraversableNavigable> m_top_level_traversable;
LibWeb: Update Page to use navigables
2023-08-27 15:06:39 +00:00
LibWeb+Browser: Disable Same-Origin Policy by default for now Until we have CORS preflight checks working, this is only getting in the way of testing and I have to disable it manually all the time.
2021-10-03 21:39:07 +00:00
// FIXME: Enable this by default once CORS preflight checks are supported.
bool m_same_origin_policy_enabled { false };
LibWeb: Add 'is scripting enabled' concept to EnvironmentSettingsObject This is now the source of truth for 'user enabled/disabled scripting', but it has to ask the window's page, which actually stores the setting. Also use this new functionality in two places where it was previously marked as a FIXME.
2022-03-30 21:42:09 +00:00
bool m_is_scripting_enabled { true };
LibWeb+WebContent: Add plumbing for 'webdriver-active flag'
2022-10-12 21:49:23 +00:00
LibWeb: Add 'should block pop ups' user config to Page This will also be used by the window.open algorithm steps.
2022-11-15 00:01:13 +00:00
bool m_should_block_pop_ups { true };
LibWeb+WebContent: Add plumbing for 'webdriver-active flag'
2022-10-12 21:49:23 +00:00
// https://w3c.github.io/webdriver/#dfn-webdriver-active-flag
// The webdriver-active flag is set to true when the user agent is under remote control. It is initially false.
bool m_is_webdriver_active { false };
LibWeb+LibWebView+WebContent: Add IPC to receive window position/size This information will have to come from the Browser application. This adds IPCs to receive that information when it is available or changes.
2022-11-01 18:55:53 +00:00
LibWeb+WebContent: Convert BrowsingContext to new pixel units This fixes a few glitches. We no longer give the page double the width it should have, and we mark the correct area of the page as needing repainting.
2022-11-03 12:49:54 +00:00
DevicePixelPoint m_window_position {};
DevicePixelSize m_window_size {};
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
GC::Ptr<GC::Function<void(DevicePixelRect)>> m_window_rect_observer;
LibWeb+WebContent: Move pending dialog handling from PageHost to Page Currently, all handling of pending dialogs occurs in PageHost. In order to re-use this functionality to run WebDriver in a headless move, move it to Page.
2022-11-21 20:18:42 +00:00
PendingDialog m_pending_dialog { PendingDialog::None };
LibWeb+Ladybird+Userland: Port window.[alert,confirm,prompt] to String LibGUI and WebDriver (read: JSON) API boundaries use DeprecatedString, so that is as far as these changes can reach. The one change which isn't just a DeprecatedString to String replacement is handling the "null" prompt response. We previously checked for the null DeprecatedString, whereas we now represent this as an empty Optional<String>.
2023-03-13 21:30:51 +00:00
Optional<String> m_pending_dialog_text;
LibWeb+WebContent: Move pending dialog handling from PageHost to Page Currently, all handling of pending dialogs occurs in PageHost. In order to re-use this functionality to run WebDriver in a headless move, move it to Page.
2022-11-21 20:18:42 +00:00
Optional<Empty> m_pending_alert_response;
Optional<bool> m_pending_confirm_response;
LibWeb+Ladybird+Userland: Port window.[alert,confirm,prompt] to String LibGUI and WebDriver (read: JSON) API boundaries use DeprecatedString, so that is as far as these changes can reach. The one change which isn't just a DeprecatedString to String replacement is handling the "null" prompt response. We previously checked for the null DeprecatedString, whereas we now represent this as an empty Optional<String>.
2023-03-13 21:30:51 +00:00
Optional<Optional<String>> m_pending_prompt_response;
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
GC::Ptr<GC::Function<void()>> m_on_pending_dialog_closed;
LibWeb: Move pdfViewerSupported's answer to Page This will also be accessed by navigator.{plugins,mimeTypes} to determine if they should expose any information.
2023-02-28 00:20:09 +00:00
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 09:32:40 +00:00
PendingNonBlockingDialog m_pending_non_blocking_dialog { PendingNonBlockingDialog::None };
Ladybird+LibWeb: Add basic select element support
2023-12-07 14:53:49 +00:00
WeakPtr<HTML::HTMLElement> m_pending_non_blocking_dialog_target;
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 09:32:40 +00:00
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 08:37:44 +00:00
Vector<UniqueNodeID> m_media_elements;
Optional<UniqueNodeID> m_media_context_menu_element_id;
Browser+LibWeb+WebContent: Broadcast video element context menu requests This just sets up the IPC to notify the browser process of context menu requests on video elements. The IPC contains a few pieces of information about the state of the video element.
2023-05-15 13:42:56 +00: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 13:41:15 +00:00
Web::HTML::MuteState m_mute_state { Web::HTML::MuteState::Unmuted };
LibWeb: Add support for "User" CascadeOrigin User styles are applied after the UserAgent's built-in styles, and before the Author styles that are part of the web page. Because they're neither part of the page, but can still be modified while the page is open, caching is a little tricky. The approach here is to piggy-back on the StyleComputer's rule caches, which already get rebuilt whenever the styles change. This is not the smartest approach, since it means re-parsing the style sheet more often than is necessary, but it's simple and works. :^)
2023-08-21 14:50:01 +00:00
Optional<String> m_user_style_sheet_source;
LibWeb: Move pdfViewerSupported's answer to Page This will also be accessed by navigator.{plugins,mimeTypes} to determine if they should expose any information.
2023-02-28 00:20:09 +00:00
// https://html.spec.whatwg.org/multipage/system-state.html#pdf-viewer-supported
// Each user agent has a PDF viewer supported boolean, whose value is implementation-defined (and might vary according to user preferences).
// Spec Note: This value also impacts the navigation processing model.
// FIXME: Actually support pdf viewing
bool m_pdf_viewer_supported { false };
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 19:09:33 +00:00
size_t m_find_in_page_match_index { 0 };
LibWeb: Rerun find in page query when navigating between URLs Previously, the "Find Next Match" and "Find Previous Match" actions simply updated the match index of the last query to be performed. This led to incorrect results if the page had been modified after the last query had been run. `Page::find_in_page_next_match()` and `Page::find_in_page_previous_match()` both now rerun the last query to ensure the results are up to date before updating the match index. The match index is also reset if the URL of the active document has changed since the last query. The current match index is maintained if only the URL fragment changes.
2024-06-14 15:56:38 +00:00
Optional<FindInPageQuery> m_last_find_in_page_query;
URL::URL m_last_find_in_page_url;
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
};
LibWeb+WebContent+WebWorker: Add an option to skip painting the overlay This will allow the Inspector to take a screenshot of a DOM node without the overlay which renders the inspected node outline / box data.
2023-12-06 16:49:45 +00:00
struct PaintOptions {
enum class PaintOverlay {
No,
Yes,
};
PaintOverlay paint_overlay { PaintOverlay::Yes };
LibWeb+WebContent: Move PageClient::paint() into TraversableNavigable This way we leak less LibWeb implementation details into WebContent.
2024-06-09 23:58:32 +00:00
bool should_show_line_box_borders { false };
bool has_focus { false };
LibWeb+WebContent+WebWorker: Add an option to skip painting the overlay This will allow the Inspector to take a screenshot of a DOM node without the overlay which renders the inspected node outline / box data.
2023-12-06 16:49:45 +00:00
};
LibWeb: Rename CommandExecutor to DisplayListPlayer Use more widely recognized name among browser engine developers.
2024-06-23 16:42:39 +00:00
enum class DisplayListPlayerType {
Ladybird+LibWeb+WebContent: Always use Skia CPU backend in tests mode Enforce the use of the CPU backend in test mode to ensure that ref-tests produce consistent results across different computers, as this consistency cannot be achieved with the GPU backend.
2024-07-17 11:13:32 +00:00
SkiaGPUIfAvailable,
SkiaCPU,
LibWeb+WebContent+WebWorker: Allow to query painter type from PageClient Now it's possible to query selected type from SVGPageClient.
2024-06-19 11:46:27 +00:00
};
LibWeb: Make Web::PageClient GC-allocated This is a first step towards simplifying the ownership model of Web::Page. Soon Web::Page will store its WebClient as a NonnullGCPtr to help solve lifetime issues of the client being destroyed before the page.
2023-12-04 08:40:33 +00:00
class PageClient : public JS::Cell {
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
GC_CELL(PageClient, JS::Cell);
LibWeb: Make Web::PageClient GC-allocated This is a first step towards simplifying the ownership model of Web::Page. Soon Web::Page will store its WebClient as a NonnullGCPtr to help solve lifetime issues of the client being destroyed before the page.
2023-12-04 08:40:33 +00:00
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
public:
LibWeb+WebContent: Virtualize PageClient methods needed for all clients
2022-11-21 20:22:26 +00:00
virtual Page& page() = 0;
virtual Page const& page() const = 0;
LibWeb+WebContent: Move pending dialog handling from PageHost to Page Currently, all handling of pending dialogs occurs in PageHost. In order to re-use this functionality to run WebDriver in a headless move, move it to Page.
2022-11-21 20:18:42 +00:00
virtual bool is_connection_open() const = 0;
LibWeb: Add PageClient::palette() for view-agnostic palette access
2020-06-17 18:26:59 +00:00
virtual Gfx::Palette palette() const = 0;
LibWeb+WebContent+headless-browser: Make Page aware of the display scale For now, we just report it as "1" everywhere. Replaced `screen_rect()` with `web_exposed_screen_area()` from the spec.
2022-11-25 17:07:19 +00:00
virtual DevicePixelRect screen_rect() const = 0;
LibWeb: Make CSSPixels and Length use 64-bit (double) floating point This fixes a plethora of rounding problems on many websites. In the future, we may want to replace this with fixed-point arithmetic (bug #18566) for performance (and consistency with other engines), but in the meantime this makes the web look a bit better. :^) There's a lot more things that could be converted to doubles, which would reduce the amount of casting necessary in this patch. We can do that incrementally, however.
2023-05-24 08:50:57 +00:00
virtual double device_pixels_per_css_pixel() const = 0;
LibWeb+WebContent: Add set_preferred_color_scheme IPC call This allows the owner of a WebView to override whether to use a dark theme or not, instead of just using the system theme's IsDark property.
2021-10-26 16:00:10 +00:00
virtual CSS::PreferredColorScheme preferred_color_scheme() const = 0;
LibWeb: Add Contrast preference
2024-06-12 23:03:56 +00:00
virtual CSS::PreferredContrast preferred_contrast() const = 0;
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 14:15:59 +00:00
virtual CSS::PreferredMotion preferred_motion() const = 0;
LibWeb+WebContent: Change event loop to synchronously paint next frame ...instead of scheduling repaint timer in PageClient. This change fixes flickering on Discord that happened because: - Event loop schedules repainting by activating repaint timer - `Document::tear_down_layout_tree()` destroys paintable tree - Repaint timer invokes callback and renders an empty frame because paintable tree was destroyed
2024-05-28 13:51:53 +00:00
virtual void paint_next_frame() = 0;
LibWeb: Stop deadlocking on unit tests Unit tests on macOS deadlock because the WebContent process is waiting for the next opportunity to render before a screenshot is taken. For some reason unknown to myself, this opportunity never arrives. In order to not deadlock, screenshot requests are now also processed separately from rendering.
2024-07-03 12:12:28 +00:00
virtual void process_screenshot_requests() = 0;
Everywhere: Pass backing store into Navigable::paint() ...instead of Gfx::Bitmap, which makes it possible to access and directly paint into IOSurface on macOS.
2024-06-25 14:43:39 +00:00
virtual void paint(DevicePixelRect const&, Painting::BackingStore&, PaintOptions = {}) = 0;
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 14:19:34 +00:00
virtual void page_did_change_title(ByteString const&) { }
LibWeb+LibWebView+WebContent: Add did_change_url() IPC call
2024-04-14 08:27:20 +00:00
virtual void page_did_change_url(URL::URL const&) { }
LibWeb+WebContent: Virtualize methods needed for WebDriver in PageClient WebDriver currently uses the WebContent::ConnectionFromClient IPC class directly for these features. To support headless-browser, WebDriver will instead need to rely on PageClient to provide these.
2022-11-21 21:10:57 +00:00
virtual void page_did_request_refresh() { }
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-29 03:37:11 +00:00
virtual void page_did_request_resize_window(Gfx::IntSize) { }
virtual void page_did_request_reposition_window(Gfx::IntPoint) { }
LibWeb+WebContent: Virtualize methods needed for WebDriver in PageClient WebDriver currently uses the WebContent::ConnectionFromClient IPC class directly for these features. To support headless-browser, WebDriver will instead need to rely on PageClient to provide these.
2022-11-21 21:10:57 +00:00
virtual void page_did_request_restore_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-29 03:45:18 +00:00
virtual void page_did_request_maximize_window() { }
virtual void page_did_request_minimize_window() { }
virtual void page_did_request_fullscreen_window() { }
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-29 02:02:55 +00:00
virtual void page_did_start_loading(URL::URL const&, bool is_redirect) { (void)is_redirect; }
LibWeb+WebContent: Set ConsoleClient for nested browsing contexts Before page_did_create_main_document() only initialized ConsoleClient for top-level browsing context which means that nested browsing context could not print into the console. With this change, ConsoleClient is initialized for documents created for nested browsing context too. One ConsoleClient is shared between all browsing contexts within the same page.
2023-09-07 10:11:37 +00:00
virtual void page_did_create_new_document(Web::DOM::Document&) { }
LibWeb+WebContent: Initialise JS console from Document::initialize() Before this change JS console was initialise from activate_history_entry() which is too late for about:blank documents that are ready to run scripts immediately after creation.
2024-04-11 15:21:09 +00:00
virtual void page_did_change_active_document_in_top_level_browsing_context(Web::DOM::Document&) { }
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-29 02:02:55 +00:00
virtual void page_did_finish_loading(URL::URL const&) { }
LibGfx: Move StandardCursor enum to LibGfx This enum existed both in LibGUI and WindowServer which was silly and error-prone.
2020-09-10 17:25:13 +00:00
virtual void page_did_request_cursor_change(Gfx::StandardCursor) { }
LibWeb+WebContent+headless-browser: Use CSSPixels for PageClient events ...and also for hit testing, which is involved in most of them. Much of this is temporary conversions and other awkwardness, which should resolve itself as the rest of LibWeb is converted to these new types. Hopefully. :thousandyakstare:
2022-11-02 17:35:53 +00:00
virtual void page_did_request_context_menu(CSSPixelPoint) { }
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 03:22:27 +00:00
virtual void page_did_request_link_context_menu(CSSPixelPoint, URL::URL const&, [[maybe_unused]] ByteString const& target, [[maybe_unused]] unsigned modifiers) { }
virtual void page_did_request_image_context_menu(CSSPixelPoint, URL::URL const&, [[maybe_unused]] ByteString const& target, [[maybe_unused]] unsigned modifiers, Gfx::Bitmap 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 14:19:34 +00:00
virtual void page_did_request_media_context_menu(CSSPixelPoint, [[maybe_unused]] ByteString const& target, [[maybe_unused]] unsigned modifiers, Page::MediaContextMenu) { }
LibWeb+WebContent: Add a page hook to invoke the did-click-link IPC
2024-08-01 17:38:21 +00:00
virtual void page_did_click_link(URL::URL const&, [[maybe_unused]] ByteString const& target, [[maybe_unused]] unsigned modifiers) { }
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-29 02:02:55 +00:00
virtual void page_did_middle_click_link(URL::URL const&, [[maybe_unused]] ByteString const& target, [[maybe_unused]] unsigned modifiers) { }
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 14:48:57 +00:00
virtual void page_did_request_tooltip_override(CSSPixelPoint, ByteString const&) { }
virtual void page_did_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 12:16:24 +00:00
virtual void page_did_enter_tooltip_area(ByteString const&) { }
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
virtual void page_did_leave_tooltip_area() { }
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-29 02:02:55 +00:00
virtual void page_did_hover_link(URL::URL const&) { }
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
virtual void page_did_unhover_link() { }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
virtual void page_did_change_favicon(Gfx::Bitmap const&) { }
LibWeb: Update PageView content size on page relayout If the layout changes and the page becomes taller or shorter for some reason, we need to update the PageView's scrollable content size.
2020-06-23 16:02:08 +00:00
virtual void page_did_layout() { }
LibWeb+Ladybird+Userland: Port window.[alert,confirm,prompt] to String LibGUI and WebDriver (read: JSON) API boundaries use DeprecatedString, so that is as far as these changes can reach. The one change which isn't just a DeprecatedString to String replacement is handling the "null" prompt response. We previously checked for the null DeprecatedString, whereas we now represent this as an empty Optional<String>.
2023-03-13 21:30:51 +00:00
virtual void page_did_request_alert(String const&) { }
virtual void page_did_request_confirm(String const&) { }
virtual void page_did_request_prompt(String const&, String const&) { }
virtual void page_did_request_set_prompt_text(String const&) { }
LibWeb+WebContent: Move pending dialog handling from PageHost to Page Currently, all handling of pending dialogs occurs in PageHost. In order to re-use this functionality to run WebDriver in a headless move, move it to Page.
2022-11-21 20:18:42 +00:00
virtual void page_did_request_accept_dialog() { }
virtual void page_did_request_dismiss_dialog() { }
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 03:22:27 +00:00
virtual Vector<Web::Cookie::Cookie> page_did_request_all_cookies(URL::URL const&) { return {}; }
virtual Optional<Web::Cookie::Cookie> page_did_request_named_cookie(URL::URL const&, String const&) { return {}; }
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-29 02:02:55 +00:00
virtual String page_did_request_cookie(URL::URL const&, Cookie::Source) { return {}; }
virtual void page_did_set_cookie(URL::URL const&, Cookie::ParsedCookie const&, Cookie::Source) { }
Browser+LibWebView+WebContent: Do not domain match on cookie updates Updating cookies through these hooks happens in one of two manners: 1. Through the Browser's storage inspector. 2. Through WebDriver's delete-cookies operation. In (1), we should not restrict ourselves to being able to delete cookies for the current page. For example, it's handy to open the inspector from the welcome page and be able to delete cookies for any domain. In (2), we already are only interacting with cookies that have been matched against the document URL.
2022-11-28 16:24:04 +00:00
virtual void page_did_update_cookie(Web::Cookie::Cookie) { }
LibWeb+LibWebView: Add an internal API to expire cookies with an offset Cookies have a minimum expiry resolution of 1 second. So to test cookie expiration, the test had to idle for at least a second, which is quite a noticeable delay now that LibWeb tests are parallelized. Instead, we can add an internal API to expire cookies with a time offset to avoid this idle delay.
2024-10-13 12:56:46 +00:00
virtual void page_did_expire_cookies_with_time_offset(AK::Duration) { }
Browser: Show currently loading host and remaining resource count
2022-02-20 22:03:39 +00:00
virtual void page_did_update_resource_count(i32) { }
LibWeb: Create a new WebView for window.open()'d top level traversables
2024-01-31 03:55:24 +00:00
struct NewWebViewResult {
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
GC::Ptr<Page> page;
LibWeb: Create a new WebView for window.open()'d top level traversables
2024-01-31 03:55:24 +00:00
String window_handle;
};
virtual NewWebViewResult page_did_request_new_web_view(HTML::ActivateTab, HTML::WebViewHints, HTML::TokenizedFeature::NoOpener) { return {}; }
WebContent+Everywhere: Add a WebContent IPC to activate a tab
2023-03-20 23:52:00 +00:00
virtual void page_did_request_activate_tab() { }
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-03 01:00:48 +00:00
virtual void page_did_close_top_level_traversable() { }
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 21:12:55 +00:00
virtual void page_did_update_navigation_buttons_state([[maybe_unused]] bool back_enabled, [[maybe_unused]] bool forward_enabled) { }
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 15:50:57 +00:00
virtual void page_did_allocate_backing_stores([[maybe_unused]] i32 front_bitmap_id, [[maybe_unused]] Gfx::ShareableBitmap front_bitmap, [[maybe_unused]] i32 back_bitmap_id, [[maybe_unused]] Gfx::ShareableBitmap back_bitmap) { }
Everything: Add `-Wnon-virtual-dtor` flag This flag warns on classes which have `virtual` functions but do not have a `virtual` destructor. This patch adds both the flag and missing destructors. The access level of the destructors was determined by a two rules of thumb: 1. A destructor should have a similar or lower access level to that of a constructor. 2. Having a `private` destructor implicitly deletes the default constructor, which is probably undesirable for "interface" types (classes with only virtual functions and no data). In short, most of the added destructors are `protected`, unless the compiler complained about access.
2021-04-15 17:43:29 +00:00
LibWeb+WebContent: Do not reference-count file request objects There is currently a memory leak with these file request objects due to the callback on_file_request_finish referencing itself in its capture list. This object does not need to be reference counted or allocated on the heap. It is only ever stored in a HashMap until a response is received from the browser, and it is not shared.
2023-01-30 21:35:47 +00:00
virtual void request_file(FileRequest) = 0;
Browser+LibWeb+WebContent: Allow Browser to load local files To achieve this goal: - The Browser unveils "/tmp/portal/filesystemaccess" - Pass the page through LoadRequest => ResourceLoader - ResourceLoader requests a file to the FileSystemAccessServer via IPC - OutOfProcessWebView handles it and sends a file descriptor back to the Page.
2022-02-26 16:50:31 +00:00
LibWeb: Implement <input type=file> behavior This includes punting on the actual file picker implementation all the way out to the PageClient. It's likely that some of the real details should be implemented somewhere closer, like the BrowsingContext or the Page, but we'll get there. For now, this allows https://copy.sh/v86 to load the emulation of the preselected images all the way until it hits a call to URL.createObjectURL.
2022-10-04 05:39:53 +00:00
// https://html.spec.whatwg.org/multipage/input.html#show-the-picker,-if-applicable
LibWeb: Remove unnecessary trailing semi-colons from Page.h These should be caught by clang-format (via the RemoveSemicolon option), but it does not seem to get these.
2024-03-26 23:18:17 +00:00
virtual void page_did_request_color_picker([[maybe_unused]] Color current_color) { }
virtual void page_did_request_file_picker([[maybe_unused]] HTML::FileFilter accepted_file_types, Web::HTML::AllowMultipleFiles) { }
virtual void page_did_request_select_dropdown([[maybe_unused]] Web::CSSPixelPoint content_position, [[maybe_unused]] Web::CSSPixels minimum_width, [[maybe_unused]] Vector<Web::HTML::SelectItem> items) { }
LibWeb: Implement <input type=file> behavior This includes punting on the actual file picker implementation all the way out to the PageClient. It's likely that some of the real details should be implemented somewhere closer, like the BrowsingContext or the Page, but we'll get there. For now, this allows https://copy.sh/v86 to load the emulation of the preselected images all the way until it hits a call to URL.createObjectURL.
2022-10-04 05:39:53 +00:00
LibWeb+WebContent: Do not include DOM HTML in text test expectations For example, in the following abbreviated test HTML: <span>some text</span> <script>println("whf")</script> We would have to craft the expectation file to include the "some text" segment, usually with some leading whitespace. This is a bit annoying, and makes it difficult to manually craft expectation files. So instead of comparing the expectation against the entire DOM inner text, we now send the inner text of just the <pre> element containing the test output when we invoke `internals.signalTextTestIsDone`.
2024-10-02 16:38:10 +00:00
virtual void page_did_finish_text_test([[maybe_unused]] String const& text) { }
LibWeb+WebContent+headless-browser: Support async text tests Previously, we used `on_load_finish` to determine when the text test was completed. This method did not allow testing of async functions because there was no way to indicate that the runner should wait for the async call to end. This change introduces a function in the `internals` object that is intended to be called when the text test execution is completed. The text test runner will now ignore `on_load_finish` which means a test will timeout if this new function is never called. `test(f)` function in `include.js` has been modified to automatically terminate a test once `load` event is fired on `window`. new `asyncTest(f)` function has been introduces. `f` receives function that will terminate a test as a first argument. Every test is expected to call either `test()` or `asyncTest()` to complete. If not, it will remain hanging until a timeout occurs.
2023-09-14 17:17:32 +00:00
LibWeb+LibWebView+WebContent: Add support for meta theme-color
2023-09-18 23:51:48 +00:00
virtual void page_did_change_theme_color(Gfx::Color) { }
LibWeb: Begin implementing the Clipboard API https://w3c.github.io/clipboard-apis/ This implements enough for navigator.clipboard.writeText(String).
2023-11-10 18:29:20 +00:00
virtual void page_did_insert_clipboard_entry([[maybe_unused]] String data, [[maybe_unused]] String presentation_style, [[maybe_unused]] String mime_type) { }
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 23:27:06 +00:00
virtual void page_did_change_audio_play_state(HTML::AudioPlayState) { }
Ladybird+Userland: Remove use of unnecessary fd passing socket concept Now that LibIPC is using SCM_RIGHTS properly, we can go back to only having one socket laying around when needing to transfer fds to peers.
2024-04-18 00:44:39 +00:00
virtual IPC::File request_worker_agent() { return IPC::File {}; }
LibWeb+WebContent: Spawn Worker processes from the chrome Instead of spawning these processes from the WebContent process, we now create them in the Browser chrome. Part 1/N of "all processes are owned by the chrome".
2024-01-06 20:13:59 +00:00
LibWeb+LibWebView+WebContent: Add an Inspector IDL object to the Window This is an internal object that must be explicitly enabled by the chrome before it is added to the Window. The Inspector object will be used by a special WebView that will replace all chrome-specific inspector windows. The IDL defines methods that this WebView will need to inform the chrome of various events, such as the user clicking a DOM node.
2023-11-23 17:22:23 +00:00
virtual void inspector_did_load() { }
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 08:37:44 +00:00
virtual void inspector_did_select_dom_node([[maybe_unused]] UniqueNodeID node_id, [[maybe_unused]] Optional<CSS::Selector::PseudoElement::Type> const& pseudo_element) { }
virtual void inspector_did_set_dom_node_text([[maybe_unused]] UniqueNodeID node_id, [[maybe_unused]] String const& text) { }
virtual void inspector_did_set_dom_node_tag([[maybe_unused]] UniqueNodeID node_id, [[maybe_unused]] String const& tag) { }
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 15:01:23 +00:00
virtual void inspector_did_add_dom_node_attributes([[maybe_unused]] UniqueNodeID node_id, [[maybe_unused]] GC::Ref<DOM::NamedNodeMap> attributes) { }
virtual void inspector_did_replace_dom_node_attribute([[maybe_unused]] UniqueNodeID node_id, [[maybe_unused]] size_t attribute_index, [[maybe_unused]] GC::Ref<DOM::NamedNodeMap> 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 08:37:44 +00:00
virtual void inspector_did_request_dom_tree_context_menu([[maybe_unused]] UniqueNodeID node_id, [[maybe_unused]] CSSPixelPoint position, [[maybe_unused]] String const& type, [[maybe_unused]] Optional<String> const& tag, [[maybe_unused]] Optional<size_t> const& attribute_index) { }
LibWebView: Add context menu support to the Inspector's cookie table The menu can currently support deleting a specific cookie or all cookies for the current page.
2024-09-06 17:22:16 +00:00
virtual void inspector_did_request_cookie_context_menu([[maybe_unused]] size_t cookie_index, [[maybe_unused]] CSSPixelPoint position) { }
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 10:18:35 +00:00
virtual void inspector_did_request_style_sheet_source([[maybe_unused]] CSS::StyleSheetIdentifier const& identifier) { }
LibWeb+LibWebView+WebContent: Add an Inspector IPC to execute JavaScript The Inspector will have an <input> element to execute user-provided JS. This adds an IDL method and IPC to forward that JS from the Inspector WebView to the Inspector client.
2023-12-01 00:27:32 +00:00
virtual void inspector_did_execute_console_script([[maybe_unused]] String const& script) { }
LibWeb+LibWebView: Add a button to the Inspector to export its contents When working on the Inspector's HTML, it's often kind of tricky to debug when an element is styled / positioned incorrectly. We don't have a way to inspect the Inspector itself. This adds a button to the Inspector to export its HTML/CSS/JS contents to the downloads directory. This allows for more easily testing changes, especially by opening the exported HTML in another browser's dev tools. We will ultimately likely remove this button (or make it hidden) by the time we are production-ready. But it's quite useful for now.
2024-08-19 16:11:39 +00:00
virtual void inspector_did_export_inspector_html([[maybe_unused]] String const& html) { }
LibWeb+LibWebView+WebContent: Add an Inspector IDL object to the Window This is an internal object that must be explicitly enabled by the chrome before it is added to the Window. The Inspector object will be used by a special WebView that will replace all chrome-specific inspector windows. The IDL defines methods that this WebView will need to inform the chrome of various events, such as the user clicking a DOM node.
2023-11-23 17:22:23 +00:00
LibWeb: Add basic implementation of has_a_rendering_opportunity() Return true only if we are ready to repaint. This fixes the issue where requestAnimationFrame() was invoked more than once between repaints.
2024-03-18 19:11:06 +00:00
virtual bool is_ready_to_paint() const = 0;
LibWeb: Schedule repainting from EventLoop::process() In this change, updating layout and painting are moved to the EventLoop processing steps. This modification allows the addition of resize observation dispatching that needs to happen in event loop processing steps and must occur in the following order relative to layout and painting: 1. Update layout. 2. Gather and broadcast resize observations. 3. Paint.
2024-02-18 18:40:11 +00:00
LibWeb: Rename CommandExecutor to DisplayListPlayer Use more widely recognized name among browser engine developers.
2024-06-23 16:42:39 +00:00
virtual DisplayListPlayerType display_list_player_type() const = 0;
LibWeb+WebContent+WebWorker: Allow to query painter type from PageClient Now it's possible to query selected type from SVGPageClient.
2024-06-19 11:46:27 +00:00
Everything: Add `-Wnon-virtual-dtor` flag This flag warns on classes which have `virtual` functions but do not have a `virtual` destructor. This patch adds both the flag and missing destructors. The access level of the destructors was determined by a two rules of thumb: 1. A destructor should have a similar or lower access level to that of a constructor. 2. Having a `private` destructor implicitly deletes the default constructor, which is probably undesirable for "interface" types (classes with only virtual functions and no data). In short, most of the added destructors are `protected`, unless the compiler complained about access.
2021-04-15 17:43:29 +00:00
protected:
virtual ~PageClient() = default;
LibWeb: Add Page abstraction between PageView and main Frame * A PageView is a view onto a Page object. * A Page always has a main Frame (root of Frame tree.) * Page has a PageClient. PageView is a PageClient. The goal here is to allow building another kind of view onto a Page while keeping the rest of LibWeb intact.
2020-06-08 18:31:49 +00:00
};
}
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 14:51:38 +00:00
namespace IPC {
template<>
ErrorOr<void> encode(Encoder&, Web::Page::MediaContextMenu const&);
template<>
ErrorOr<Web::Page::MediaContextMenu> decode(Decoder&);
}
Reference in a new issue Copy permalink