dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ladybird/UI/Qt/WebContentView.cpp

1302 lines
47 KiB
C++
Raw Permalink Normal View History

Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 08:19:50 -03:00
* Copyright (c) 2022-2023, Andreas Kling <andreas@ladybird.org>
Ladybird: Implement zoom :^)
2023-01-12 11:39:53 -03:00
* Copyright (c) 2023, Linus Groh <linusg@serenityos.org>
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
* Copyright (c) 2024-2025, Sam Atkins <sam@ladybird.org>
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/Assertions.h>
#include <AK/ByteBuffer.h>
#include <AK/Format.h>
#include <AK/LexicalPath.h>
#include <AK/NonnullOwnPtr.h>
#include <AK/Types.h>
#include <LibCore/EventLoop.h>
Ladybird: Convert theme configuration to resource URIs
2023-11-05 11:46:28 -03:00
#include <LibCore/Resource.h>
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
#include <LibCore/Timer.h>
#include <LibGfx/Bitmap.h>
#include <LibGfx/Font/FontDatabase.h>
LibGfx: Move all image loaders and writers to a subdirectory
2023-03-21 15:58:06 -03:00
#include <LibGfx/ImageFormats/PNGWriter.h>
Ladybird: Get the system's current color theme settings from Qt There isn't a 1:1 equivalent for all ColorRoles between Qt and LibGfx, but we can at least make an effort to translate the various QPalette preferred colors. This makes text selection look a lot more "native" in Ladybird. :^)
2023-03-15 18:56:47 -03:00
#include <LibGfx/Palette.h>
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
#include <LibGfx/Rect.h>
Ladybird: Reimplement the DOM inspector :^) This has been broken since the switch to the multiprocess architecture (and even before then was very limited). This restores the previous functionally and also implements the ability to inspect individual elements (by selecting them in the tree view). The inspector also now correctly updates when navigating between pages.
2022-12-17 21:50:53 -03:00
#include <LibGfx/SystemTheme.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 16:29:08 -03:00
#include <LibWeb/UIEvents/KeyCode.h>
LibWeb: Add Web::UIEvents::MouseButton enum, drop dependency on LibGUI This was the only thing LibWeb needed from LibGUI, and we can just duplicate the enum in LibWeb and get rid of a bogus dependency.
2024-06-02 14:00:42 -03:00
#include <LibWeb/UIEvents/MouseButton.h>
LibWebView+UI: Migrate Ladybird's command line flags to LibWebView Currently, if we want to add a new e.g. WebContent command line option, we have to add it to all of Qt, AppKit, and headless-browser. (Or worse, we only add it to one of these, and we have feature disparity). To prevent this, this moves command line flags to WebView::Application. The flags are assigned to ChromeOptions and WebContentOptions structs. Each chrome can still add its platform-specific options; for example, the Qt chrome has a flag to enable Qt networking. There should be no behavior change here, other than that AppKit will now support command line flags that were previously only supported by Qt.
2024-07-30 15:01:05 -03:00
#include <LibWebView/Application.h>
UI: Share macOS web selection color Move the active macOS web selection color into LibWebView so AppKit and Qt use the same value when building the WebContent system palette. Qt now also asks AppKit for inactive selection colors on macOS, matching the AppKit frontend while leaving other Qt platforms on QPalette.
2026-06-20 20:22:50 -03:00
#include <LibWebView/PlatformColors.h>
LibWeb+LibWebView+UI: Move SelectedFile factory to LibWebView This factory is only used by the UI. An upcoming commit will make it depend on LibFileSystem. LibWeb currently does not link LibFileSystem, and doing so would push LibWeb in the wrong direction (we should be doing less file IO in LibWeb, not more).
2026-05-20 13:37:49 -03:00
#include <LibWebView/Utilities.h>
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
#include <LibWebView/WebContentClient.h>
Everywhere: Move the Ladybird folder to UI
2024-11-09 14:50:33 -03:00
#include <UI/Qt/Application.h>
UI: Share macOS web selection color Move the active macOS web selection color into LibWebView so AppKit and Qt use the same value when building the WebContent system palette. Qt now also asks AppKit for inactive selection colors on macOS, matching the AppKit frontend while leaving other Qt platforms on QPalette.
2026-06-20 20:22:50 -03:00
#ifdef AK_OS_MACOS
# include <UI/Qt/MacWindow.h>
#endif
Everywhere: Move the Ladybird folder to UI
2024-11-09 14:50:33 -03:00
#include <UI/Qt/StringUtils.h>
#include <UI/Qt/WebContentView.h>
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
#include <QApplication>
#include <QCursor>
Ladybird: Update screen rects on client creation This makes pages that use CSS rules like '@media (max-device-width: 600px)' render more correctly. Without this change device-width and height queries would return 0.
2023-06-12 07:52:44 -03:00
#include <QGuiApplication>
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
#include <QIcon>
LibWebView: Fast-close pages without beforeunload prompts Track whether WebContent still needs a beforeunload check and let the frontends immediately remove a tab or window when no prompt can be shown. WebContent still receives the close request so pagehide, unload, and cleanup steps can run. When the visible view is removed immediately, keep detached ownership of the WebContent page until it reports that the top-level traversable closed. If no acknowledgement arrives, release detached ownership and ask ProcessManager to shut down the unused WebContent process.
2026-05-26 13:03:07 -03:00
#include <QKeySequence>
Ladybird: Accept file drops
2023-01-07 13:40:04 -03:00
#include <QMimeData>
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
#include <QMouseEvent>
UI/Qt: Handle pinch zoom gestures Translate Qt native zoom gestures into Web::PinchEvent for the web content view. This gives the Qt UI the same pinch-to-zoom input path as the AppKit UI while leaving ordinary wheel scrolling unchanged. Map the Qt native gesture screen position back into WebContentView before creating the event, since macOS delivers the gesture through the top-level widget window after forwarding. Keeping the pinch focal point in content coordinates lets visual viewport zoom preserve the user's focus point.
2026-05-31 21:55:31 -03:00
#include <QNativeGestureEvent>
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
#include <QPaintEvent>
#include <QPainter>
Ladybird: Get the system's current color theme settings from Qt There isn't a 1:1 equivalent for all ColorRoles between Qt and LibGfx, but we can at least make an effort to translate the various QPalette preferred colors. This makes text selection look a lot more "native" in Ladybird. :^)
2023-03-15 18:56:47 -03:00
#include <QPalette>
UI/Qt: Add tab hover previews Show a delayed preview popup when hovering background tabs. Build the thumbnail from the cached front or backup WebContent bitmap so chrome does not need a fresh screenshot request or WebContent repaint on hover. Tie the popup to the tab hover lifecycle and hide it on current-tab hovers, tab presses, drags, layout changes, and tab strip exits.
2026-06-10 21:26:41 -03:00
#include <QPixmap>
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
#include <QScrollBar>
UI/Qt+WebContent: Refresh theme colors live Refresh Qt chrome palettes from the current color scheme when the application palette changes. Recompute autocomplete and location field colors and repaint WebContent immediately so theme changes do not require another interaction or restart.
2026-05-25 16:22:50 -03:00
#if QT_VERSION >= QT_VERSION_CHECK(6, 5, 0)
# include <QStyleHints>
#endif
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
#include <QTextEdit>
#include <QTimer>
#include <QToolTip>
Ladybird: Move classes and types into the Ladybird namespace We were super inconsistent about this, with most "new" classes living in the Ladybird namespace, while "old" ones were in the global namespace, or even sitting in the Browser namespace.
2023-08-02 14:52:59 -03:00
namespace Ladybird {
Ladybird: Let WebContent know if the current system theme is dark This means we now actually respect @media (prefers-color-scheme: dark) by default when in dark mode. :^)
2023-04-29 13:35:06 -03:00
bool is_using_dark_system_theme(QWidget&);
UI/Qt: Keep macOS chrome out of RHI flushes Stop forcing RHI for every QWidget on macOS. The web content view is the only widget that needs Metal, and QRhiWidget already requests that. Make the web content view a native child before parenting it into the tab UI so Qt does not propagate its RHI config to the browser window backing store. This keeps chrome repaints on the normal Cocoa backing store path instead of copying the full window backing store into a texture.
2026-06-01 05:40:42 -03:00
static QWidget* initial_web_content_view_parent([[maybe_unused]] QWidget* window)
{
#ifdef AK_OS_MACOS
return nullptr;
#else
return window;
#endif
}
UI/Qt: Set WC's max FPS to the refresh rate of the current screen
2025-07-25 12:43:27 -03:00
WebContentView::WebContentView(QWidget* window, RefPtr<WebView::WebContentClient> parent_client, size_t page_index, WebContentViewInitialState initial_state)
UI/Qt: Keep macOS chrome out of RHI flushes Stop forcing RHI for every QWidget on macOS. The web content view is the only widget that needs Metal, and QRhiWidget already requests that. Make the web content view a native child before parenting it into the tab UI so Qt does not propagate its RHI config to the browser window backing store. This keeps chrome repaints on the normal Cocoa backing store path instead of copying the full window backing store into a texture.
2026-06-01 05:40:42 -03:00
: WebContentViewBase(initial_web_content_view_parent(window))
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
{
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
#ifdef LADYBIRD_QT_USE_METAL_RHI_WIDGET
UI/Qt: Keep macOS chrome out of RHI flushes Stop forcing RHI for every QWidget on macOS. The web content view is the only widget that needs Metal, and QRhiWidget already requests that. Make the web content view a native child before parenting it into the tab UI so Qt does not propagate its RHI config to the browser window backing store. This keeps chrome repaints on the normal Cocoa backing store path instead of copying the full window backing store into a texture.
2026-06-01 05:40:42 -03:00
// Keep the QRhiWidget out of the top-level QWidget backing store. If it is
// parented before becoming native, Qt propagates its RHI config to the whole
// browser window and uploads the full backing store texture on chrome repaints.
setAttribute(Qt::WA_DontCreateNativeAncestors);
setAttribute(Qt::WA_NativeWindow);
setParent(window);
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
setApi(QRhiWidget::Api::Metal);
#endif
Ladybird: Add ability to create a tab without creating a new WebContent
2024-01-30 13:12:14 -03:00
m_client_state.client = parent_client;
m_client_state.page_index = page_index;
UI/Qt: Enable basic IME keyboard input for WebContentView This makes dead keys work (e.g. typing ' and e results in é).
2024-08-12 09:06:41 -03:00
setAttribute(Qt::WA_InputMethodEnabled, true);
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
setMouseTracking(true);
Ladybird: Accept file drops
2023-01-07 13:40:04 -03:00
setAcceptDrops(true);
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
Ladybird/WebContentView: Accept focus and notify WebContent on change
2022-10-11 06:38:03 -03:00
setFocusPolicy(Qt::FocusPolicy::StrongFocus);
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
#ifdef LADYBIRD_QT_USE_VULKAN_WINDOW
create_vulkan_window();
#endif
Ladybird: Set 'device pixels per CSS pixel' to device pixel ratio :^)
2023-01-12 11:39:05 -03:00
m_device_pixel_ratio = devicePixelRatio();
UI/Qt: Set WC's max FPS to the refresh rate of the current screen
2025-07-25 12:43:27 -03:00
m_maximum_frames_per_second = initial_state.maximum_frames_per_second;
LibWebView+Compositor+UI: Send display metadata to Compositor The browser process forwards the maximum frame rate to WebContent, but the compositor process had no copy of that display timing metadata or the display identity needed by compositor-local vsync. Add one compositor control IPC message carrying the optional display ID and refresh rate together, and store both values on each compositor context.
2026-05-28 14:04:22 -03:00
m_display_id = initial_state.display_id;
LibWebView: Avoid white initial web view fills in dark mode Seed the page background fallback from the platform color scheme before WebContent has painted. Update the same fallback when the platform theme changes, and when the preferred color scheme is forced through the debug menu, so unpainted web view areas use the matching Canvas color.
2026-05-26 20:11:14 -03:00
set_page_background_color_to_system_canvas(is_using_dark_system_theme(*this));
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
Ladybird/Qt: Wire up screen added and removed events
2024-04-05 14:19:50 -03:00
QObject::connect(qGuiApp, &QGuiApplication::screenRemoved, [this](QScreen*) {
update_screen_rects();
});
QObject::connect(qGuiApp, &QGuiApplication::screenAdded, [this](QScreen*) {
update_screen_rects();
});
UI/Qt+WebContent: Refresh theme colors live Refresh Qt chrome palettes from the current color scheme when the application palette changes. Recompute autocomplete and location field colors and repaint WebContent immediately so theme changes do not require another interaction or restart.
2026-05-25 16:22:50 -03:00
#if QT_VERSION >= QT_VERSION_CHECK(6, 5, 0)
QObject::connect(QGuiApplication::styleHints(), &QStyleHints::colorSchemeChanged, this, [this] {
QTimer::singleShot(0, this, [this] {
update_palette();
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
schedule_repaint();
UI/Qt+WebContent: Refresh theme colors live Refresh Qt chrome palettes from the current color scheme when the application palette changes. Recompute autocomplete and location field colors and repaint WebContent immediately so theme changes do not require another interaction or restart.
2026-05-25 16:22:50 -03:00
});
});
#endif
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 09:16:24 -03:00
m_tooltip_hover_timer.setSingleShot(true);
QObject::connect(&m_tooltip_hover_timer, &QTimer::timeout, [this] {
if (m_tooltip_text.has_value())
QToolTip::showText(
QCursor::pos(),
qstring_from_ak_string(m_tooltip_text.value()),
this);
});
Ladybird: Add ability to create a tab without creating a new WebContent
2024-01-30 13:12:14 -03:00
initialize_client((parent_client == nullptr) ? CreateNewClient::Yes : CreateNewClient::No);
Ladybird+LibWebView: Move most of paint handling to LibWebView Storing the backup bitmap is the same across Browser and Ladybird. Just peform that work in LibWebView, and handle only the implementation- specific nuances within the browsers.
2023-05-20 11:50:05 -03:00
on_ready_to_paint = [this]() {
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
schedule_repaint();
Ladybird+LibWebView: Move most of paint handling to LibWebView Storing the backup bitmap is the same across Browser and Ladybird. Just peform that work in LibWebView, and handle only the implementation- specific nuances within the browsers.
2023-05-20 11:50:05 -03:00
};
Ladybird+LibWebView: Migrate cursor changes to LibWebView callbacks
2023-08-23 11:43:27 -03:00
on_cursor_change = [this](auto cursor) {
update_cursor(cursor);
};
Ladybird+LibWebView: Migrate tooltip changes to LibWebView callbacks
2023-08-23 12:11:39 -03:00
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 11:48:57 -03:00
on_request_tooltip_override = [this](auto position, auto const& tooltip) {
m_tooltip_override = true;
if (m_tooltip_hover_timer.isActive())
m_tooltip_hover_timer.stop();
auto tooltip_without_carriage_return = tooltip.contains("\r"sv)
? tooltip.replace("\r\n"sv, "\n"sv, ReplaceMode::All).replace("\r"sv, "\n"sv, ReplaceMode::All)
: tooltip;
QToolTip::showText(
mapToGlobal(QPoint(position.x(), position.y())),
qstring_from_ak_string(tooltip_without_carriage_return),
this);
};
on_stop_tooltip_override = [this]() {
m_tooltip_override = false;
};
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 09:16:24 -03:00
on_enter_tooltip_area = [this](auto const& tooltip) {
m_tooltip_text = tooltip.contains("\r"sv)
Ladybird/Qt: Allow CR inside of elements title attributes
2024-03-08 21:11:30 -03:00
? tooltip.replace("\r\n"sv, "\n"sv, ReplaceMode::All).replace("\r"sv, "\n"sv, ReplaceMode::All)
: tooltip;
Ladybird+LibWebView: Migrate tooltip changes to LibWebView callbacks
2023-08-23 12:11:39 -03:00
};
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 09:16:24 -03:00
on_leave_tooltip_area = [this]() {
m_tooltip_text.clear();
Ladybird+LibWebView: Migrate tooltip changes to LibWebView callbacks
2023-08-23 12:11:39 -03:00
};
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 17:13:59 -03:00
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
on_finish_handling_key_event = [this](auto const& event) {
finish_handling_key_event(event);
};
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
on_finish_handling_drag_event = [this](auto const& event) {
finish_handling_drag_event(event);
};
UI/Qt: Assign dropdown handler for select in WebContentView, not Tab This makes `<select>` elements also work outside of Tab content, for example in the Inspector. Co-authored-by: Tim Flynn <trflynn89@serenityos.org>
2024-08-21 07:10:41 -03:00
m_select_dropdown = new QMenu("Select Dropdown", this);
QObject::connect(m_select_dropdown, &QMenu::aboutToHide, this, [this]() {
if (!m_select_dropdown->activeAction())
select_dropdown_closed({});
});
on_request_select_dropdown = [this](Gfx::IntPoint content_position, i32 minimum_width, Vector<Web::HTML::SelectItem> items) {
m_select_dropdown->clear();
LibWebView+UI: Handle DPR for select elements like other menus The select dropdown was doing its own ad-hoc method of handling DPR. We now handle it just like other context menus. Previously, the drop down in the AppKit chrome was twice as large as it should be.
2025-03-21 11:53:59 -03:00
m_select_dropdown->setMinimumWidth(minimum_width);
UI/Qt: Assign dropdown handler for select in WebContentView, not Tab This makes `<select>` elements also work outside of Tab content, for example in the Inspector. Co-authored-by: Tim Flynn <trflynn89@serenityos.org>
2024-08-21 07:10:41 -03:00
auto add_menu_item = [this](Web::HTML::SelectItemOption const& item_option, bool in_option_group) {
UI/Qt: Use QString format helper in various components
2026-05-26 14:26:09 -03:00
auto label = in_option_group ? qformatted(" {}", item_option.label) : qstring_from_ak_string(item_option.label);
QAction* action = new QAction(label, this);
UI/Qt: Assign dropdown handler for select in WebContentView, not Tab This makes `<select>` elements also work outside of Tab content, for example in the Inspector. Co-authored-by: Tim Flynn <trflynn89@serenityos.org>
2024-08-21 07:10:41 -03:00
action->setCheckable(true);
action->setChecked(item_option.selected);
action->setDisabled(item_option.disabled);
action->setData(QVariant(static_cast<uint>(item_option.id)));
QObject::connect(action, &QAction::triggered, this, &WebContentView::select_dropdown_action);
m_select_dropdown->addAction(action);
};
for (auto const& item : items) {
if (item.has<Web::HTML::SelectItemOptionGroup>()) {
auto const& item_option_group = item.get<Web::HTML::SelectItemOptionGroup>();
QAction* subtitle = new QAction(qstring_from_ak_string(item_option_group.label), this);
subtitle->setDisabled(true);
m_select_dropdown->addAction(subtitle);
for (auto const& item_option : item_option_group.items)
add_menu_item(item_option, true);
}
if (item.has<Web::HTML::SelectItemOption>())
add_menu_item(item.get<Web::HTML::SelectItemOption>(), false);
if (item.has<Web::HTML::SelectItemSeparator>())
m_select_dropdown->addSeparator();
}
m_select_dropdown->exec(map_point_to_global_position(content_position));
};
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
}
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
WebContentView::~WebContentView()
{
#ifdef AK_OS_MACOS
release_metal_resources();
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
#elif defined(LADYBIRD_QT_USE_VULKAN_WINDOW)
destroy_vulkan_window();
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
#endif
}
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
UI/Qt: Assign dropdown handler for select in WebContentView, not Tab This makes `<select>` elements also work outside of Tab content, for example in the Inspector. Co-authored-by: Tim Flynn <trflynn89@serenityos.org>
2024-08-21 07:10:41 -03:00
void WebContentView::select_dropdown_action()
{
QAction* action = qobject_cast<QAction*>(sender());
select_dropdown_closed(action->data().value<uint>());
}
Ladybird/Qt: Rename convert functions to reflect their new types This is a follow up to GH-1111 to reflect the new signatures that these functions have.
2024-08-20 15:48:41 -03:00
static Web::UIEvents::MouseButton get_button_from_qt_mouse_button(Qt::MouseButton button)
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
{
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
if (button == Qt::MouseButton::LeftButton)
LibWeb: Add Web::UIEvents::MouseButton enum, drop dependency on LibGUI This was the only thing LibWeb needed from LibGUI, and we can just duplicate the enum in LibWeb and get rid of a bogus dependency.
2024-06-02 14:00:42 -03:00
return Web::UIEvents::MouseButton::Primary;
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
if (button == Qt::MouseButton::RightButton)
LibWeb: Add Web::UIEvents::MouseButton enum, drop dependency on LibGUI This was the only thing LibWeb needed from LibGUI, and we can just duplicate the enum in LibWeb and get rid of a bogus dependency.
2024-06-02 14:00:42 -03:00
return Web::UIEvents::MouseButton::Secondary;
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
if (button == Qt::MouseButton::MiddleButton)
LibWeb: Add Web::UIEvents::MouseButton enum, drop dependency on LibGUI This was the only thing LibWeb needed from LibGUI, and we can just duplicate the enum in LibWeb and get rid of a bogus dependency.
2024-06-02 14:00:42 -03:00
return Web::UIEvents::MouseButton::Middle;
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
if (button == Qt::MouseButton::BackButton)
LibWeb: Add Web::UIEvents::MouseButton enum, drop dependency on LibGUI This was the only thing LibWeb needed from LibGUI, and we can just duplicate the enum in LibWeb and get rid of a bogus dependency.
2024-06-02 14:00:42 -03:00
return Web::UIEvents::MouseButton::Backward;
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
if (button == Qt::MouseButton::ForwardButton)
LibWeb: Add Web::UIEvents::MouseButton enum, drop dependency on LibGUI This was the only thing LibWeb needed from LibGUI, and we can just duplicate the enum in LibWeb and get rid of a bogus dependency.
2024-06-02 14:00:42 -03:00
return Web::UIEvents::MouseButton::Forward;
return Web::UIEvents::MouseButton::None;
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
}
Ladybird/Qt: Rename convert functions to reflect their new types This is a follow up to GH-1111 to reflect the new signatures that these functions have.
2024-08-20 15:48:41 -03:00
static Web::UIEvents::MouseButton get_buttons_from_qt_mouse_buttons(Qt::MouseButtons buttons)
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
{
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
auto result = Web::UIEvents::MouseButton::None;
if (buttons.testFlag(Qt::MouseButton::LeftButton))
result |= Web::UIEvents::MouseButton::Primary;
if (buttons.testFlag(Qt::MouseButton::RightButton))
result |= Web::UIEvents::MouseButton::Secondary;
if (buttons.testFlag(Qt::MouseButton::MiddleButton))
result |= Web::UIEvents::MouseButton::Middle;
if (buttons.testFlag(Qt::MouseButton::BackButton))
result |= Web::UIEvents::MouseButton::Backward;
if (buttons.testFlag(Qt::MouseButton::ForwardButton))
result |= Web::UIEvents::MouseButton::Forward;
return result;
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
}
Ladybird/Qt: Rename convert functions to reflect their new types This is a follow up to GH-1111 to reflect the new signatures that these functions have.
2024-08-20 15:48:41 -03:00
static Web::UIEvents::KeyModifier get_modifiers_from_qt_keyboard_modifiers(Qt::KeyboardModifiers modifiers)
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
{
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
auto result = Web::UIEvents::KeyModifier::Mod_None;
if (modifiers.testFlag(Qt::AltModifier))
result |= Web::UIEvents::KeyModifier::Mod_Alt;
if (modifiers.testFlag(Qt::ShiftModifier))
result |= Web::UIEvents::KeyModifier::Mod_Shift;
UI/Qt: Preserve macOS web modifier semantics Qt swaps Command into ControlModifier and Control into MetaModifier on macOS so shortcut definitions can stay portable. Convert those modifiers back to Web-facing semantics before sending input events to LibWeb. This lets Command-click behave as platform-control click instead of being mistaken for Control-click, while physical Control-click still opens the context menu on macOS.
2026-05-31 22:09:15 -03:00
#if defined(AK_OS_MACOS)
if (modifiers.testFlag(Qt::ControlModifier))
result |= Web::UIEvents::KeyModifier::Mod_Super;
if (modifiers.testFlag(Qt::MetaModifier))
result |= Web::UIEvents::KeyModifier::Mod_Ctrl;
#else
if (modifiers.testFlag(Qt::ControlModifier))
result |= Web::UIEvents::KeyModifier::Mod_Ctrl;
if (modifiers.testFlag(Qt::MetaModifier))
result |= Web::UIEvents::KeyModifier::Mod_Super;
#endif
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
return result;
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
}
Ladybird/Qt: Rename convert functions to reflect their new types This is a follow up to GH-1111 to reflect the new signatures that these functions have.
2024-08-20 15:48:41 -03:00
static Web::UIEvents::KeyModifier get_modifiers_from_qt_key_event(QKeyEvent const& event)
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
{
UI/Qt: Preserve macOS web modifier semantics Qt swaps Command into ControlModifier and Control into MetaModifier on macOS so shortcut definitions can stay portable. Convert those modifiers back to Web-facing semantics before sending input events to LibWeb. This lets Command-click behave as platform-control click instead of being mistaken for Control-click, while physical Control-click still opens the context menu on macOS.
2026-05-31 22:09:15 -03:00
auto modifiers = get_modifiers_from_qt_keyboard_modifiers(event.modifiers());
Ladybird: Include the keypad modifier in key events sent to WebContent
2023-07-08 17:01:32 -03:00
if (event.modifiers().testFlag(Qt::KeypadModifier))
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 16:29:08 -03:00
modifiers |= Web::UIEvents::KeyModifier::Mod_Keypad;
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
return modifiers;
}
Ladybird/Qt: Rename convert functions to reflect their new types This is a follow up to GH-1111 to reflect the new signatures that these functions have.
2024-08-20 15:48:41 -03:00
static Web::UIEvents::KeyCode get_keycode_from_qt_key_event(QKeyEvent const& event)
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
{
struct Mapping {
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 16:29:08 -03:00
constexpr Mapping(Qt::Key q, Web::UIEvents::KeyCode s)
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
: qt_key(q)
, serenity_key(s)
{
}
Qt::Key qt_key;
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 16:29:08 -03:00
Web::UIEvents::KeyCode serenity_key;
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
};
LibWeb+UI: Detect and handle left vs. right modifier keys Our handling of left vs. right modifiers keys (shift, ctrl, etc.) was largely not to spec. This patch adds explicit UIEvents::KeyCode values for these keys, and updates the UI to match native key events to these keys (as best as we are able).
2024-10-09 09:56:55 -03:00
// FIXME: Qt does not differentiate between left-and-right modifier keys. Unfortunately, it seems like we would have
// to inspect event.nativeScanCode() / event.nativeVirtualKey() to do so, which has platform-dependent values.
// For now, we default to left keys.
Ladybird: Add a few missing Qt-to-Serenity keycode mappings And add a link to the Qt documentation that maps event keys to their enumerated names for convenience.
2023-07-08 17:58:22 -03:00
// https://doc.qt.io/qt-6/qt.html#Key-enum
LibWeb+UI: Detect and handle left vs. right modifier keys Our handling of left vs. right modifiers keys (shift, ctrl, etc.) was largely not to spec. This patch adds explicit UIEvents::KeyCode values for these keys, and updates the UI to match native key events to these keys (as best as we are able).
2024-10-09 09:56:55 -03:00
static constexpr Mapping mappings[] = {
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 16:29:08 -03:00
{ Qt::Key_0, Web::UIEvents::Key_0 },
{ Qt::Key_1, Web::UIEvents::Key_1 },
{ Qt::Key_2, Web::UIEvents::Key_2 },
{ Qt::Key_3, Web::UIEvents::Key_3 },
{ Qt::Key_4, Web::UIEvents::Key_4 },
{ Qt::Key_5, Web::UIEvents::Key_5 },
{ Qt::Key_6, Web::UIEvents::Key_6 },
{ Qt::Key_7, Web::UIEvents::Key_7 },
{ Qt::Key_8, Web::UIEvents::Key_8 },
{ Qt::Key_9, Web::UIEvents::Key_9 },
{ Qt::Key_A, Web::UIEvents::Key_A },
LibWeb+UI: Detect and handle left vs. right modifier keys Our handling of left vs. right modifiers keys (shift, ctrl, etc.) was largely not to spec. This patch adds explicit UIEvents::KeyCode values for these keys, and updates the UI to match native key events to these keys (as best as we are able).
2024-10-09 09:56:55 -03:00
{ Qt::Key_Alt, Web::UIEvents::Key_LeftAlt },
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 16:29:08 -03:00
{ Qt::Key_Ampersand, Web::UIEvents::Key_Ampersand },
{ Qt::Key_Apostrophe, Web::UIEvents::Key_Apostrophe },
{ Qt::Key_AsciiCircum, Web::UIEvents::Key_Circumflex },
{ Qt::Key_AsciiTilde, Web::UIEvents::Key_Tilde },
{ Qt::Key_Asterisk, Web::UIEvents::Key_Asterisk },
{ Qt::Key_At, Web::UIEvents::Key_AtSign },
{ Qt::Key_B, Web::UIEvents::Key_B },
{ Qt::Key_Backslash, Web::UIEvents::Key_Backslash },
{ Qt::Key_Backspace, Web::UIEvents::Key_Backspace },
{ Qt::Key_Bar, Web::UIEvents::Key_Pipe },
{ Qt::Key_BraceLeft, Web::UIEvents::Key_LeftBrace },
{ Qt::Key_BraceRight, Web::UIEvents::Key_RightBrace },
{ Qt::Key_BracketLeft, Web::UIEvents::Key_LeftBracket },
{ Qt::Key_BracketRight, Web::UIEvents::Key_RightBracket },
{ Qt::Key_C, Web::UIEvents::Key_C },
{ Qt::Key_CapsLock, Web::UIEvents::Key_CapsLock },
{ Qt::Key_Colon, Web::UIEvents::Key_Colon },
{ Qt::Key_Comma, Web::UIEvents::Key_Comma },
LibWeb+UI: Detect and handle left vs. right modifier keys Our handling of left vs. right modifiers keys (shift, ctrl, etc.) was largely not to spec. This patch adds explicit UIEvents::KeyCode values for these keys, and updates the UI to match native key events to these keys (as best as we are able).
2024-10-09 09:56:55 -03:00
{ Qt::Key_Control, Web::UIEvents::Key_LeftControl },
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 16:29:08 -03:00
{ Qt::Key_D, Web::UIEvents::Key_D },
{ Qt::Key_Delete, Web::UIEvents::Key_Delete },
{ Qt::Key_Dollar, Web::UIEvents::Key_Dollar },
{ Qt::Key_Down, Web::UIEvents::Key_Down },
{ Qt::Key_E, Web::UIEvents::Key_E },
{ Qt::Key_End, Web::UIEvents::Key_End },
{ Qt::Key_Equal, Web::UIEvents::Key_Equal },
{ Qt::Key_Enter, Web::UIEvents::Key_Return },
{ Qt::Key_Escape, Web::UIEvents::Key_Escape },
{ Qt::Key_Exclam, Web::UIEvents::Key_ExclamationPoint },
{ Qt::Key_exclamdown, Web::UIEvents::Key_ExclamationPoint },
{ Qt::Key_F, Web::UIEvents::Key_F },
{ Qt::Key_F1, Web::UIEvents::Key_F1 },
{ Qt::Key_F10, Web::UIEvents::Key_F10 },
{ Qt::Key_F11, Web::UIEvents::Key_F11 },
{ Qt::Key_F12, Web::UIEvents::Key_F12 },
{ Qt::Key_F2, Web::UIEvents::Key_F2 },
{ Qt::Key_F3, Web::UIEvents::Key_F3 },
{ Qt::Key_F4, Web::UIEvents::Key_F4 },
{ Qt::Key_F5, Web::UIEvents::Key_F5 },
{ Qt::Key_F6, Web::UIEvents::Key_F6 },
{ Qt::Key_F7, Web::UIEvents::Key_F7 },
{ Qt::Key_F8, Web::UIEvents::Key_F8 },
{ Qt::Key_F9, Web::UIEvents::Key_F9 },
{ Qt::Key_G, Web::UIEvents::Key_G },
{ Qt::Key_Greater, Web::UIEvents::Key_GreaterThan },
{ Qt::Key_H, Web::UIEvents::Key_H },
{ Qt::Key_Home, Web::UIEvents::Key_Home },
{ Qt::Key_I, Web::UIEvents::Key_I },
{ Qt::Key_Insert, Web::UIEvents::Key_Insert },
{ Qt::Key_J, Web::UIEvents::Key_J },
{ Qt::Key_K, Web::UIEvents::Key_K },
{ Qt::Key_L, Web::UIEvents::Key_L },
{ Qt::Key_Left, Web::UIEvents::Key_Left },
{ Qt::Key_Less, Web::UIEvents::Key_LessThan },
{ Qt::Key_M, Web::UIEvents::Key_M },
{ Qt::Key_Menu, Web::UIEvents::Key_Menu },
LibWeb+UI: Detect and handle left vs. right modifier keys Our handling of left vs. right modifiers keys (shift, ctrl, etc.) was largely not to spec. This patch adds explicit UIEvents::KeyCode values for these keys, and updates the UI to match native key events to these keys (as best as we are able).
2024-10-09 09:56:55 -03:00
{ Qt::Key_Meta, Web::UIEvents::Key_LeftSuper },
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 16:29:08 -03:00
{ Qt::Key_Minus, Web::UIEvents::Key_Minus },
{ Qt::Key_N, Web::UIEvents::Key_N },
{ Qt::Key_NumberSign, Web::UIEvents::Key_Hashtag },
{ Qt::Key_NumLock, Web::UIEvents::Key_NumLock },
{ Qt::Key_O, Web::UIEvents::Key_O },
{ Qt::Key_P, Web::UIEvents::Key_P },
{ Qt::Key_PageDown, Web::UIEvents::Key_PageDown },
{ Qt::Key_PageUp, Web::UIEvents::Key_PageUp },
{ Qt::Key_ParenLeft, Web::UIEvents::Key_LeftParen },
{ Qt::Key_ParenRight, Web::UIEvents::Key_RightParen },
{ Qt::Key_Percent, Web::UIEvents::Key_Percent },
{ Qt::Key_Period, Web::UIEvents::Key_Period },
{ Qt::Key_Plus, Web::UIEvents::Key_Plus },
{ Qt::Key_Print, Web::UIEvents::Key_PrintScreen },
{ Qt::Key_Q, Web::UIEvents::Key_Q },
{ Qt::Key_Question, Web::UIEvents::Key_QuestionMark },
{ Qt::Key_QuoteDbl, Web::UIEvents::Key_DoubleQuote },
{ Qt::Key_QuoteLeft, Web::UIEvents::Key_Backtick },
{ Qt::Key_R, Web::UIEvents::Key_R },
{ Qt::Key_Return, Web::UIEvents::Key_Return },
{ Qt::Key_Right, Web::UIEvents::Key_Right },
{ Qt::Key_S, Web::UIEvents::Key_S },
{ Qt::Key_ScrollLock, Web::UIEvents::Key_ScrollLock },
{ Qt::Key_Semicolon, Web::UIEvents::Key_Semicolon },
{ Qt::Key_Shift, Web::UIEvents::Key_LeftShift },
{ Qt::Key_Slash, Web::UIEvents::Key_Slash },
{ Qt::Key_Space, Web::UIEvents::Key_Space },
LibWeb+UI: Detect and handle left vs. right modifier keys Our handling of left vs. right modifiers keys (shift, ctrl, etc.) was largely not to spec. This patch adds explicit UIEvents::KeyCode values for these keys, and updates the UI to match native key events to these keys (as best as we are able).
2024-10-09 09:56:55 -03:00
{ Qt::Key_Super_L, Web::UIEvents::Key_LeftSuper },
{ Qt::Key_Super_R, Web::UIEvents::Key_RightSuper },
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 16:29:08 -03:00
{ Qt::Key_SysReq, Web::UIEvents::Key_SysRq },
{ Qt::Key_T, Web::UIEvents::Key_T },
{ Qt::Key_Tab, Web::UIEvents::Key_Tab },
{ Qt::Key_U, Web::UIEvents::Key_U },
{ Qt::Key_Underscore, Web::UIEvents::Key_Underscore },
{ Qt::Key_Up, Web::UIEvents::Key_Up },
{ Qt::Key_V, Web::UIEvents::Key_V },
{ Qt::Key_W, Web::UIEvents::Key_W },
{ Qt::Key_X, Web::UIEvents::Key_X },
{ Qt::Key_Y, Web::UIEvents::Key_Y },
{ Qt::Key_Z, Web::UIEvents::Key_Z },
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
};
for (auto const& mapping : mappings) {
if (event.key() == mapping.qt_key)
return mapping.serenity_key;
}
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 16:29:08 -03:00
return Web::UIEvents::Key_Invalid;
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
}
UI/Qt: Reserve browser chrome shortcuts Let browser chrome shortcuts for tab and window management bypass the WebContent shortcut override path. This makes new tab, new window, reopen closed tab, tab switching, close tab, and quit dispatch through Qt immediately instead of waiting for page event handling.
2026-05-26 14:58:58 -03:00
static bool is_browser_reserved_shortcut(QKeyEvent const& event)
{
UI/Qt: Reserve the location shortcut Let Ctrl+L bypass WebContent in the shortcut override path so the browser chrome can focus the location editor immediately. This matches Qt's other browser-owned tab and window shortcuts.
2026-05-31 09:26:58 -03:00
// Browser chrome shortcuts that manage tabs, windows, or focus should not wait for
UI/Qt: Reserve browser chrome shortcuts Let browser chrome shortcuts for tab and window management bypass the WebContent shortcut override path. This makes new tab, new window, reopen closed tab, tab switching, close tab, and quit dispatch through Qt immediately instead of waiting for page event handling.
2026-05-26 14:58:58 -03:00
// WebContent to decide whether the page wants to suppress them.
if (event.matches(QKeySequence::StandardKey::AddTab)
|| event.matches(QKeySequence::StandardKey::Close)
|| event.matches(QKeySequence::StandardKey::New)
|| event.matches(QKeySequence::StandardKey::Quit))
return true;
auto const modifiers = event.modifiers() & (Qt::ControlModifier | Qt::ShiftModifier | Qt::AltModifier | Qt::MetaModifier);
auto const key = event.key();
if (modifiers == (Qt::ControlModifier | Qt::ShiftModifier) && key == Qt::Key_T)
return true;
UI/Qt: Reserve the location shortcut Let Ctrl+L bypass WebContent in the shortcut override path so the browser chrome can focus the location editor immediately. This matches Qt's other browser-owned tab and window shortcuts.
2026-05-31 09:26:58 -03:00
if (modifiers == Qt::ControlModifier && (key == Qt::Key_L || key == Qt::Key_Tab || key == Qt::Key_PageDown))
UI/Qt: Reserve browser chrome shortcuts Let browser chrome shortcuts for tab and window management bypass the WebContent shortcut override path. This makes new tab, new window, reopen closed tab, tab switching, close tab, and quit dispatch through Qt immediately instead of waiting for page event handling.
2026-05-26 14:58:58 -03:00
return true;
if (modifiers == (Qt::ControlModifier | Qt::ShiftModifier) && (key == Qt::Key_Tab || key == Qt::Key_Backtab))
return true;
UI/Qt: Add macOS shortcuts for switching tabs Support Command+Shift+[ and Command+Shift+] for moving between Qt tabs on macOS. Also support the physical Control+Tab and Control+Shift+Tab shortcuts accepted by other browsers. Treat these as browser-reserved shortcuts so WebContent does not consume the shortcut override before the browser action can run.
2026-06-01 05:13:33 -03:00
#if defined(AK_OS_MACOS)
if (modifiers == Qt::MetaModifier && key == Qt::Key_Tab)
return true;
if (modifiers == (Qt::MetaModifier | Qt::ShiftModifier) && (key == Qt::Key_Tab || key == Qt::Key_Backtab))
return true;
if (modifiers == (Qt::ControlModifier | Qt::ShiftModifier) && (key == Qt::Key_BracketLeft || key == Qt::Key_BracketRight))
return true;
#endif
UI/Qt: Reserve browser chrome shortcuts Let browser chrome shortcuts for tab and window management bypass the WebContent shortcut override path. This makes new tab, new window, reopen closed tab, tab switching, close tab, and quit dispatch through Qt immediately instead of waiting for page event handling.
2026-05-26 14:58:58 -03:00
if (modifiers == Qt::ControlModifier && key == Qt::Key_PageUp)
return true;
return false;
}
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
void WebContentView::keyPressEvent(QKeyEvent* event)
{
UI: Route node picker input through WebView Picker input starts in each platform UI, while protocol state lives in LibWebView. Route movement, primary clicks, Escape, and leave events through the WebView picker API so each frontend drives the same hit-test and picker-event path. The selected click is consumed because picker mode uses it to choose an element for DevTools rather than activate page content. AppKit routes normal mouse input through WebViewBridge, which converts view points to device pixels before forwarding to LibWeb. Picker input bypasses that enqueue path, so apply the same scaling before requesting a picker hit test.
2026-05-28 08:18:49 -03:00
if (is_node_picker_active()) {
if (event->key() == Qt::Key_Escape)
node_picker_cancel();
event->accept();
return;
}
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
enqueue_native_event(Web::KeyEvent::Type::KeyDown, *event);
}
void WebContentView::keyReleaseEvent(QKeyEvent* event)
{
UI: Route node picker input through WebView Picker input starts in each platform UI, while protocol state lives in LibWebView. Route movement, primary clicks, Escape, and leave events through the WebView picker API so each frontend drives the same hit-test and picker-event path. The selected click is consumed because picker mode uses it to choose an element for DevTools rather than activate page content. AppKit routes normal mouse input through WebViewBridge, which converts view points to device pixels before forwarding to LibWeb. Picker input bypasses that enqueue path, so apply the same scaling before requesting a picker hit test.
2026-05-28 08:18:49 -03:00
if (is_node_picker_active()) {
event->accept();
return;
}
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
enqueue_native_event(Web::KeyEvent::Type::KeyUp, *event);
}
UI/Qt: Enable basic IME keyboard input for WebContentView This makes dead keys work (e.g. typing ' and e results in é).
2024-08-12 09:06:41 -03:00
void WebContentView::inputMethodEvent(QInputMethodEvent* event)
{
UI: Route node picker input through WebView Picker input starts in each platform UI, while protocol state lives in LibWebView. Route movement, primary clicks, Escape, and leave events through the WebView picker API so each frontend drives the same hit-test and picker-event path. The selected click is consumed because picker mode uses it to choose an element for DevTools rather than activate page content. AppKit routes normal mouse input through WebViewBridge, which converts view points to device pixels before forwarding to LibWeb. Picker input bypasses that enqueue path, so apply the same scaling before requesting a picker hit test.
2026-05-28 08:18:49 -03:00
if (is_node_picker_active()) {
event->accept();
return;
}
UI/Qt: Enable basic IME keyboard input for WebContentView This makes dead keys work (e.g. typing ' and e results in é).
2024-08-12 09:06:41 -03:00
if (!event->commitString().isEmpty()) {
QKeyEvent keyEvent(QEvent::KeyPress, 0, Qt::NoModifier, event->commitString());
keyPressEvent(&keyEvent);
}
event->accept();
}
QVariant WebContentView::inputMethodQuery(Qt::InputMethodQuery) const
{
return QVariant();
}
UI: Inform WebContent when the mouse leaves the WebView widget Previously, when the mouse left the WebView, the currently hovered node would remain hovered (including the scroll bar). This felt a bit awkward and is not how other browsers behave.
2025-07-27 10:55:26 -03:00
void WebContentView::leaveEvent(QEvent* event)
{
UI: Route node picker input through WebView Picker input starts in each platform UI, while protocol state lives in LibWebView. Route movement, primary clicks, Escape, and leave events through the WebView picker API so each frontend drives the same hit-test and picker-event path. The selected click is consumed because picker mode uses it to choose an element for DevTools rather than activate page content. AppKit routes normal mouse input through WebViewBridge, which converts view points to device pixels before forwarding to LibWeb. Picker input bypasses that enqueue path, so apply the same scaling before requesting a picker hit test.
2026-05-28 08:18:49 -03:00
if (is_node_picker_active()) {
clear_node_picker();
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
WebContentViewBase::leaveEvent(event);
UI: Route node picker input through WebView Picker input starts in each platform UI, while protocol state lives in LibWebView. Route movement, primary clicks, Escape, and leave events through the WebView picker API so each frontend drives the same hit-test and picker-event path. The selected click is consumed because picker mode uses it to choose an element for DevTools rather than activate page content. AppKit routes normal mouse input through WebViewBridge, which converts view points to device pixels before forwarding to LibWeb. Picker input bypasses that enqueue path, so apply the same scaling before requesting a picker hit test.
2026-05-28 08:18:49 -03:00
return;
}
LibWeb+UI: Add an explicit IPC to handle mouse leave events The faux position we created here is adjusted by the device pixel ratio later on, which would invoke integer overflow on screens with a DPR greater than 1. Instead of creating special data for a mouse move event, let's just add an explicit leave event handler.
2025-07-28 13:57:31 -03:00
static QMouseEvent mouse_event { QEvent::Type::Leave, {}, {}, Qt::MouseButton::NoButton, Qt::MouseButton::NoButton, Qt::KeyboardModifier::NoModifier };
enqueue_native_event(Web::MouseEvent::Type::MouseLeave, mouse_event);
UI: Inform WebContent when the mouse leaves the WebView widget Previously, when the mouse left the WebView, the currently hovered node would remain hovered (including the scroll bar). This felt a bit awkward and is not how other browsers behave.
2025-07-27 10:55:26 -03:00
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
WebContentViewBase::leaveEvent(event);
UI: Inform WebContent when the mouse leaves the WebView widget Previously, when the mouse left the WebView, the currently hovered node would remain hovered (including the scroll bar). This felt a bit awkward and is not how other browsers behave.
2025-07-27 10:55:26 -03:00
}
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
void WebContentView::mouseMoveEvent(QMouseEvent* event)
{
UI: Route node picker input through WebView Picker input starts in each platform UI, while protocol state lives in LibWebView. Route movement, primary clicks, Escape, and leave events through the WebView picker API so each frontend drives the same hit-test and picker-event path. The selected click is consumed because picker mode uses it to choose an element for DevTools rather than activate page content. AppKit routes normal mouse input through WebViewBridge, which converts view points to device pixels before forwarding to LibWeb. Picker input bypasses that enqueue path, so apply the same scaling before requesting a picker hit test.
2026-05-28 08:18:49 -03:00
if (is_node_picker_active()) {
node_picker_hover(node_picker_position_for(*event));
event->accept();
return;
}
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 11:48:57 -03:00
if (!m_tooltip_override) {
if (QToolTip::isVisible())
QToolTip::hideText();
m_tooltip_hover_timer.start(600);
}
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 09:16:24 -03:00
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
enqueue_native_event(Web::MouseEvent::Type::MouseMove, *event);
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
WebContentViewBase::mouseMoveEvent(event);
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
}
void WebContentView::mousePressEvent(QMouseEvent* event)
{
UI: Route node picker input through WebView Picker input starts in each platform UI, while protocol state lives in LibWebView. Route movement, primary clicks, Escape, and leave events through the WebView picker API so each frontend drives the same hit-test and picker-event path. The selected click is consumed because picker mode uses it to choose an element for DevTools rather than activate page content. AppKit routes normal mouse input through WebViewBridge, which converts view points to device pixels before forwarding to LibWeb. Picker input bypasses that enqueue path, so apply the same scaling before requesting a picker hit test.
2026-05-28 08:18:49 -03:00
if (is_node_picker_active()) {
if (event->button() == Qt::MouseButton::LeftButton) {
auto position = node_picker_position_for(*event);
if (event->modifiers().testFlag(Qt::ControlModifier))
node_picker_preview(position);
else
node_picker_pick(position);
}
event->accept();
return;
}
LibWeb+UI: Support triple clicking and dragging paragraphs When triple clicking on text, we should select the entire paragraph, or entire line in <input>s and <textarea>s. If the mouse button is held down and the user starts dragging, the selection expands with additional paragraphs or lines. This expands on the work of Kai Wildberger (PR #7681) but was adjusted for the work that happened previously to support double click + drag moves and includes triple click support for our Qt UI. Co-authored-by: Kai Wildberger <kiawildberger@gmail.com>
2026-02-05 09:07:15 -03:00
auto elapsed = event->timestamp() - m_last_click_timestamp;
auto distance = (event->position() - m_last_click_position).manhattanLength();
UI/Qt: Store the click count as int to match UIEvent.detail's type Also, ensure that it never goes below 0.
2026-03-07 03:30:48 -03:00
if (elapsed < static_cast<u64>(QApplication::doubleClickInterval()) && distance < QApplication::startDragDistance()) {
LibWeb+UI: Support triple clicking and dragging paragraphs When triple clicking on text, we should select the entire paragraph, or entire line in <input>s and <textarea>s. If the mouse button is held down and the user starts dragging, the selection expands with additional paragraphs or lines. This expands on the work of Kai Wildberger (PR #7681) but was adjusted for the work that happened previously to support double click + drag moves and includes triple click support for our Qt UI. Co-authored-by: Kai Wildberger <kiawildberger@gmail.com>
2026-02-05 09:07:15 -03:00
++m_click_count;
UI/Qt: Store the click count as int to match UIEvent.detail's type Also, ensure that it never goes below 0.
2026-03-07 03:30:48 -03:00
if (m_click_count < 1)
m_click_count = 1;
} else {
LibWeb+UI: Support triple clicking and dragging paragraphs When triple clicking on text, we should select the entire paragraph, or entire line in <input>s and <textarea>s. If the mouse button is held down and the user starts dragging, the selection expands with additional paragraphs or lines. This expands on the work of Kai Wildberger (PR #7681) but was adjusted for the work that happened previously to support double click + drag moves and includes triple click support for our Qt UI. Co-authored-by: Kai Wildberger <kiawildberger@gmail.com>
2026-02-05 09:07:15 -03:00
m_click_count = 1;
UI/Qt: Store the click count as int to match UIEvent.detail's type Also, ensure that it never goes below 0.
2026-03-07 03:30:48 -03:00
}
LibWeb+UI: Support triple clicking and dragging paragraphs When triple clicking on text, we should select the entire paragraph, or entire line in <input>s and <textarea>s. If the mouse button is held down and the user starts dragging, the selection expands with additional paragraphs or lines. This expands on the work of Kai Wildberger (PR #7681) but was adjusted for the work that happened previously to support double click + drag moves and includes triple click support for our Qt UI. Co-authored-by: Kai Wildberger <kiawildberger@gmail.com>
2026-02-05 09:07:15 -03:00
m_last_click_timestamp = event->timestamp();
m_last_click_position = event->position();
Everywhere: Consolidate double/triple click handling to use click count This moves normal/double/triple click checking into WebContent, the client only has to send a click count in order to activate a double or triple click in the content. This means that the AppKit UI will no longer fire multiple double clicks when clicking in place more than 3 times. This matches the behavior of other browsers on macOS. We will now also fire the click event regardless of whether a dblclick event will follow, as the spec requires.
2026-03-07 03:06:07 -03:00
enqueue_native_event(Web::MouseEvent::Type::MouseDown, *event);
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
}
void WebContentView::mouseReleaseEvent(QMouseEvent* event)
{
UI: Route node picker input through WebView Picker input starts in each platform UI, while protocol state lives in LibWebView. Route movement, primary clicks, Escape, and leave events through the WebView picker API so each frontend drives the same hit-test and picker-event path. The selected click is consumed because picker mode uses it to choose an element for DevTools rather than activate page content. AppKit routes normal mouse input through WebViewBridge, which converts view points to device pixels before forwarding to LibWeb. Picker input bypasses that enqueue path, so apply the same scaling before requesting a picker hit test.
2026-05-28 08:18:49 -03:00
if (is_node_picker_active()) {
event->accept();
return;
}
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
enqueue_native_event(Web::MouseEvent::Type::MouseUp, *event);
Ladybird: Handle forward and backward mouse buttons We now emit a new signal for backward mouse button's mouseup and forward mouse button's mouseup which is handled by going back and forward in the history respectively:))
2022-11-07 22:00:24 -03:00
LibWebView+UI: Remove history traversal WebView callbacks We can handle these entirely within LibWebView.
2024-09-22 14:29:27 -03:00
if (event->button() == Qt::MouseButton::BackButton)
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
(void)traverse_the_history_by_delta(-1);
LibWebView+UI: Remove history traversal WebView callbacks We can handle these entirely within LibWebView.
2024-09-22 14:29:27 -03:00
else if (event->button() == Qt::MouseButton::ForwardButton)
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
(void)traverse_the_history_by_delta(1);
LibWeb: Refactor WebContentServer mouse input message to DevicePixel
2023-12-15 13:46:09 -03:00
}
void WebContentView::wheelEvent(QWheelEvent* event)
{
UI: Route node picker input through WebView Picker input starts in each platform UI, while protocol state lives in LibWebView. Route movement, primary clicks, Escape, and leave events through the WebView picker API so each frontend drives the same hit-test and picker-event path. The selected click is consumed because picker mode uses it to choose an element for DevTools rather than activate page content. AppKit routes normal mouse input through WebViewBridge, which converts view points to device pixels before forwarding to LibWeb. Picker input bypasses that enqueue path, so apply the same scaling before requesting a picker hit test.
2026-05-28 08:18:49 -03:00
if (is_node_picker_active()) {
event->accept();
return;
}
Ladybird/Qt: Explicitly ignore wheel events with the ctrl key pressed This allows ctrl+wheel events to zoom in and out of the page. This was ported incorrectly in commit c1476c3405518871be7a8f5f4feb0670d1051df8.
2024-03-06 09:21:00 -03:00
if (event->modifiers().testFlag(Qt::ControlModifier)) {
event->ignore();
return;
}
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
enqueue_native_event(Web::MouseEvent::Type::MouseWheel, *event);
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
}
Ladybird: Send the double click event to WebContent
2023-05-13 11:55:10 -03:00
void WebContentView::mouseDoubleClickEvent(QMouseEvent* event)
{
LibWeb+UI: Support triple clicking and dragging paragraphs When triple clicking on text, we should select the entire paragraph, or entire line in <input>s and <textarea>s. If the mouse button is held down and the user starts dragging, the selection expands with additional paragraphs or lines. This expands on the work of Kai Wildberger (PR #7681) but was adjusted for the work that happened previously to support double click + drag moves and includes triple click support for our Qt UI. Co-authored-by: Kai Wildberger <kiawildberger@gmail.com>
2026-02-05 09:07:15 -03:00
// NOTE: Qt calls this instead of mousePressEvent on the 2nd click. Forward to mousePressEvent so our click
// counting logic handles double and triple clicks uniformly.
mousePressEvent(event);
Ladybird: Send the double click event to WebContent
2023-05-13 11:55:10 -03:00
}
Ladybird: Accept file drops
2023-01-07 13:40:04 -03:00
void WebContentView::dragEnterEvent(QDragEnterEvent* event)
{
UI: Route node picker input through WebView Picker input starts in each platform UI, while protocol state lives in LibWebView. Route movement, primary clicks, Escape, and leave events through the WebView picker API so each frontend drives the same hit-test and picker-event path. The selected click is consumed because picker mode uses it to choose an element for DevTools rather than activate page content. AppKit routes normal mouse input through WebViewBridge, which converts view points to device pixels before forwarding to LibWeb. Picker input bypasses that enqueue path, so apply the same scaling before requesting a picker hit test.
2026-05-28 08:18:49 -03:00
if (is_node_picker_active()) {
event->ignore();
return;
}
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
if (!event->mimeData()->hasUrls())
return;
enqueue_native_event(Web::DragEvent::Type::DragStart, *event);
event->acceptProposedAction();
}
void WebContentView::dragMoveEvent(QDragMoveEvent* event)
{
UI: Route node picker input through WebView Picker input starts in each platform UI, while protocol state lives in LibWebView. Route movement, primary clicks, Escape, and leave events through the WebView picker API so each frontend drives the same hit-test and picker-event path. The selected click is consumed because picker mode uses it to choose an element for DevTools rather than activate page content. AppKit routes normal mouse input through WebViewBridge, which converts view points to device pixels before forwarding to LibWeb. Picker input bypasses that enqueue path, so apply the same scaling before requesting a picker hit test.
2026-05-28 08:18:49 -03:00
if (is_node_picker_active()) {
event->ignore();
return;
}
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
enqueue_native_event(Web::DragEvent::Type::DragMove, *event);
event->acceptProposedAction();
}
void WebContentView::dragLeaveEvent(QDragLeaveEvent*)
{
UI: Route node picker input through WebView Picker input starts in each platform UI, while protocol state lives in LibWebView. Route movement, primary clicks, Escape, and leave events through the WebView picker API so each frontend drives the same hit-test and picker-event path. The selected click is consumed because picker mode uses it to choose an element for DevTools rather than activate page content. AppKit routes normal mouse input through WebViewBridge, which converts view points to device pixels before forwarding to LibWeb. Picker input bypasses that enqueue path, so apply the same scaling before requesting a picker hit test.
2026-05-28 08:18:49 -03:00
if (is_node_picker_active())
return;
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
// QDragLeaveEvent does not contain any mouse position or button information.
Web::DragEvent event {};
event.type = Web::DragEvent::Type::DragEnd;
enqueue_input_event(AK::move(event));
Ladybird: Accept file drops
2023-01-07 13:40:04 -03:00
}
void WebContentView::dropEvent(QDropEvent* event)
{
UI: Route node picker input through WebView Picker input starts in each platform UI, while protocol state lives in LibWebView. Route movement, primary clicks, Escape, and leave events through the WebView picker API so each frontend drives the same hit-test and picker-event path. The selected click is consumed because picker mode uses it to choose an element for DevTools rather than activate page content. AppKit routes normal mouse input through WebViewBridge, which converts view points to device pixels before forwarding to LibWeb. Picker input bypasses that enqueue path, so apply the same scaling before requesting a picker hit test.
2026-05-28 08:18:49 -03:00
if (is_node_picker_active()) {
event->ignore();
return;
}
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
enqueue_native_event(Web::DragEvent::Type::Drop, *event);
Ladybird: Accept file drops
2023-01-07 13:40:04 -03:00
event->acceptProposedAction();
}
Ladybird/WebContentView: Accept focus and notify WebContent on change
2022-10-11 06:38:03 -03:00
void WebContentView::focusInEvent(QFocusEvent*)
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_set_has_focus(m_client_state.page_index, true);
Ladybird/WebContentView: Accept focus and notify WebContent on change
2022-10-11 06:38:03 -03:00
}
void WebContentView::focusOutEvent(QFocusEvent*)
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_set_has_focus(m_client_state.page_index, false);
Ladybird/WebContentView: Accept focus and notify WebContent on change
2022-10-11 06:38:03 -03:00
}
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
Optional<WebContentView::Paintable> WebContentView::current_paintable() const
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
{
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
Gfx::SharedImageBuffer const* shared_image_buffer = nullptr;
Ladybird: Make resizing the window a lot less laggy While resizing, we now pad the shared bitmap allocations with 256 pixels extra in both axes. This avoids churning through huge allocations for every single resize step. We also don't reallocate at all when making the window smaller. 3 seconds after the user stops resizing, we resize the backing stores again so they fit the window perfectly.
2023-05-14 13:57:14 -03:00
Gfx::IntSize bitmap_size;
if (m_client_state.has_usable_bitmap) {
Everywhere: Replace SharedBackingStore with Gfx::SharedImage Generalize the backing store sharing abstraction into SharedImage, which represents shared GPU memory independently of Skia and can be used to share memory between different processes or different GPU contexts.
2026-04-07 13:35:26 -03:00
VERIFY(m_client_state.front_bitmap.shared_image_buffer);
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
shared_image_buffer = m_client_state.front_bitmap.shared_image_buffer.ptr();
LibWeb: Refactor int types in WebContentServer to DevicePixels
2023-12-14 03:17:00 -03:00
bitmap_size = m_client_state.front_bitmap.last_painted_size.to_type<int>();
Everywhere: Replace SharedBackingStore with Gfx::SharedImage Generalize the backing store sharing abstraction into SharedImage, which represents shared GPU memory independently of Skia and can be used to share memory between different processes or different GPU contexts.
2026-04-07 13:35:26 -03:00
} else if (m_backup_shared_image_buffer) {
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
shared_image_buffer = m_backup_shared_image_buffer.ptr();
LibWeb: Refactor int types in WebContentServer to DevicePixels
2023-12-14 03:17:00 -03:00
bitmap_size = m_backup_bitmap_size.to_type<int>();
Ladybird: Make resizing the window a lot less laggy While resizing, we now pad the shared bitmap allocations with 256 pixels extra in both axes. This avoids churning through huge allocations for every single resize step. We also don't reallocate at all when making the window smaller. 3 seconds after the user stops resizing, we resize the backing stores again so they fit the window perfectly.
2023-05-14 13:57:14 -03:00
}
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
if (!shared_image_buffer)
return {};
return Paintable { shared_image_buffer, bitmap_size };
}
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
void WebContentView::schedule_repaint()
{
#ifdef LADYBIRD_QT_USE_VULKAN_WINDOW
schedule_vulkan_window_update();
#else
update();
#endif
}
#ifndef LADYBIRD_QT_USE_RHI_WIDGET
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
void WebContentView::paintEvent(QPaintEvent*)
{
QPainter painter(this);
painter.scale(1 / m_device_pixel_ratio, 1 / m_device_pixel_ratio);
auto paintable = current_paintable();
Gfx::Bitmap const* bitmap = nullptr;
Gfx::IntSize bitmap_size;
if (paintable.has_value()) {
bitmap = paintable->shared_image_buffer->bitmap().ptr();
bitmap_size = paintable->bitmap_size;
}
Ladybird: Make resizing the window a lot less laggy While resizing, we now pad the shared bitmap allocations with 256 pixels extra in both axes. This avoids churning through huge allocations for every single resize step. We also don't reallocate at all when making the window smaller. 3 seconds after the user stops resizing, we resize the backing stores again so they fit the window perfectly.
2023-05-14 13:57:14 -03:00
if (bitmap) {
Ladybird: Account for backing store bitmap pitch In the upcoming changes, Skia painter will be switched to Metal backend, so we can no longer assume `pitch = width * 4` while reading Gfx::Bitmap that wraps IOSurface populated by writing into MTLTexture that has padded scanlines.
2024-06-26 12:56:20 -03:00
QImage q_image(bitmap->scanline_u8(0), bitmap->width(), bitmap->height(), bitmap->pitch(), QImage::Format_RGB32);
Ladybird: Make resizing the window a lot less laggy While resizing, we now pad the shared bitmap allocations with 256 pixels extra in both axes. This avoids churning through huge allocations for every single resize step. We also don't reallocate at all when making the window smaller. 3 seconds after the user stops resizing, we resize the backing stores again so they fit the window perfectly.
2023-05-14 13:57:14 -03:00
painter.drawImage(QPoint(0, 0), q_image, QRect(0, 0, bitmap_size.width(), bitmap_size.height()));
LibWebView: Use page background color while resizing Notify the UI process with the solid canvas background color recorded for the top-level document. This is the Canvas system color with the effective document background composited over it, matching the color used before normal painting. Store that color on the view and use it when AppKit, Qt, and Gtk need to fill areas exposed while an older bitmap is still on screen during a window resize.
2026-05-24 15:44:30 -03:00
auto background_color = page_background_color();
auto fallback_color = QColor(background_color.red(), background_color.green(), background_color.blue());
UI/Qt: Paint web view fallback at device size WebContentView scales its painter into device-pixel coordinates before painting page bitmaps. When no page bitmap was available, the fallback fill still used the widget rect in CSS pixels. On high-DPI displays, it only filled the top-left portion of the viewport. Use the stored device-pixel viewport size for the no-bitmap fill and for the fallback area around a smaller bitmap.
2026-05-29 07:04:52 -03:00
if (bitmap_size.width() < m_viewport_size.width()) {
painter.fillRect(bitmap_size.width(), 0, m_viewport_size.width() - bitmap_size.width(), bitmap->height(), fallback_color);
Ladybird: Make resizing the window a lot less laggy While resizing, we now pad the shared bitmap allocations with 256 pixels extra in both axes. This avoids churning through huge allocations for every single resize step. We also don't reallocate at all when making the window smaller. 3 seconds after the user stops resizing, we resize the backing stores again so they fit the window perfectly.
2023-05-14 13:57:14 -03:00
}
UI/Qt: Paint web view fallback at device size WebContentView scales its painter into device-pixel coordinates before painting page bitmaps. When no page bitmap was available, the fallback fill still used the widget rect in CSS pixels. On high-DPI displays, it only filled the top-left portion of the viewport. Use the stored device-pixel viewport size for the no-bitmap fill and for the fallback area around a smaller bitmap.
2026-05-29 07:04:52 -03:00
if (bitmap_size.height() < m_viewport_size.height()) {
painter.fillRect(0, bitmap_size.height(), m_viewport_size.width(), m_viewport_size.height() - bitmap_size.height(), fallback_color);
Ladybird: Make resizing the window a lot less laggy While resizing, we now pad the shared bitmap allocations with 256 pixels extra in both axes. This avoids churning through huge allocations for every single resize step. We also don't reallocate at all when making the window smaller. 3 seconds after the user stops resizing, we resize the backing stores again so they fit the window perfectly.
2023-05-14 13:57:14 -03:00
}
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
return;
}
LibWebView: Use page background color while resizing Notify the UI process with the solid canvas background color recorded for the top-level document. This is the Canvas system color with the effective document background composited over it, matching the color used before normal painting. Store that color on the view and use it when AppKit, Qt, and Gtk need to fill areas exposed while an older bitmap is still on screen during a window resize.
2026-05-24 15:44:30 -03:00
auto background_color = page_background_color();
UI/Qt: Paint web view fallback at device size WebContentView scales its painter into device-pixel coordinates before painting page bitmaps. When no page bitmap was available, the fallback fill still used the widget rect in CSS pixels. On high-DPI displays, it only filled the top-left portion of the viewport. Use the stored device-pixel viewport size for the no-bitmap fill and for the fallback area around a smaller bitmap.
2026-05-29 07:04:52 -03:00
painter.fillRect(QRect(0, 0, m_viewport_size.width(), m_viewport_size.height()), QColor(background_color.red(), background_color.green(), background_color.blue()));
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
}
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
#endif
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
UI/Qt: Add tab hover previews Show a delayed preview popup when hovering background tabs. Build the thumbnail from the cached front or backup WebContent bitmap so chrome does not need a fresh screenshot request or WebContent repaint on hover. Tie the popup to the tab hover lifecycle and hide it on current-tab hovers, tab presses, drags, layout changes, and tab strip exits.
2026-06-10 21:26:41 -03:00
Optional<QPixmap> WebContentView::tab_preview_pixmap(QSize const& maximum_size) const
{
auto paintable = current_paintable();
if (!paintable.has_value())
return {};
auto const* bitmap = paintable->shared_image_buffer->bitmap().ptr();
if (!bitmap)
return {};
auto width = min(bitmap->width(), paintable->bitmap_size.width());
auto height = min(bitmap->height(), paintable->bitmap_size.height());
if (width <= 0 || height <= 0 || maximum_size.isEmpty())
return {};
QImage image(bitmap->scanline_u8(0), bitmap->width(), bitmap->height(), bitmap->pitch(), QImage::Format_RGB32);
auto snapshot = image.copy(0, 0, width, height);
if (snapshot.isNull())
return {};
auto preview_size = snapshot.size().scaled(maximum_size, Qt::KeepAspectRatio);
if (preview_size.isEmpty())
return {};
auto preview = QPixmap::fromImage(snapshot).scaled(preview_size, Qt::KeepAspectRatio, Qt::SmoothTransformation);
if (preview.isNull())
return {};
return preview;
}
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
void WebContentView::resizeEvent(QResizeEvent* event)
{
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
WebContentViewBase::resizeEvent(event);
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
#ifdef LADYBIRD_QT_USE_VULKAN_WINDOW
update_vulkan_window_geometry();
#endif
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 11:53:55 -03:00
update_viewport_size();
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 02:59:51 -03:00
handle_resize();
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
}
Ladybird: Specify window size in layout dump mode
2023-01-30 17:38:19 -03:00
void WebContentView::set_viewport_rect(Gfx::IntRect rect)
{
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 11:53:55 -03:00
m_viewport_size = rect.size();
WebContent: Combine viewport size and DPR into a single IPC message The set_viewport_size and set_device_pixel_ratio IPC messages were sent separately, potentially causing a race condition when the DPR changes (e.g. moving a window between screens): the DPR message would arrive and use a stale viewport size, computing a temporarily wrong CSS viewport. Combine both into a single set_viewport IPC that updates the device viewport size and DPR together.
2026-02-20 18:09:39 -03:00
handle_resize();
Ladybird: Specify window size in layout dump mode
2023-01-30 17:38:19 -03:00
}
Ladybird/Qt: Listen to DPI changes and update WebContentView accordingly
2023-12-13 15:10:05 -03:00
void WebContentView::set_device_pixel_ratio(double device_pixel_ratio)
{
m_device_pixel_ratio = device_pixel_ratio;
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 11:53:55 -03:00
update_viewport_size();
Ladybird/Qt: Listen to DPI changes and update WebContentView accordingly
2023-12-13 15:10:05 -03:00
handle_resize();
}
LibWeb+WebContent: Allow WebContent to disentangle zoom from css pixels So Ladybird can paint scrollbar & resizer chrome at the same size regardless of zoom level while still respecting device pixel ratio
2026-01-05 22:05:10 -03:00
void WebContentView::set_zoom_level(double zoom_level)
{
m_zoom_level = zoom_level;
client().async_set_zoom_level(m_client_state.page_index, m_zoom_level);
update_zoom();
}
UI/Qt: Set WC's max FPS to the refresh rate of the current screen
2025-07-25 12:43:27 -03:00
void WebContentView::set_maximum_frames_per_second(double maximum_frames_per_second)
{
LibWebView+Compositor+UI: Send display metadata to Compositor The browser process forwards the maximum frame rate to WebContent, but the compositor process had no copy of that display timing metadata or the display identity needed by compositor-local vsync. Add one compositor control IPC message carrying the optional display ID and refresh rate together, and store both values on each compositor context.
2026-05-28 14:04:22 -03:00
set_display_metadata(m_display_id, maximum_frames_per_second);
}
void WebContentView::set_display_metadata(Optional<u64> display_id, double maximum_frames_per_second)
{
m_display_id = display_id;
UI/Qt: Set WC's max FPS to the refresh rate of the current screen
2025-07-25 12:43:27 -03:00
m_maximum_frames_per_second = maximum_frames_per_second;
client().async_set_maximum_frames_per_second(m_client_state.page_index, m_maximum_frames_per_second);
LibWebView+Compositor+UI: Send display metadata to Compositor The browser process forwards the maximum frame rate to WebContent, but the compositor process had no copy of that display timing metadata or the display identity needed by compositor-local vsync. Add one compositor control IPC message carrying the optional display ID and refresh rate together, and store both values on each compositor context.
2026-05-28 14:04:22 -03:00
update_compositor_display_metadata();
}
void WebContentView::update_compositor_display_metadata()
{
if (!m_client_state.client)
return;
auto compositor_context_id = client().compositor_context_id_for_page(m_client_state.page_index);
WebView::Application::the().update_compositor_display_metadata(compositor_context_id, m_display_id, m_maximum_frames_per_second);
UI/Qt: Set WC's max FPS to the refresh rate of the current screen
2025-07-25 12:43:27 -03:00
}
LibWeb+WebContent: Move scrollbar painting into WebContent The main intention of this change is to have a consistent look and behavior across all scrollbars, including elements with `overflow: scroll` and `overflow: auto`, iframes, and a page. Before: - Page's scrollbar is painted by Browser (Qt/AppKit) using the corresponding UI framework style, - Both WebContent and Browser know the scroll position offset. - WebContent uses did_request_scroll_to() IPC call to send updates. - Browser uses set_viewport_rect() to send updates. After: - Page's scrollbar is painted on WebContent side using the same style as currently used for elements with `overflow: scroll` and `overflow: auto`. A nice side effects: scrollbars are now painted for iframes, and page's scrollbar respects scrollbar-width CSS property. - Only WebContent knows scroll position offset. - did_request_scroll_to() is no longer used. - set_viewport_rect() is changed to set_viewport_size().
2024-06-03 11:53:55 -03:00
void WebContentView::update_viewport_size()
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
{
UI/Qt: Do not place the WebView inside a scroll view Now that scrolling and rendering scrollbars is handled entirely in the WebContent process, there's no reason to place the WebView inside scroll views.
2024-11-07 14:46:45 -03:00
auto scaled_width = int(width() * m_device_pixel_ratio);
auto scaled_height = int(height() * m_device_pixel_ratio);
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 11:53:55 -03:00
Gfx::IntRect rect(0, 0, scaled_width, scaled_height);
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
Ladybird: Specify window size in layout dump mode
2023-01-30 17:38:19 -03:00
set_viewport_rect(rect);
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
}
Ladybird: Implement zoom :^)
2023-01-12 11:39:53 -03:00
void WebContentView::update_zoom()
{
LibWebView+UI: Generate the zoom menu
2025-09-10 08:23:15 -03:00
ViewImplementation::update_zoom();
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 11:53:55 -03:00
update_viewport_size();
Ladybird: Implement zoom :^)
2023-01-12 11:39:53 -03:00
}
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
void WebContentView::showEvent(QShowEvent* event)
{
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
WebContentViewBase::showEvent(event);
LibWebView+WebContent+UI: Remember the current system visibility state We will want to re-inform WebContent of the system visibility state when we create a new process after a crash. This changes the IPC to just send the enum value directly, instead of a boolean, so that we can just store that enum value directly on the ViewImplementation class.
2024-11-13 13:24:16 -03:00
set_system_visibility_state(Web::HTML::VisibilityState::Visible);
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
}
void WebContentView::hideEvent(QHideEvent* event)
{
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
WebContentViewBase::hideEvent(event);
LibWebView+WebContent+UI: Remember the current system visibility state We will want to re-inform WebContent of the system visibility state when we create a new process after a crash. This changes the IPC to just send the enum value directly, instead of a boolean, so that we can just store that enum value directly on the ViewImplementation class.
2024-11-13 13:24:16 -03:00
set_system_visibility_state(Web::HTML::VisibilityState::Hidden);
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
}
Ladybird: Implement the JavaScript console using a WebContentView This aligns the Ladybird console implementation with the Browser console a bit more, which uses OutOfProcessWebView for rendering console output. This allows us to style the console output to try and match the system theme. Using a WebContentView is simpler than trying to style the old QTextEdit widget, as the console output is HTML with built-in "-libweb-palette-*" colors. These will override any color we set on the QTextEdit widget.
2023-04-22 22:57:08 -03:00
static Core::AnonymousBuffer make_system_theme_from_qt_palette(QWidget& widget, WebContentView::PaletteMode mode)
Ladybird: Get the system's current color theme settings from Qt There isn't a 1:1 equivalent for all ColorRoles between Qt and LibGfx, but we can at least make an effort to translate the various QPalette preferred colors. This makes text selection look a lot more "native" in Ladybird. :^)
2023-03-15 18:56:47 -03:00
{
auto qt_palette = widget.palette();
Ladybird: Implement the JavaScript console using a WebContentView This aligns the Ladybird console implementation with the Browser console a bit more, which uses OutOfProcessWebView for rendering console output. This allows us to style the console output to try and match the system theme. Using a WebContentView is simpler than trying to style the old QTextEdit widget, as the console output is HTML with built-in "-libweb-palette-*" colors. These will override any color we set on the QTextEdit widget.
2023-04-22 22:57:08 -03:00
auto theme_file = mode == WebContentView::PaletteMode::Default ? "Default"sv : "Dark"sv;
Ladybird: Convert theme configuration to resource URIs
2023-11-05 11:46:28 -03:00
auto theme_ini = MUST(Core::Resource::load_from_uri(MUST(String::formatted("resource://themes/{}.ini", theme_file))));
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 11:19:34 -03:00
auto theme = Gfx::load_system_theme(theme_ini->filesystem_path().to_byte_string()).release_value_but_fixme_should_propagate_errors();
Ladybird: Convert theme configuration to resource URIs
2023-11-05 11:46:28 -03:00
Ladybird: Get the system's current color theme settings from Qt There isn't a 1:1 equivalent for all ColorRoles between Qt and LibGfx, but we can at least make an effort to translate the various QPalette preferred colors. This makes text selection look a lot more "native" in Ladybird. :^)
2023-03-15 18:56:47 -03:00
auto palette_impl = Gfx::PaletteImpl::create_with_anonymous_buffer(theme);
auto palette = Gfx::Palette(move(palette_impl));
auto translate = [&](Gfx::ColorRole gfx_color_role, QPalette::ColorRole qt_color_role) {
Everywhere: Unify naming of RGBA-like colors The `Bitmap` type was referring to to its internal pixel format by a name that represents the order of the color components as they are layed out in memory. Contrary, the `Color` type was using a naming that where the name represents the order of the components from most to least significant byte when viewed as a unsigned 32bit integer. This is confusing as you have to keep remembering which mental model to use depending on which code you work with. To unify the two, the naming of RGBA-like colors in the `Color` type has been adjusted to match the one from the Bitmap type. This seems to be generally in line with how web APIs think about these types: * `ImageData.pixelFormat` can be `rgba-8unorm` backed by a `Uint8ClamedArray`, but there is no pixel format backed by a 32bit unsigned type. * WebGL can use format `RGBA` with type `UNSIGNED_BYTE`, but there is no such format with type `UNSIGNED_INT`. Additionally, it appears that other browsers and browser-adjacent libraries also think similarly about these types: * Firefox: https://github.com/mozilla-firefox/firefox/blob/main/gfx/2d/Types.h * WebKit: https://github.com/WebKit/WebKit/blob/main/Source/WebCore/platform/graphics/PixelFormat.h * Skia: https://chromium.googlesource.com/skia/+/refs/heads/main/include/core/SkColorType.h This has the not so nice side effect that APIs that interact with these types through 32bit unsigned integers now have the component order inverted due to little-endian byte order. E.g. specifying a color as hex constant needs to be done as `0xAABBGGRR` if it is to be treated as RGBA8888. We could alleviate this by providing endian-independent APIs to callers. But I suspect long-term we might want to think differently about bitmap data anyway, e.g. to better support HDR in the future. However, such changes would be more involved than just unifying the naming as done here. So I considered that out of scope for now.
2025-11-23 09:07:38 -03:00
auto new_color = Gfx::Color::from_bgra(qt_palette.color(qt_color_role).rgba());
Ladybird: Get the system's current color theme settings from Qt There isn't a 1:1 equivalent for all ColorRoles between Qt and LibGfx, but we can at least make an effort to translate the various QPalette preferred colors. This makes text selection look a lot more "native" in Ladybird. :^)
2023-03-15 18:56:47 -03:00
palette.set_color(gfx_color_role, new_color);
};
translate(Gfx::ColorRole::ThreedHighlight, QPalette::ColorRole::Light);
translate(Gfx::ColorRole::ThreedShadow1, QPalette::ColorRole::Mid);
translate(Gfx::ColorRole::ThreedShadow2, QPalette::ColorRole::Dark);
translate(Gfx::ColorRole::HoverHighlight, QPalette::ColorRole::Light);
translate(Gfx::ColorRole::Link, QPalette::ColorRole::Link);
translate(Gfx::ColorRole::VisitedLink, QPalette::ColorRole::LinkVisited);
translate(Gfx::ColorRole::Button, QPalette::ColorRole::Button);
translate(Gfx::ColorRole::ButtonText, QPalette::ColorRole::ButtonText);
UI: Share macOS web selection color Move the active macOS web selection color into LibWebView so AppKit and Qt use the same value when building the WebContent system palette. Qt now also asks AppKit for inactive selection colors on macOS, matching the AppKit frontend while leaving other Qt platforms on QPalette.
2026-06-20 20:22:50 -03:00
#ifdef AK_OS_MACOS
palette.set_color(Gfx::ColorRole::Selection, WebView::macos_web_selection_color());
palette.set_color(Gfx::ColorRole::InactiveSelection, appkit_web_inactive_selection_color());
palette.set_color(Gfx::ColorRole::InactiveSelectionText, appkit_web_inactive_selection_text_color());
#else
Ladybird: Get the system's current color theme settings from Qt There isn't a 1:1 equivalent for all ColorRoles between Qt and LibGfx, but we can at least make an effort to translate the various QPalette preferred colors. This makes text selection look a lot more "native" in Ladybird. :^)
2023-03-15 18:56:47 -03:00
translate(Gfx::ColorRole::Selection, QPalette::ColorRole::Highlight);
UI: Share macOS web selection color Move the active macOS web selection color into LibWebView so AppKit and Qt use the same value when building the WebContent system palette. Qt now also asks AppKit for inactive selection colors on macOS, matching the AppKit frontend while leaving other Qt platforms on QPalette.
2026-06-20 20:22:50 -03:00
#endif
Ladybird: Get the system's current color theme settings from Qt There isn't a 1:1 equivalent for all ColorRoles between Qt and LibGfx, but we can at least make an effort to translate the various QPalette preferred colors. This makes text selection look a lot more "native" in Ladybird. :^)
2023-03-15 18:56:47 -03:00
Ladybird: Let WebContent know if the current system theme is dark This means we now actually respect @media (prefers-color-scheme: dark) by default when in dark mode. :^)
2023-04-29 13:35:06 -03:00
palette.set_flag(Gfx::FlagRole::IsDark, is_using_dark_system_theme(widget));
Ladybird: Get the system's current color theme settings from Qt There isn't a 1:1 equivalent for all ColorRoles between Qt and LibGfx, but we can at least make an effort to translate the various QPalette preferred colors. This makes text selection look a lot more "native" in Ladybird. :^)
2023-03-15 18:56:47 -03:00
return theme;
}
Ladybird: Implement the JavaScript console using a WebContentView This aligns the Ladybird console implementation with the Browser console a bit more, which uses OutOfProcessWebView for rendering console output. This allows us to style the console output to try and match the system theme. Using a WebContentView is simpler than trying to style the old QTextEdit widget, as the console output is HTML with built-in "-libweb-palette-*" colors. These will override any color we set on the QTextEdit widget.
2023-04-22 22:57:08 -03:00
void WebContentView::update_palette(PaletteMode mode)
Ladybird: Get the system's current color theme settings from Qt There isn't a 1:1 equivalent for all ColorRoles between Qt and LibGfx, but we can at least make an effort to translate the various QPalette preferred colors. This makes text selection look a lot more "native" in Ladybird. :^)
2023-03-15 18:56:47 -03:00
{
LibWebView: Avoid white initial web view fills in dark mode Seed the page background fallback from the platform color scheme before WebContent has painted. Update the same fallback when the platform theme changes, and when the preferred color scheme is forced through the debug menu, so unpainted web view areas use the matching Canvas color.
2026-05-26 20:11:14 -03:00
set_page_background_color_to_system_canvas(is_using_dark_system_theme(*this));
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_update_system_theme(m_client_state.page_index, make_system_theme_from_qt_palette(*this, mode));
Ladybird: Get the system's current color theme settings from Qt There isn't a 1:1 equivalent for all ColorRoles between Qt and LibGfx, but we can at least make an effort to translate the various QPalette preferred colors. This makes text selection look a lot more "native" in Ladybird. :^)
2023-03-15 18:56:47 -03:00
}
Ladybird/Qt: Factor out a method to update the screen rects
2024-05-11 00:00:00 -03:00
void WebContentView::update_screen_rects()
{
auto screens = QGuiApplication::screens();
if (!screens.empty()) {
Vector<Web::DevicePixelRect> screen_rects;
for (auto const& screen : screens) {
Ladybird/Qt: Calculate the 'physical pixels' for screens This fixes a regression introduced by GH-23855 in [1], and re-applies a previous change I made [2]. [1] https://github.com/SerenityOS/serenity/commit/dfc7534 [2] https://github.com/SerenityOS/serenity/commit/b7bd3fd
2024-05-29 18:37:39 -03:00
// NOTE: QScreen::geometry() returns the 'device-independent pixels', we multiply
// by the device pixel ratio to get the 'physical pixels' of the display.
Ladybird/Qt: Factor out a method to update the screen rects
2024-05-11 00:00:00 -03:00
auto geometry = screen->geometry();
Ladybird/Qt: Calculate the 'physical pixels' for screens This fixes a regression introduced by GH-23855 in [1], and re-applies a previous change I made [2]. [1] https://github.com/SerenityOS/serenity/commit/dfc7534 [2] https://github.com/SerenityOS/serenity/commit/b7bd3fd
2024-05-29 18:37:39 -03:00
auto device_pixel_ratio = screen->devicePixelRatio();
screen_rects.append(Web::DevicePixelRect(geometry.x(), geometry.y(), geometry.width() * device_pixel_ratio, geometry.height() * device_pixel_ratio));
Ladybird/Qt: Factor out a method to update the screen rects
2024-05-11 00:00:00 -03:00
}
// NOTE: The first item in QGuiApplication::screens is always the primary screen.
// This is not specified in the documentation but QGuiApplication::primaryScreen
// always returns the first item in the list if it isn't empty.
client().async_update_screen_rects(m_client_state.page_index, screen_rects, 0);
}
}
Ladybird: Add ability to create a tab without creating a new WebContent
2024-01-30 13:12:14 -03:00
void WebContentView::initialize_client(WebView::ViewImplementation::CreateNewClient create_new_client)
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
{
LibWebView+UI: Handle common WebView client initialization in LibWebView No need to have every UI manually implement these common steps.
2024-11-13 18:35:17 -03:00
ViewImplementation::initialize_client(create_new_client);
UI: Send the current system visibility state to new WebContent clients After a crash, we need to inform the new WebContent process of the current system visibility state.
2024-11-13 13:31:06 -03:00
LibWebView+Compositor+UI: Send display metadata to Compositor The browser process forwards the maximum frame rate to WebContent, but the compositor process had no copy of that display timing metadata or the display identity needed by compositor-local vsync. Add one compositor control IPC message carrying the optional display ID and refresh rate together, and store both values on each compositor context.
2026-05-28 14:04:22 -03:00
update_compositor_display_metadata();
UI: Send the current system visibility state to new WebContent clients After a crash, we need to inform the new WebContent process of the current system visibility state.
2024-11-13 13:31:06 -03:00
update_palette();
Ladybird/Qt: Factor out a method to update the screen rects
2024-05-11 00:00:00 -03:00
update_screen_rects();
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
}
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
void WebContentView::update_cursor(Gfx::Cursor cursor)
{
cursor.visit([this](Gfx::StandardCursor standard_cursor) {
switch (standard_cursor) {
case Gfx::StandardCursor::Hidden:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::BlankCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
case Gfx::StandardCursor::Arrow:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::ArrowCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
case Gfx::StandardCursor::Crosshair:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::CrossCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
case Gfx::StandardCursor::IBeam:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::IBeamCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
case Gfx::StandardCursor::ResizeHorizontal:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::SizeHorCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
case Gfx::StandardCursor::ResizeVertical:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::SizeVerCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
case Gfx::StandardCursor::ResizeDiagonalTLBR:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::SizeFDiagCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
case Gfx::StandardCursor::ResizeDiagonalBLTR:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::SizeBDiagCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
case Gfx::StandardCursor::ResizeColumn:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::SplitHCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
case Gfx::StandardCursor::ResizeRow:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::SplitVCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
case Gfx::StandardCursor::Hand:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::PointingHandCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
case Gfx::StandardCursor::Help:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::WhatsThisCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
LibGfx+LibWeb+UI: Add OpenHand cursor for CSS grab property
2025-09-06 13:19:21 -03:00
case Gfx::StandardCursor::OpenHand:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::OpenHandCursor);
LibGfx+LibWeb+UI: Add OpenHand cursor for CSS grab property
2025-09-06 13:19:21 -03:00
break;
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
case Gfx::StandardCursor::Drag:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::ClosedHandCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
case Gfx::StandardCursor::DragCopy:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::DragCopyCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
case Gfx::StandardCursor::Move:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::DragMoveCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
case Gfx::StandardCursor::Wait:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::BusyCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
case Gfx::StandardCursor::Disallowed:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::ForbiddenCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
case Gfx::StandardCursor::Eyedropper:
case Gfx::StandardCursor::Zoom:
// FIXME: No corresponding Qt cursors, default to Arrow
default:
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(Qt::ArrowCursor);
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
break;
} },
[this](Gfx::ImageCursor const& image_cursor) {
if (!image_cursor.bitmap.is_valid()) {
dbgln("Failed to set cursor: Bitmap is invalid.");
return;
}
auto const& bitmap = *image_cursor.bitmap.bitmap();
auto qimage = QImage { bitmap.scanline_u8(0), bitmap.width(), bitmap.height(), QImage::Format_ARGB32 };
if (qimage.isNull()) {
dbgln("Failed to set cursor: Null QImage.");
return;
}
auto qpixmap = QPixmap::fromImage(qimage);
if (qimage.isNull()) {
dbgln("Failed to set cursor: Couldn't create QPixmap from QImage.");
return;
}
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
apply_web_content_cursor(QCursor { qpixmap, image_cursor.hotspot.x(), image_cursor.hotspot.y() });
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
});
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
}
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
void WebContentView::apply_web_content_cursor(QCursor const& cursor)
{
setCursor(cursor);
#ifdef LADYBIRD_QT_USE_VULKAN_WINDOW
set_vulkan_window_cursor(cursor);
#endif
}
UI: Route node picker input through WebView Picker input starts in each platform UI, while protocol state lives in LibWebView. Route movement, primary clicks, Escape, and leave events through the WebView picker API so each frontend drives the same hit-test and picker-event path. The selected click is consumed because picker mode uses it to choose an element for DevTools rather than activate page content. AppKit routes normal mouse input through WebViewBridge, which converts view points to device pixels before forwarding to LibWeb. Picker input bypasses that enqueue path, so apply the same scaling before requesting a picker hit test.
2026-05-28 08:18:49 -03:00
Web::DevicePixelPoint WebContentView::node_picker_position_for(QSinglePointEvent const& event) const
{
return { event.position().x() * m_device_pixel_ratio, event.position().y() * m_device_pixel_ratio };
}
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 11:53:55 -03:00
Web::DevicePixelSize WebContentView::viewport_size() const
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
{
LibWeb+WebContent: Move scrollbar painting into WebContent The main intention of this change is to have a consistent look and behavior across all scrollbars, including elements with `overflow: scroll` and `overflow: auto`, iframes, and a page. Before: - Page's scrollbar is painted by Browser (Qt/AppKit) using the corresponding UI framework style, - Both WebContent and Browser know the scroll position offset. - WebContent uses did_request_scroll_to() IPC call to send updates. - Browser uses set_viewport_rect() to send updates. After: - Page's scrollbar is painted on WebContent side using the same style as currently used for elements with `overflow: scroll` and `overflow: auto`. A nice side effects: scrollbars are now painted for iframes, and page's scrollbar respects scrollbar-width CSS property. - Only WebContent knows scroll position offset. - did_request_scroll_to() is no longer used. - set_viewport_rect() is changed to set_viewport_size().
2024-06-03 11:53:55 -03:00
return m_viewport_size.to_type<Web::DevicePixels>();
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 10:23:41 -03:00
}
Ladybird/WebContentView: Make Tab and Shift+Tab work These didn't work, for two reasons: 1. Qt swallows all Tab key presses by default. We have to override the event() function in order to receive them. 2. Qt transforms Shift+Tab into a fake "Backtab" key. We have to undo this transformation and send Shift+Tab to WebContent.
2022-10-11 12:17:49 -03:00
Ladybird/Qt: Move positional device pixel ratio adjustment to a helper The code to convert a Gfx::IntPoint to a QPoint adjusted for the device pixel ratio is a bit of a mouthful, and will be needed outside of Tab, so move it to a helper that can be reused.
2024-03-10 23:15:06 -03:00
QPoint WebContentView::map_point_to_global_position(Gfx::IntPoint position) const
{
return mapToGlobal(QPoint { position.x(), position.y() } / device_pixel_ratio());
}
Browser+Ladybird+LibWebView: Virtualize computing content/widget points This will allow moving some copy-pasted functionality from web view implementations to the base LibWebView class.
2023-05-17 11:12:13 -03:00
Gfx::IntPoint WebContentView::to_content_position(Gfx::IntPoint widget_position) 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 11:53:55 -03:00
return widget_position;
Browser+Ladybird+LibWebView: Virtualize computing content/widget points This will allow moving some copy-pasted functionality from web view implementations to the base LibWebView class.
2023-05-17 11:12:13 -03:00
}
Gfx::IntPoint WebContentView::to_widget_position(Gfx::IntPoint content_position) 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 11:53:55 -03:00
return content_position;
Browser+Ladybird+LibWebView: Virtualize computing content/widget points This will allow moving some copy-pasted functionality from web view implementations to the base LibWebView class.
2023-05-17 11:12:13 -03:00
}
Ladybird/WebContentView: Make Tab and Shift+Tab work These didn't work, for two reasons: 1. Qt swallows all Tab key presses by default. We have to override the event() function in order to receive them. 2. Qt transforms Shift+Tab into a fake "Backtab" key. We have to undo this transformation and send Shift+Tab to WebContent.
2022-10-11 12:17:49 -03:00
bool WebContentView::event(QEvent* event)
{
// NOTE: We have to implement event() manually as Qt's focus navigation mechanism
// eats all the Tab key presses by default.
if (event->type() == QEvent::KeyPress) {
keyPressEvent(static_cast<QKeyEvent*>(event));
return true;
}
if (event->type() == QEvent::KeyRelease) {
keyReleaseEvent(static_cast<QKeyEvent*>(event));
return true;
}
UI/Qt: Handle pinch zoom gestures Translate Qt native zoom gestures into Web::PinchEvent for the web content view. This gives the Qt UI the same pinch-to-zoom input path as the AppKit UI while leaving ordinary wheel scrolling unchanged. Map the Qt native gesture screen position back into WebContentView before creating the event, since macOS delivers the gesture through the top-level widget window after forwarding. Keeping the pinch focal point in content coordinates lets visual viewport zoom preserve the user's focus point.
2026-05-31 21:55:31 -03:00
if (event->type() == QEvent::NativeGesture) {
auto const& native_gesture_event = *static_cast<QNativeGestureEvent const*>(event);
if (native_gesture_event.gestureType() == Qt::ZoomNativeGesture) {
Web::PinchEvent pinch_event;
auto const local_position = mapFromGlobal(native_gesture_event.globalPosition());
pinch_event.position = { local_position.x() * m_device_pixel_ratio, local_position.y() * m_device_pixel_ratio };
pinch_event.modifiers = get_modifiers_from_qt_keyboard_modifiers(native_gesture_event.modifiers());
pinch_event.scale_delta = native_gesture_event.value();
enqueue_input_event(AK::move(pinch_event));
return true;
}
}
Ladybird: Get the system's current color theme settings from Qt There isn't a 1:1 equivalent for all ColorRoles between Qt and LibGfx, but we can at least make an effort to translate the various QPalette preferred colors. This makes text selection look a lot more "native" in Ladybird. :^)
2023-03-15 18:56:47 -03:00
UI/Qt+WebContent: Refresh theme colors live Refresh Qt chrome palettes from the current color scheme when the application palette changes. Recompute autocomplete and location field colors and repaint WebContent immediately so theme changes do not require another interaction or restart.
2026-05-25 16:22:50 -03:00
if (event->type() == QEvent::PaletteChange || event->type() == QEvent::ApplicationPaletteChange || event->type() == QEvent::ThemeChange) {
QTimer::singleShot(0, this, [this] {
update_palette();
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
schedule_repaint();
UI/Qt+WebContent: Refresh theme colors live Refresh Qt chrome palettes from the current color scheme when the application palette changes. Recompute autocomplete and location field colors and repaint WebContent immediately so theme changes do not require another interaction or restart.
2026-05-25 16:22:50 -03:00
});
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
return WebContentViewBase::event(event);
Ladybird: Get the system's current color theme settings from Qt There isn't a 1:1 equivalent for all ColorRoles between Qt and LibGfx, but we can at least make an effort to translate the various QPalette preferred colors. This makes text selection look a lot more "native" in Ladybird. :^)
2023-03-15 18:56:47 -03:00
}
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
if (event->type() == QEvent::ShortcutOverride) {
LibWebView: Fast-close pages without beforeunload prompts Track whether WebContent still needs a beforeunload check and let the frontends immediately remove a tab or window when no prompt can be shown. WebContent still receives the close request so pagehide, unload, and cleanup steps can run. When the visible view is removed immediately, keep detached ownership of the WebContent page until it reports that the top-level traversable closed. If no acknowledgement arrives, release detached ownership and ask ProcessManager to shut down the unused WebContent process.
2026-05-26 13:03:07 -03:00
auto* key_event = static_cast<QKeyEvent*>(event);
UI/Qt: Reserve browser chrome shortcuts Let browser chrome shortcuts for tab and window management bypass the WebContent shortcut override path. This makes new tab, new window, reopen closed tab, tab switching, close tab, and quit dispatch through Qt immediately instead of waiting for page event handling.
2026-05-26 14:58:58 -03:00
if (is_browser_reserved_shortcut(*key_event)) {
LibWebView: Fast-close pages without beforeunload prompts Track whether WebContent still needs a beforeunload check and let the frontends immediately remove a tab or window when no prompt can be shown. WebContent still receives the close request so pagehide, unload, and cleanup steps can run. When the visible view is removed immediately, keep detached ownership of the WebContent page until it reports that the top-level traversable closed. If no acknowledgement arrives, release detached ownership and ask ProcessManager to shut down the unused WebContent process.
2026-05-26 13:03:07 -03:00
event->ignore();
return false;
}
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
event->accept();
return true;
}
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
return WebContentViewBase::event(event);
Ladybird/WebContentView: Make Tab and Shift+Tab work These didn't work, for two reasons: 1. Qt swallows all Tab key presses by default. We have to override the event() function in order to receive them. 2. Qt transforms Shift+Tab into a fake "Backtab" key. We have to undo this transformation and send Shift+Tab to WebContent.
2022-10-11 12:17:49 -03:00
}
Ladybird: Add stub for notify_server_did_finish_handling_input_event This doesn't need to do anything yet, but will do once we start passing events to web content *before* they're passed to our GUI.
2022-11-21 13:36:26 -03:00
UI/Qt: Present Linux DMABUF frames with QVulkanWindow Use a native QVulkanWindow child for Linux DMABUF presentation instead of making WebContentView itself a QRhiWidget. This keeps BrowserWindow on Qt's normal QWidget backing store path while sampling compositor DMABUF backing stores directly in Vulkan. Keep WebContentView's paintEvent as fallback for builds without Vulkan DMABUF support and for cases where the Vulkan instance or window cannot be created. Set an explicit Vulkan API version before creating the shared QVulkanInstance so validation layers do not reject Qt defaults.
2026-06-01 06:45:00 -03:00
#ifdef LADYBIRD_QT_USE_VULKAN_WINDOW
bool WebContentView::handle_vulkan_window_event(QEvent* event)
{
switch (event->type()) {
case QEvent::KeyPress:
keyPressEvent(static_cast<QKeyEvent*>(event));
return true;
case QEvent::KeyRelease:
keyReleaseEvent(static_cast<QKeyEvent*>(event));
return true;
case QEvent::MouseMove:
mouseMoveEvent(static_cast<QMouseEvent*>(event));
return true;
case QEvent::MouseButtonPress:
mousePressEvent(static_cast<QMouseEvent*>(event));
return true;
case QEvent::MouseButtonRelease:
mouseReleaseEvent(static_cast<QMouseEvent*>(event));
return true;
case QEvent::MouseButtonDblClick:
mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
return true;
case QEvent::Wheel:
wheelEvent(static_cast<QWheelEvent*>(event));
return true;
case QEvent::Leave:
leaveEvent(event);
return true;
case QEvent::FocusIn:
focusInEvent(static_cast<QFocusEvent*>(event));
return true;
case QEvent::FocusOut:
focusOutEvent(static_cast<QFocusEvent*>(event));
return true;
case QEvent::InputMethod:
inputMethodEvent(static_cast<QInputMethodEvent*>(event));
return true;
case QEvent::DragEnter:
dragEnterEvent(static_cast<QDragEnterEvent*>(event));
return true;
case QEvent::DragMove:
dragMoveEvent(static_cast<QDragMoveEvent*>(event));
return true;
case QEvent::DragLeave:
dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
return true;
case QEvent::Drop:
dropEvent(static_cast<QDropEvent*>(event));
return true;
case QEvent::NativeGesture: {
auto const& native_gesture_event = *static_cast<QNativeGestureEvent const*>(event);
if (native_gesture_event.gestureType() == Qt::ZoomNativeGesture) {
Web::PinchEvent pinch_event;
auto const local_position = mapFromGlobal(native_gesture_event.globalPosition());
pinch_event.position = { local_position.x() * m_device_pixel_ratio, local_position.y() * m_device_pixel_ratio };
pinch_event.modifiers = get_modifiers_from_qt_keyboard_modifiers(native_gesture_event.modifiers());
pinch_event.scale_delta = native_gesture_event.value();
enqueue_input_event(AK::move(pinch_event));
return true;
}
return false;
}
case QEvent::ShortcutOverride: {
auto* key_event = static_cast<QKeyEvent*>(event);
if (is_browser_reserved_shortcut(*key_event)) {
event->ignore();
return false;
}
event->accept();
return true;
}
default:
return false;
}
}
#endif
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
void WebContentView::enqueue_native_event(Web::MouseEvent::Type type, QSinglePointEvent const& event)
{
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 11:53:55 -03:00
Web::DevicePixelPoint position = { event.position().x() * m_device_pixel_ratio, event.position().y() * m_device_pixel_ratio };
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
auto screen_position = Gfx::IntPoint { event.globalPosition().x() * m_device_pixel_ratio, event.globalPosition().y() * m_device_pixel_ratio };
Ladybird/Qt: Rename convert functions to reflect their new types This is a follow up to GH-1111 to reflect the new signatures that these functions have.
2024-08-20 15:48:41 -03:00
auto button = get_button_from_qt_mouse_button(event.button());
auto buttons = get_buttons_from_qt_mouse_buttons(event.buttons());
auto modifiers = get_modifiers_from_qt_keyboard_modifiers(event.modifiers());
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
if (button == 0 && (type == Web::MouseEvent::Type::MouseDown || type == Web::MouseEvent::Type::MouseUp)) {
// We could not convert Qt buttons to something that LibWeb can recognize - don't even bother propagating this
// to the web engine as it will not handle it anyway, and it will (currently) assert.
return;
}
LibWeb: Use double precision for wheel scroll deltas Wheel deltas were truncated to int at the platform input boundary, which dropped the sub-pixel tail of trackpad momentum scrolls. Each NSEvent's scrollingDeltaY arrived as a CGFloat, got cast to int, and flowed through IPC, EventHandler, and PaintableBox::scroll_by as int, losing fractional information that never came back. Widen Web::MouseEvent::wheel_delta_{x,y} to double and propagate through Page, EventHandler, Paintable, PaintableBox, and the AppKit, Qt, and GTK input paths.
2026-05-12 05:40:45 -03:00
double wheel_delta_x = 0;
double wheel_delta_y = 0;
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
Ladybird/Qt: Explicitly ignore wheel events with the ctrl key pressed This allows ctrl+wheel events to zoom in and out of the page. This was ported incorrectly in commit c1476c3405518871be7a8f5f4feb0670d1051df8.
2024-03-06 09:21:00 -03:00
if (type == Web::MouseEvent::Type::MouseWheel) {
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
auto const& wheel_event = static_cast<QWheelEvent const&>(event);
if (auto pixel_delta = -wheel_event.pixelDelta(); !pixel_delta.isNull()) {
wheel_delta_x = pixel_delta.x();
wheel_delta_y = pixel_delta.y();
} else {
auto angle_delta = -wheel_event.angleDelta();
LibWeb: Use double precision for wheel scroll deltas Wheel deltas were truncated to int at the platform input boundary, which dropped the sub-pixel tail of trackpad momentum scrolls. Each NSEvent's scrollingDeltaY arrived as a CGFloat, got cast to int, and flowed through IPC, EventHandler, and PaintableBox::scroll_by as int, losing fractional information that never came back. Widen Web::MouseEvent::wheel_delta_{x,y} to double and propagate through Page, EventHandler, Paintable, PaintableBox, and the AppKit, Qt, and GTK input paths.
2026-05-12 05:40:45 -03:00
double delta_x = -static_cast<double>(angle_delta.x()) / 120.0;
double delta_y = static_cast<double>(angle_delta.y()) / 120.0;
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
LibWeb: Use double precision for wheel scroll deltas Wheel deltas were truncated to int at the platform input boundary, which dropped the sub-pixel tail of trackpad momentum scrolls. Each NSEvent's scrollingDeltaY arrived as a CGFloat, got cast to int, and flowed through IPC, EventHandler, and PaintableBox::scroll_by as int, losing fractional information that never came back. Widen Web::MouseEvent::wheel_delta_{x,y} to double and propagate through Page, EventHandler, Paintable, PaintableBox, and the AppKit, Qt, and GTK input paths.
2026-05-12 05:40:45 -03:00
static constexpr double scroll_step_size = 40;
LibWebView: Normalize wheel deltas to CSS pixels Platform wheel deltas describe movement in the view, not in page CSS pixels. Convert them by page zoom before dispatch so physical scrolling covers a smaller page area when zoomed in. Do this before the UI-side async scrolling shortcut so compositor scrolling and main-thread fallback scrolling use the same delta. Also avoid applying the Qt device pixel ratio while converting angle-only wheel input, since LibWeb later handles device-pixel scaling itself.
2026-05-31 22:07:38 -03:00
auto step_x = delta_x * static_cast<double>(QApplication::wheelScrollLines());
auto step_y = delta_y * static_cast<double>(QApplication::wheelScrollLines());
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
LibWeb: Use double precision for wheel scroll deltas Wheel deltas were truncated to int at the platform input boundary, which dropped the sub-pixel tail of trackpad momentum scrolls. Each NSEvent's scrollingDeltaY arrived as a CGFloat, got cast to int, and flowed through IPC, EventHandler, and PaintableBox::scroll_by as int, losing fractional information that never came back. Widen Web::MouseEvent::wheel_delta_{x,y} to double and propagate through Page, EventHandler, Paintable, PaintableBox, and the AppKit, Qt, and GTK input paths.
2026-05-12 05:40:45 -03:00
wheel_delta_x = step_x * scroll_step_size;
wheel_delta_y = step_y * scroll_step_size;
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
}
}
Everywhere: Consolidate double/triple click handling to use click count This moves normal/double/triple click checking into WebContent, the client only has to send a click count in order to activate a double or triple click in the content. This means that the AppKit UI will no longer fire multiple double clicks when clicking in place more than 3 times. This matches the behavior of other browsers on macOS. We will now also fire the click event regardless of whether a dblclick event will follow, as the spec requires.
2026-03-07 03:06:07 -03:00
enqueue_input_event(Web::MouseEvent { type, position, screen_position.to_type<Web::DevicePixels>(), button, buttons, modifiers, wheel_delta_x, wheel_delta_y, m_click_count, nullptr });
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
}
LibWeb+UI: Rename ChromeInputData to BrowserInputData
2025-03-15 18:07:53 -03:00
struct DragData : Web::BrowserInputData {
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
explicit DragData(QDropEvent const& event)
: urls(event.mimeData()->urls())
{
}
QList<QUrl> urls;
};
void WebContentView::enqueue_native_event(Web::DragEvent::Type type, QDropEvent const& event)
{
Web::DevicePixelPoint position = { event.position().x() * m_device_pixel_ratio, event.position().y() * m_device_pixel_ratio };
auto global_position = mapToGlobal(event.position());
auto screen_position = Gfx::IntPoint { global_position.x() * m_device_pixel_ratio, global_position.y() * m_device_pixel_ratio };
Ladybird/Qt: Rename convert functions to reflect their new types This is a follow up to GH-1111 to reflect the new signatures that these functions have.
2024-08-20 15:48:41 -03:00
auto button = get_button_from_qt_mouse_button(Qt::LeftButton);
auto buttons = get_buttons_from_qt_mouse_buttons(event.buttons());
auto modifiers = get_modifiers_from_qt_keyboard_modifiers(event.modifiers());
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
Vector<Web::HTML::SelectedFile> files;
LibWeb+UI: Rename ChromeInputData to BrowserInputData
2025-03-15 18:07:53 -03:00
OwnPtr<DragData> browser_data;
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
if (type == Web::DragEvent::Type::DragStart) {
VERIFY(event.mimeData()->hasUrls());
for (auto const& url : event.mimeData()->urls()) {
auto file_path = ak_byte_string_from_qstring(url.toLocalFile());
LibWeb+LibWebView+UI: Move SelectedFile factory to LibWebView This factory is only used by the UI. An upcoming commit will make it depend on LibFileSystem. LibWeb currently does not link LibFileSystem, and doing so would push LibWeb in the wrong direction (we should be doing less file IO in LibWeb, not more).
2026-05-20 13:37:49 -03:00
if (auto file = WebView::create_selected_file(file_path); file.is_error())
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
warnln("Unable to open file {}: {}", file_path, file.error());
else
files.append(file.release_value());
}
} else if (type == Web::DragEvent::Type::Drop) {
LibWeb+UI: Rename ChromeInputData to BrowserInputData
2025-03-15 18:07:53 -03:00
browser_data = make<DragData>(event);
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
}
LibWeb+UI: Rename ChromeInputData to BrowserInputData
2025-03-15 18:07:53 -03:00
enqueue_input_event(Web::DragEvent { type, position, screen_position.to_type<Web::DevicePixels>(), button, buttons, modifiers, AK::move(files), AK::move(browser_data) });
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
}
void WebContentView::finish_handling_drag_event(Web::DragEvent const& event)
{
if (event.type != Web::DragEvent::Type::Drop)
return;
LibWeb+UI: Rename ChromeInputData to BrowserInputData
2025-03-15 18:07:53 -03:00
auto const& browser_data = as<DragData>(*event.browser_data);
emit urls_dropped(browser_data.urls);
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 15:47:28 -03:00
}
LibWeb+UI: Rename ChromeInputData to BrowserInputData
2025-03-15 18:07:53 -03:00
struct KeyData : Web::BrowserInputData {
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
explicit KeyData(QKeyEvent const& event)
: event(adopt_own(*event.clone()))
{
}
NonnullOwnPtr<QKeyEvent> event;
};
void WebContentView::enqueue_native_event(Web::KeyEvent::Type type, QKeyEvent const& event)
{
Ladybird/Qt: Rename convert functions to reflect their new types This is a follow up to GH-1111 to reflect the new signatures that these functions have.
2024-08-20 15:48:41 -03:00
auto keycode = get_keycode_from_qt_key_event(event);
auto modifiers = get_modifiers_from_qt_key_event(event);
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
auto text = event.text();
auto code_point = text.isEmpty() ? 0u : event.text()[0].unicode();
LibWeb: Allow Option-generated text insertion Track whether a keydown should perform text insertion separately from the delivered code point. Native frontends and text-oriented test paths can now mark events that came from text input, while shortcut-style key events keep Alt-modified default insertion suppressed. This lets macOS Option-generated text such as Option+A and Option+Space insert into editable controls without making plain Alt shortcuts insert their base character. Add coverage for Alt text, Ctrl+Alt text, separator text, Ctrl-only shortcuts, and Alt shortcuts.
2026-06-03 07:26:44 -03:00
auto should_insert_text = type == Web::KeyEvent::Type::KeyDown && !text.isEmpty();
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
auto to_web_event = [&]() -> Web::KeyEvent {
if (event.key() == Qt::Key_Backtab) {
// Qt transforms Shift+Tab into a "Backtab", so we undo that transformation here.
LibWeb: Allow Option-generated text insertion Track whether a keydown should perform text insertion separately from the delivered code point. Native frontends and text-oriented test paths can now mark events that came from text input, while shortcut-style key events keep Alt-modified default insertion suppressed. This lets macOS Option-generated text such as Option+A and Option+Space insert into editable controls without making plain Alt shortcuts insert their base character. Add coverage for Alt text, Ctrl+Alt text, separator text, Ctrl-only shortcuts, and Alt shortcuts.
2026-06-03 07:26:44 -03:00
return { type, Web::UIEvents::KeyCode::Key_Tab, Web::UIEvents::Mod_Shift, '\t', event.isAutoRepeat(), false, make<KeyData>(event) };
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
}
if (event.key() == Qt::Key_Enter || event.key() == Qt::Key_Return) {
// This ensures consistent behavior between systems that treat Enter as '\n' and '\r\n'
LibWeb: Allow Option-generated text insertion Track whether a keydown should perform text insertion separately from the delivered code point. Native frontends and text-oriented test paths can now mark events that came from text input, while shortcut-style key events keep Alt-modified default insertion suppressed. This lets macOS Option-generated text such as Option+A and Option+Space insert into editable controls without making plain Alt shortcuts insert their base character. Add coverage for Alt text, Ctrl+Alt text, separator text, Ctrl-only shortcuts, and Alt shortcuts.
2026-06-03 07:26:44 -03:00
return { type, Web::UIEvents::KeyCode::Key_Return, modifiers, '\n', event.isAutoRepeat(), should_insert_text, make<KeyData>(event) };
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
}
LibWeb: Allow Option-generated text insertion Track whether a keydown should perform text insertion separately from the delivered code point. Native frontends and text-oriented test paths can now mark events that came from text input, while shortcut-style key events keep Alt-modified default insertion suppressed. This lets macOS Option-generated text such as Option+A and Option+Space insert into editable controls without making plain Alt shortcuts insert their base character. Add coverage for Alt text, Ctrl+Alt text, separator text, Ctrl-only shortcuts, and Alt shortcuts.
2026-06-03 07:26:44 -03:00
return { type, keycode, modifiers, code_point, event.isAutoRepeat(), should_insert_text, make<KeyData>(event) };
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
};
enqueue_input_event(to_web_event());
}
void WebContentView::finish_handling_key_event(Web::KeyEvent const& key_event)
{
LibWeb+UI: Rename ChromeInputData to BrowserInputData
2025-03-15 18:07:53 -03:00
auto& browser_data = as<KeyData>(*key_event.browser_data);
auto& event = *browser_data.event;
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
switch (key_event.type) {
case Web::KeyEvent::Type::KeyDown:
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
WebContentViewBase::keyPressEvent(&event);
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
break;
case Web::KeyEvent::Type::KeyUp:
UI/Qt: Present macOS frames with QRhiWidget Use QRhiWidget for the Qt web content view on macOS and render the current IOSurface-backed shared image into the widget's Metal render target. This keeps normal presentation on the GPU instead of painting a QImage wrapper over the shared bitmap. Force Qt Widgets' RHI backing store to Metal before QApplication is created so QRhiWidget can obtain the top-level QRhi even when the native window is created before the web content widget enters the hierarchy. Other platforms keep the existing QWidget and QPainter path.
2026-05-31 21:29:15 -03:00
WebContentViewBase::keyReleaseEvent(&event);
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 09:53:57 -03:00
break;
}
if (!event.isAccepted())
QApplication::sendEvent(parent(), &event);
}
Ladybird: Move classes and types into the Ladybird namespace We were super inconsistent about this, with most "new" classes living in the Ladybird namespace, while "old" ones were in the global namespace, or even sitting in the Browser namespace.
2023-08-02 14:52:59 -03:00
}
Reference in a new issue Copy permalink