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

818 lines
30 KiB
C++
Raw 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 13:23:41 +00:00
/*
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 16:57:14 +00:00
* Copyright (c) 2022-2023, Andreas Kling <kling@serenityos.org>
Ladybird: Implement zoom :^)
2023-01-12 14:39:53 +00:00
* Copyright (c) 2023, Linus Groh <linusg@serenityos.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 13:23:41 +00:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include "WebContentView.h"
Ladybird+headless-browser: Make RequestServer single instance on Lagom Co-Authored-By: Timothy Flynn <trflynn89@pm.me>
2024-04-15 23:39:48 +00:00
#include "Application.h"
Ladybird: Move Qt-specific classes and functions to a Qt subdirectory This will help a lot with developing chromes for different UI frameworks where we can see which helper classes and processes are really using Qt vs just using it to get at helper data. As a bonus, remove Qt dependency from WebDriver.
2023-08-05 16:42:26 +00:00
#include "StringUtils.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 13:23:41 +00:00
#include <AK/Assertions.h>
#include <AK/ByteBuffer.h>
#include <AK/Format.h>
#include <AK/LexicalPath.h>
#include <AK/NonnullOwnPtr.h>
#include <AK/Types.h>
Ladybird: Move Qt-specific classes and functions to a Qt subdirectory This will help a lot with developing chromes for different UI frameworks where we can see which helper classes and processes are really using Qt vs just using it to get at helper data. As a bonus, remove Qt dependency from WebDriver.
2023-08-05 16:42:26 +00:00
#include <Ladybird/HelperProcess.h>
#include <Ladybird/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 13:23:41 +00:00
#include <LibCore/EventLoop.h>
Ladybird: Convert theme configuration to resource URIs
2023-11-05 14:46:28 +00: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 13:23:41 +00: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 18:58:06 +00:00
#include <LibGfx/ImageFormats/PNGWriter.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 13:23:41 +00:00
#include <LibGfx/Painter.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 21:56:47 +00: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 13:23:41 +00: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-18 00:50:53 +00:00
#include <LibGfx/SystemTheme.h>
Ladybird: Generate window handle during client creation Generate handle UUID for top-level context that is going to run in created WebContent process and sent it over IPC. Co-authored-by: Timothy Flynn <trflynn89@pm.me>
2023-03-16 15:35:19 +00:00
#include <LibWeb/Crypto/Crypto.h>
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 19:29:08 +00:00
#include <LibWeb/UIEvents/KeyCode.h>
LibWeb: Add 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 17:00:42 +00:00
#include <LibWeb/UIEvents/MouseButton.h>
LibWeb+WebContent: Spawn Worker processes from the chrome Instead of spawning these processes from the WebContent process, we now create them in the Browser chrome. Part 1/N of "all processes are owned by the chrome".
2024-01-06 20:13:59 +00:00
#include <LibWeb/Worker/WebWorkerClient.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 18:01:05 +00:00
#include <LibWebView/Application.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 13:23:41 +00:00
#include <LibWebView/WebContentClient.h>
#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 10:52:44 +00: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 13:23:41 +00:00
#include <QIcon>
#include <QLineEdit>
Ladybird: Accept file drops
2023-01-07 16:40:04 +00: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 13:23:41 +00:00
#include <QMouseEvent>
#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 21:56:47 +00:00
#include <QPalette>
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 13:23:41 +00:00
#include <QScrollBar>
#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 17:52:59 +00: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 16:35:06 +00:00
bool is_using_dark_system_theme(QWidget&);
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 18:01:05 +00:00
WebContentView::WebContentView(QWidget* window, RefPtr<WebView::WebContentClient> parent_client, size_t page_index)
Ladybird/Qt: Properly listen for DPI changes on Wayland Some Wayland compositors have support of fractional-scale-v1 protocol. The protocol allows compositor to announce a preferred fractional scale on a per-wl_surface basis. Qt forwards these Wayland events to an application using a usual DevicePixelRatioChange event. However, in contrast to the other platforms, this DevicePixelRatioChange event is issued directly on widgets and not screens. Additionally, the exact fractional scale is stored in QWindow object and not the current screen. Note that in theory it is possible to obtain per-screen fractional scaling on Wayland by interpolating data provided by wl_output and xdg_output events but qtwayland does not do that. If fractional-scale-v1 is not available, qtwayland will still fire per-Widget DevicePixelRatioChange events, but, obviously, with the per-screen possibly larger ceiled scaling. This whole thing makes handling DPI changes on Wayland really simple. All we need to do is to intercept DevicePixelRatioChange events firing on QWindow objects and call the old device_pixel_ratio_changed handler with the window's devicePixelRatio(). The only caveat here is not forget to always set QWidget's parent before calling devicePixelRatio() on it.
2024-01-27 04:14:41 +00:00
: QAbstractScrollArea(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 13:23:41 +00:00
{
LibWeb+WebContent: Move scrollbar painting into WebContent The main intention of this change is to have a consistent look and behavior across all scrollbars, including elements with `overflow: scroll` and `overflow: auto`, iframes, and a page. Before: - Page's scrollbar is painted by Browser (Qt/AppKit) using the corresponding UI framework style, - Both WebContent and Browser know the scroll position offset. - WebContent uses did_request_scroll_to() IPC call to send updates. - Browser uses set_viewport_rect() to send updates. After: - Page's scrollbar is painted on WebContent side using the same style as currently used for elements with `overflow: scroll` and `overflow: auto`. A nice side effects: scrollbars are now painted for iframes, and page's scrollbar respects scrollbar-width CSS property. - Only WebContent knows scroll position offset. - did_request_scroll_to() is no longer used. - set_viewport_rect() is changed to set_viewport_size().
2024-06-03 14:53:55 +00:00
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
Ladybird: Add ability to create a tab without creating a new WebContent
2024-01-30 16:12:14 +00:00
m_client_state.client = parent_client;
m_client_state.page_index = page_index;
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 13:23:41 +00:00
setMouseTracking(true);
Ladybird: Accept file drops
2023-01-07 16:40:04 +00: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 13:23:41 +00:00
Ladybird/WebContentView: Accept focus and notify WebContent on change
2022-10-11 09:38:03 +00:00
setFocusPolicy(Qt::FocusPolicy::StrongFocus);
Ladybird: Set 'device pixels per CSS pixel' to device pixel ratio :^)
2023-01-12 14:39:05 +00:00
m_device_pixel_ratio = devicePixelRatio();
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 13:23:41 +00:00
verticalScrollBar()->setSingleStep(24);
horizontalScrollBar()->setSingleStep(24);
Ladybird/Qt: Wire up screen added and removed events
2024-04-05 17:19:50 +00:00
QObject::connect(qGuiApp, &QGuiApplication::screenRemoved, [this](QScreen*) {
update_screen_rects();
});
QObject::connect(qGuiApp, &QGuiApplication::screenAdded, [this](QScreen*) {
update_screen_rects();
});
LibWeb+UI/Qt: Display 'title' tooltips only when the mouse stops moving Now instead of sending the position in which the user entered the tooltip area, send just the text, and let the chrome figure out how to display it. In the case of Qt, wait for 600 milliseconds of no mouse movement, then display it under the mouse cursor.
2024-07-02 12:16:24 +00:00
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 16:12:14 +00: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 14:50:05 +00:00
on_ready_to_paint = [this]() {
viewport()->update();
};
Ladybird+LibWebView: Migrate cursor changes to LibWebView callbacks
2023-08-23 14:43:27 +00:00
on_cursor_change = [this](auto cursor) {
update_cursor(cursor);
};
Ladybird+LibWebView: Migrate tooltip changes to LibWebView callbacks
2023-08-23 15:11:39 +00: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 14:48:57 +00: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 12:16:24 +00: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-09 00:11:30 +00: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 15:11:39 +00: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 12:16:24 +00:00
on_leave_tooltip_area = [this]() {
m_tooltip_text.clear();
Ladybird+LibWebView: Migrate tooltip changes to LibWebView callbacks
2023-08-23 15:11:39 +00: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 20:13:59 +00: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 12:53:57 +00:00
on_finish_handling_key_event = [this](auto const& event) {
finish_handling_key_event(event);
};
WebWorker: Allow the WebWorker process to optionally use Qt networking This change adds a `--use-lagom-networking` flag to the WebWorker process. Qt networking is used if this flag isn't passed. The flag is passed the UI launches the WebWorker process unless the Qt chrome is being run with the `--enable-qt-networking` flag.
2024-07-06 02:41:07 +00:00
on_request_worker_agent = [&]() {
RefPtr<Protocol::RequestClient> request_server_client {};
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 18:01:05 +00:00
if (WebView::Application::web_content_options().use_lagom_networking == WebView::UseLagomNetworking::Yes)
WebWorker: Allow the WebWorker process to optionally use Qt networking This change adds a `--use-lagom-networking` flag to the WebWorker process. Qt networking is used if this flag isn't passed. The flag is passed the UI launches the WebWorker process unless the Qt chrome is being run with the `--enable-qt-networking` flag.
2024-07-06 02:41:07 +00:00
request_server_client = static_cast<Ladybird::Application*>(QApplication::instance())->request_server_client;
auto worker_client = MUST(launch_web_worker_process(MUST(get_paths_for_helper_process("WebWorker"sv)), request_server_client));
Ladybird+Userland: Remove use of unnecessary fd passing socket concept Now that LibIPC is using SCM_RIGHTS properly, we can go back to only having one socket laying around when needing to transfer fds to peers.
2024-04-18 00:44:39 +00:00
return worker_client->dup_socket();
LibWeb+WebContent: Spawn Worker processes from the chrome Instead of spawning these processes from the WebContent process, we now create them in the Browser chrome. Part 1/N of "all processes are owned by the chrome".
2024-01-06 20:13:59 +00:00
};
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 13:23:41 +00:00
}
UI/Qt: Unregister WebContentView instances just once We already unregister the view in the ViewImplementation destructor. We do not need to do so again in the WebContentView destructor.
2024-08-03 16:48:00 +00:00
WebContentView::~WebContentView() = default;
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 13:23:41 +00:00
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 17:00:42 +00:00
static Web::UIEvents::MouseButton get_button_from_qt_event(QSinglePointEvent 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 13:23:41 +00:00
{
if (event.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 17:00:42 +00:00
return Web::UIEvents::MouseButton::Primary;
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 13:23:41 +00:00
if (event.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 17:00:42 +00:00
return Web::UIEvents::MouseButton::Secondary;
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 13:23:41 +00:00
if (event.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 17:00:42 +00:00
return Web::UIEvents::MouseButton::Middle;
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 13:23:41 +00:00
if (event.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 17:00:42 +00:00
return Web::UIEvents::MouseButton::Backward;
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 13:23:41 +00:00
if (event.buttons() == 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 17:00:42 +00: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 12:53:57 +00:00
}
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 17:00:42 +00:00
static Web::UIEvents::MouseButton get_buttons_from_qt_event(QSinglePointEvent const& 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 12:53:57 +00:00
{
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 17:00:42 +00:00
auto buttons = 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 12:53:57 +00:00
if (event.buttons().testFlag(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 17:00:42 +00:00
buttons |= Web::UIEvents::MouseButton::Primary;
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 12:53:57 +00:00
if (event.buttons().testFlag(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 17:00:42 +00:00
buttons |= Web::UIEvents::MouseButton::Secondary;
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 12:53:57 +00:00
if (event.buttons().testFlag(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 17:00:42 +00:00
buttons |= Web::UIEvents::MouseButton::Middle;
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 12:53:57 +00:00
if (event.buttons().testFlag(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 17:00:42 +00:00
buttons |= Web::UIEvents::MouseButton::Backward;
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 12:53:57 +00:00
if (event.buttons().testFlag(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 17:00:42 +00:00
buttons |= Web::UIEvents::MouseButton::Forward;
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 13:23:41 +00:00
return buttons;
}
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 19:29:08 +00:00
static Web::UIEvents::KeyModifier get_modifiers_from_qt_mouse_event(QSinglePointEvent 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 13:23:41 +00:00
{
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 19:29:08 +00:00
auto modifiers = Web::UIEvents::KeyModifier::Mod_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 12:53:57 +00:00
if (event.modifiers().testFlag(Qt::AltModifier))
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 19:29:08 +00:00
modifiers |= Web::UIEvents::KeyModifier::Mod_Alt;
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 12:53:57 +00:00
if (event.modifiers().testFlag(Qt::ControlModifier))
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 19:29:08 +00:00
modifiers |= Web::UIEvents::KeyModifier::Mod_Ctrl;
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 12:53:57 +00:00
if (event.modifiers().testFlag(Qt::ShiftModifier))
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 19:29:08 +00:00
modifiers |= Web::UIEvents::KeyModifier::Mod_Shift;
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 13:23:41 +00:00
return modifiers;
}
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 19:29:08 +00:00
static Web::UIEvents::KeyModifier get_modifiers_from_qt_keyboard_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 13:23:41 +00:00
{
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 19:29:08 +00:00
auto modifiers = Web::UIEvents::KeyModifier::Mod_None;
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 13:23:41 +00:00
if (event.modifiers().testFlag(Qt::AltModifier))
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 19:29:08 +00:00
modifiers |= Web::UIEvents::KeyModifier::Mod_Alt;
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 13:23:41 +00:00
if (event.modifiers().testFlag(Qt::ControlModifier))
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 19:29:08 +00:00
modifiers |= Web::UIEvents::KeyModifier::Mod_Ctrl;
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 13:23:41 +00:00
if (event.modifiers().testFlag(Qt::MetaModifier))
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 19:29:08 +00:00
modifiers |= Web::UIEvents::KeyModifier::Mod_Super;
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 13:23:41 +00:00
if (event.modifiers().testFlag(Qt::ShiftModifier))
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 19:29:08 +00:00
modifiers |= Web::UIEvents::KeyModifier::Mod_Shift;
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 13:23:41 +00:00
if (event.modifiers().testFlag(Qt::AltModifier))
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 19:29:08 +00:00
modifiers |= Web::UIEvents::KeyModifier::Mod_AltGr;
Ladybird: Include the keypad modifier in key events sent to WebContent
2023-07-08 20:01:32 +00: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 19:29:08 +00: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 13:23:41 +00:00
return modifiers;
}
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 19:29:08 +00:00
static Web::UIEvents::KeyCode get_keycode_from_qt_keyboard_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 13:23:41 +00: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 19:29:08 +00: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 13:23:41 +00: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 19:29:08 +00: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 13:23:41 +00:00
};
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 20:58:22 +00:00
// https://doc.qt.io/qt-6/qt.html#Key-enum
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 13:23:41 +00:00
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 19:29:08 +00: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 },
{ Qt::Key_Alt, Web::UIEvents::Key_Alt },
{ 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 },
{ Qt::Key_Control, Web::UIEvents::Key_Control },
{ 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 },
{ Qt::Key_Meta, Web::UIEvents::Key_Super },
{ 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 },
{ Qt::Key_Super_L, Web::UIEvents::Key_Super },
{ Qt::Key_Super_R, Web::UIEvents::Key_Super },
{ 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 13:23:41 +00: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 19:29:08 +00: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 13:23:41 +00: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 12:53:57 +00:00
void WebContentView::keyPressEvent(QKeyEvent* event)
{
enqueue_native_event(Web::KeyEvent::Type::KeyDown, *event);
}
void WebContentView::keyReleaseEvent(QKeyEvent* event)
{
enqueue_native_event(Web::KeyEvent::Type::KeyUp, *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 13:23:41 +00:00
void WebContentView::mouseMoveEvent(QMouseEvent* event)
{
LibWeb+UI: Add tooltip overriding and use it for <video> tags This call is used to inform the chrome that it should display a tooltip now and avoid any hovering timers. This is used by <video> tags to display the volume percentage when it is changed.
2024-07-02 14:48:57 +00:00
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 12:16:24 +00: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 12:53:57 +00:00
enqueue_native_event(Web::MouseEvent::Type::MouseMove, *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 13:23:41 +00:00
}
void WebContentView::mousePressEvent(QMouseEvent* 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 12:53:57 +00: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 13:23:41 +00:00
}
void WebContentView::mouseReleaseEvent(QMouseEvent* 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 12:53:57 +00: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-08 01:00:24 +00: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 12:53:57 +00:00
if (event->button() == Qt::MouseButton::BackButton) {
LibWebView+Ladybird: Remove duplicate WebContent callback We have on_navigate_back + on_back_button and on_navigate_forward + on_forward_button. Remove the *_button variants.
2023-08-18 22:33:25 +00:00
if (on_navigate_back)
on_navigate_back();
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 12:53:57 +00:00
} else if (event->button() == Qt::MouseButton::ForwardButton) {
LibWebView+Ladybird: Remove duplicate WebContent callback We have on_navigate_back + on_back_button and on_navigate_forward + on_forward_button. Remove the *_button variants.
2023-08-18 22:33:25 +00:00
if (on_navigate_forward)
on_navigate_forward();
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-08 01:00:24 +00:00
}
LibWeb: Refactor WebContentServer mouse input message to DevicePixel
2023-12-15 16:46:09 +00:00
}
void WebContentView::wheelEvent(QWheelEvent* event)
{
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 12:21:00 +00: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 12:53:57 +00: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 13:23:41 +00:00
}
Ladybird: Send the double click event to WebContent
2023-05-13 14:55:10 +00:00
void WebContentView::mouseDoubleClickEvent(QMouseEvent* 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 12:53:57 +00:00
enqueue_native_event(Web::MouseEvent::Type::DoubleClick, *event);
Ladybird: Send the double click event to WebContent
2023-05-13 14:55:10 +00:00
}
Ladybird: Accept file drops
2023-01-07 16:40:04 +00:00
void WebContentView::dragEnterEvent(QDragEnterEvent* event)
{
if (event->mimeData()->hasUrls())
event->acceptProposedAction();
}
void WebContentView::dropEvent(QDropEvent* event)
{
VERIFY(event->mimeData()->hasUrls());
emit urls_dropped(event->mimeData()->urls());
event->acceptProposedAction();
}
Ladybird/WebContentView: Accept focus and notify WebContent on change
2022-10-11 09:38:03 +00: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-03 01:00:48 +00:00
client().async_set_has_focus(m_client_state.page_index, true);
Ladybird/WebContentView: Accept focus and notify WebContent on change
2022-10-11 09:38:03 +00: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-03 01:00:48 +00:00
client().async_set_has_focus(m_client_state.page_index, false);
Ladybird/WebContentView: Accept focus and notify WebContent on change
2022-10-11 09:38:03 +00: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 13:23:41 +00:00
void WebContentView::paintEvent(QPaintEvent*)
{
QPainter painter(viewport());
Ladybird/Qt: Listen to DPI changes and update WebContentView accordingly
2023-12-13 18:10:05 +00:00
painter.scale(1 / m_device_pixel_ratio, 1 / m_device_pixel_ratio);
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 13:23:41 +00:00
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 16:57:14 +00:00
Gfx::Bitmap const* bitmap = nullptr;
Gfx::IntSize bitmap_size;
if (m_client_state.has_usable_bitmap) {
bitmap = m_client_state.front_bitmap.bitmap.ptr();
LibWeb: Refactor int types in WebContentServer to DevicePixels
2023-12-14 06:17:00 +00:00
bitmap_size = m_client_state.front_bitmap.last_painted_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 16:57:14 +00:00
} else {
bitmap = m_backup_bitmap.ptr();
LibWeb: Refactor int types in WebContentServer to DevicePixels
2023-12-14 06:17:00 +00: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 16:57:14 +00: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 15:56:20 +00: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 16:57:14 +00:00
painter.drawImage(QPoint(0, 0), q_image, QRect(0, 0, bitmap_size.width(), bitmap_size.height()));
if (bitmap_size.width() < width()) {
painter.fillRect(bitmap_size.width(), 0, width() - bitmap_size.width(), bitmap->height(), palette().base());
}
if (bitmap_size.height() < height()) {
painter.fillRect(0, bitmap_size.height(), width(), height() - bitmap_size.height(), palette().base());
}
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 13:23:41 +00:00
return;
}
painter.fillRect(rect(), palette().base());
}
void WebContentView::resizeEvent(QResizeEvent* event)
{
QAbstractScrollArea::resizeEvent(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 14:53:55 +00: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 05:59:51 +00: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 13:23:41 +00:00
}
Ladybird: Specify window size in layout dump mode
2023-01-30 20:38:19 +00: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 14:53:55 +00:00
m_viewport_size = rect.size();
client().async_set_viewport_size(m_client_state.page_index, rect.size().to_type<Web::DevicePixels>());
Ladybird: Specify window size in layout dump mode
2023-01-30 20:38:19 +00:00
}
Ladybird: Send window size and position to WebContent process
2023-03-08 20:57:24 +00:00
void WebContentView::set_window_size(Gfx::IntSize size)
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-03 01:00:48 +00:00
client().async_set_window_size(m_client_state.page_index, size.to_type<Web::DevicePixels>());
Ladybird: Send window size and position to WebContent process
2023-03-08 20:57:24 +00:00
}
void WebContentView::set_window_position(Gfx::IntPoint position)
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-03 01:00:48 +00:00
client().async_set_window_position(m_client_state.page_index, position.to_type<Web::DevicePixels>());
Ladybird: Send window size and position to WebContent process
2023-03-08 20:57:24 +00:00
}
Ladybird/Qt: Listen to DPI changes and update WebContentView accordingly
2023-12-13 18:10:05 +00:00
void WebContentView::set_device_pixel_ratio(double device_pixel_ratio)
{
m_device_pixel_ratio = device_pixel_ratio;
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-03 01:00:48 +00:00
client().async_set_device_pixels_per_css_pixel(m_client_state.page_index, m_device_pixel_ratio * m_zoom_level);
LibWeb+WebContent: Move scrollbar painting into WebContent The main intention of this change is to have a consistent look and behavior across all scrollbars, including elements with `overflow: scroll` and `overflow: auto`, iframes, and a page. Before: - Page's scrollbar is painted by Browser (Qt/AppKit) using the corresponding UI framework style, - Both WebContent and Browser know the scroll position offset. - WebContent uses did_request_scroll_to() IPC call to send updates. - Browser uses set_viewport_rect() to send updates. After: - Page's scrollbar is painted on WebContent side using the same style as currently used for elements with `overflow: scroll` and `overflow: auto`. A nice side effects: scrollbars are now painted for iframes, and page's scrollbar respects scrollbar-width CSS property. - Only WebContent knows scroll position offset. - did_request_scroll_to() is no longer used. - set_viewport_rect() is changed to set_viewport_size().
2024-06-03 14:53:55 +00:00
update_viewport_size();
Ladybird/Qt: Listen to DPI changes and update WebContentView accordingly
2023-12-13 18:10:05 +00:00
handle_resize();
}
LibWeb+WebContent: Move scrollbar painting into WebContent The main intention of this change is to have a consistent look and behavior across all scrollbars, including elements with `overflow: scroll` and `overflow: auto`, iframes, and a page. Before: - Page's scrollbar is painted by Browser (Qt/AppKit) using the corresponding UI framework style, - Both WebContent and Browser know the scroll position offset. - WebContent uses did_request_scroll_to() IPC call to send updates. - Browser uses set_viewport_rect() to send updates. After: - Page's scrollbar is painted on WebContent side using the same style as currently used for elements with `overflow: scroll` and `overflow: auto`. A nice side effects: scrollbars are now painted for iframes, and page's scrollbar respects scrollbar-width CSS property. - Only WebContent knows scroll position offset. - did_request_scroll_to() is no longer used. - set_viewport_rect() is changed to set_viewport_size().
2024-06-03 14:53:55 +00:00
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 13:23:41 +00:00
{
Ladybird/Qt: Listen to DPI changes and update WebContentView accordingly
2023-12-13 18:10:05 +00:00
auto scaled_width = int(viewport()->width() * m_device_pixel_ratio);
auto scaled_height = int(viewport()->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 14:53:55 +00: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 13:23:41 +00:00
Ladybird: Specify window size in layout dump mode
2023-01-30 20:38:19 +00: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 13:23:41 +00:00
}
Ladybird: Implement zoom :^)
2023-01-12 14:39:53 +00:00
void WebContentView::update_zoom()
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-03 01:00:48 +00:00
client().async_set_device_pixels_per_css_pixel(m_client_state.page_index, m_device_pixel_ratio * m_zoom_level);
LibWeb+WebContent: Move scrollbar painting into WebContent The main intention of this change is to have a consistent look and behavior across all scrollbars, including elements with `overflow: scroll` and `overflow: auto`, iframes, and a page. Before: - Page's scrollbar is painted by Browser (Qt/AppKit) using the corresponding UI framework style, - Both WebContent and Browser know the scroll position offset. - WebContent uses did_request_scroll_to() IPC call to send updates. - Browser uses set_viewport_rect() to send updates. After: - Page's scrollbar is painted on WebContent side using the same style as currently used for elements with `overflow: scroll` and `overflow: auto`. A nice side effects: scrollbars are now painted for iframes, and page's scrollbar respects scrollbar-width CSS property. - Only WebContent knows scroll position offset. - did_request_scroll_to() is no longer used. - set_viewport_rect() is changed to set_viewport_size().
2024-06-03 14:53:55 +00:00
update_viewport_size();
Ladybird: Implement zoom :^)
2023-01-12 14:39:53 +00: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 13:23:41 +00:00
void WebContentView::showEvent(QShowEvent* event)
{
QAbstractScrollArea::showEvent(event);
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-03 01:00:48 +00:00
client().async_set_system_visibility_state(m_client_state.page_index, 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 13:23:41 +00:00
}
void WebContentView::hideEvent(QHideEvent* event)
{
QAbstractScrollArea::hideEvent(event);
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-03 01:00:48 +00:00
client().async_set_system_visibility_state(m_client_state.page_index, false);
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 13:23:41 +00: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-23 01:57:08 +00: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 21:56:47 +00: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-23 01:57:08 +00:00
auto theme_file = mode == WebContentView::PaletteMode::Default ? "Default"sv : "Dark"sv;
Ladybird: Convert theme configuration to resource URIs
2023-11-05 14:46:28 +00: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 14:19:34 +00: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 14:46:28 +00: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 21:56:47 +00: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) {
auto new_color = Gfx::Color::from_argb(qt_palette.color(qt_color_role).rgba());
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);
translate(Gfx::ColorRole::Selection, QPalette::ColorRole::Highlight);
translate(Gfx::ColorRole::SelectionText, QPalette::ColorRole::HighlightedText);
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 16:35:06 +00: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 21:56:47 +00: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-23 01:57:08 +00: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 21:56:47 +00:00
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-03 01:00:48 +00:00
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 21:56:47 +00:00
}
Ladybird/Qt: Factor out a method to update the screen rects
2024-05-11 03:00:00 +00: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 21:37:39 +00: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 03:00:00 +00: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 21:37:39 +00: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 03:00:00 +00: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 16:12:14 +00: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 13:23:41 +00:00
{
Ladybird: Add ability to create a tab without creating a new WebContent
2024-01-30 16:12:14 +00:00
if (create_new_client == CreateNewClient::Yes) {
m_client_state = {};
Ladybird+Userland: Remove use of unnecessary fd passing socket concept Now that LibIPC is using SCM_RIGHTS properly, we can go back to only having one socket laying around when needing to transfer fds to peers.
2024-04-18 00:44:39 +00:00
Optional<IPC::File> request_server_socket;
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 18:01:05 +00:00
if (WebView::Application::web_content_options().use_lagom_networking == WebView::UseLagomNetworking::Yes) {
Ladybird+headless-browser: Make RequestServer single instance on Lagom Co-Authored-By: Timothy Flynn <trflynn89@pm.me>
2024-04-15 23:39:48 +00:00
auto& protocol = static_cast<Ladybird::Application*>(QApplication::instance())->request_server_client;
// FIXME: Fail to open the tab, rather than crashing the whole application if this fails
Ladybird+Userland: Remove use of unnecessary fd passing socket concept Now that LibIPC is using SCM_RIGHTS properly, we can go back to only having one socket laying around when needing to transfer fds to peers.
2024-04-18 00:44:39 +00:00
auto socket = connect_new_request_server_client(*protocol).release_value_but_fixme_should_propagate_errors();
request_server_socket = AK::move(socket);
Ladybird+headless-browser: Make RequestServer single instance on Lagom Co-Authored-By: Timothy Flynn <trflynn89@pm.me>
2024-04-15 23:39:48 +00:00
}
Everywhere: Transition ImageDecoder to be single-instance, owned by UI This is the same behavior as RequestServer, with the added benefit that we know how to gracefully reconnect ImageDecoder to all WebContent processes on restart.
2024-06-26 19:44:42 +00:00
auto image_decoder = static_cast<Ladybird::Application*>(QApplication::instance())->image_decoder_client();
auto image_decoder_socket = connect_new_image_decoder_client(*image_decoder).release_value_but_fixme_should_propagate_errors();
Ladybird: Add ability to create a tab without creating a new WebContent
2024-01-30 16:12:14 +00:00
auto candidate_web_content_paths = get_paths_for_helper_process("WebContent"sv).release_value_but_fixme_should_propagate_errors();
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 18:01:05 +00:00
auto new_client = launch_web_content_process(*this, candidate_web_content_paths, AK::move(image_decoder_socket), AK::move(request_server_socket)).release_value_but_fixme_should_propagate_errors();
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 13:23:41 +00:00
Ladybird: Add ability to create a tab without creating a new WebContent
2024-01-30 16:12:14 +00:00
m_client_state.client = new_client;
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-03 01:00:48 +00:00
} else {
m_client_state.client->register_view(m_client_state.page_index, *this);
Ladybird: Add ability to create a tab without creating a new WebContent
2024-01-30 16:12:14 +00: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 13:23:41 +00:00
m_client_state.client->on_web_content_process_crash = [this] {
Ladybird: Remove Web::Platform plugins for Qt in favor of LibCore Now that the Core::EventLoop is driven by a QEventLoop in Ladybird, we don't need to patch LibWeb with Web::Platform plugins. This patch removes EventLoopPluginQt and TimerQt. Note that we can't just replace the Web::Platform abstractions with LibCore stuff immediately, since the Web::Platform APIs use JS::SafeFunction for callbacks.
2023-04-24 16:02:29 +00:00
Core::deferred_invoke([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 13:23:41 +00:00
handle_web_content_process_crash();
});
};
Ladybird: Generate window handle during client creation Generate handle UUID for top-level context that is going to run in created WebContent process and sent it over IPC. Co-authored-by: Timothy Flynn <trflynn89@pm.me>
2023-03-16 15:35:19 +00:00
m_client_state.client_handle = Web::Crypto::generate_random_uuid().release_value_but_fixme_should_propagate_errors();
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-03 01:00:48 +00:00
client().async_set_window_handle(m_client_state.page_index, m_client_state.client_handle);
Ladybird: Generate window handle during client creation Generate handle UUID for top-level context that is going to run in created WebContent process and sent it over IPC. Co-authored-by: Timothy Flynn <trflynn89@pm.me>
2023-03-16 15:35:19 +00:00
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-03 01:00:48 +00:00
client().async_set_device_pixels_per_css_pixel(m_client_state.page_index, m_device_pixel_ratio);
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 21:56:47 +00:00
update_palette();
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 13:23:41 +00:00
Ladybird/Qt: Factor out a method to update the screen rects
2024-05-11 03:00:00 +00:00
update_screen_rects();
WebContent+LibWebView: Consolidate the way browsers connect to WebDriver Currently, on Serenity, we connect to WebDriver from the browser-side of the WebContent connection for both Browser and headless-browser. On Lagom, we connect from within the WebContent process itself, signaled by a command line flag. This patch changes Lagom browsers to connect to WebDriver the same way that Serenity browsers do. This will ensure we can do other initializers in the same order across all platforms and browsers.
2023-03-16 12:50:22 +00:00
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 18:01:05 +00:00
if (auto webdriver_content_ipc_path = WebView::Application::chrome_options().webdriver_content_ipc_path; webdriver_content_ipc_path.has_value())
client().async_connect_to_webdriver(m_client_state.page_index, *webdriver_content_ipc_path);
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 13:23:41 +00:00
}
Ladybird+LibWebView: Migrate cursor changes to LibWebView callbacks
2023-08-23 14:43:27 +00:00
void WebContentView::update_cursor(Gfx::StandardCursor cursor)
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 13:23:41 +00:00
{
switch (cursor) {
Ladybird: Display Qt cursors corresponding to missing CSS cursors
2023-04-14 00:07:54 +00:00
case Gfx::StandardCursor::Hidden:
setCursor(Qt::BlankCursor);
break;
case Gfx::StandardCursor::Arrow:
setCursor(Qt::ArrowCursor);
break;
case Gfx::StandardCursor::Crosshair:
setCursor(Qt::CrossCursor);
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 13:23:41 +00:00
break;
case Gfx::StandardCursor::IBeam:
setCursor(Qt::IBeamCursor);
break;
Ladybird: Display Qt cursors corresponding to missing CSS cursors
2023-04-14 00:07:54 +00:00
case Gfx::StandardCursor::ResizeHorizontal:
setCursor(Qt::SizeHorCursor);
break;
case Gfx::StandardCursor::ResizeVertical:
setCursor(Qt::SizeVerCursor);
break;
case Gfx::StandardCursor::ResizeDiagonalTLBR:
setCursor(Qt::SizeFDiagCursor);
break;
case Gfx::StandardCursor::ResizeDiagonalBLTR:
setCursor(Qt::SizeBDiagCursor);
break;
case Gfx::StandardCursor::ResizeColumn:
setCursor(Qt::SplitHCursor);
break;
case Gfx::StandardCursor::ResizeRow:
setCursor(Qt::SplitVCursor);
break;
case Gfx::StandardCursor::Hand:
setCursor(Qt::PointingHandCursor);
break;
case Gfx::StandardCursor::Help:
setCursor(Qt::WhatsThisCursor);
break;
case Gfx::StandardCursor::Drag:
setCursor(Qt::ClosedHandCursor);
break;
case Gfx::StandardCursor::DragCopy:
setCursor(Qt::DragCopyCursor);
break;
case Gfx::StandardCursor::Move:
setCursor(Qt::DragMoveCursor);
break;
case Gfx::StandardCursor::Wait:
setCursor(Qt::BusyCursor);
break;
case Gfx::StandardCursor::Disallowed:
setCursor(Qt::ForbiddenCursor);
break;
case Gfx::StandardCursor::Eyedropper:
case Gfx::StandardCursor::Zoom:
// FIXME: No corresponding Qt cursors, default to Arrow
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 13:23:41 +00:00
default:
setCursor(Qt::ArrowCursor);
break;
}
}
LibWeb+WebContent: Move scrollbar painting into WebContent The main intention of this change is to have a consistent look and behavior across all scrollbars, including elements with `overflow: scroll` and `overflow: auto`, iframes, and a page. Before: - Page's scrollbar is painted by Browser (Qt/AppKit) using the corresponding UI framework style, - Both WebContent and Browser know the scroll position offset. - WebContent uses did_request_scroll_to() IPC call to send updates. - Browser uses set_viewport_rect() to send updates. After: - Page's scrollbar is painted on WebContent side using the same style as currently used for elements with `overflow: scroll` and `overflow: auto`. A nice side effects: scrollbars are now painted for iframes, and page's scrollbar respects scrollbar-width CSS property. - Only WebContent knows scroll position offset. - did_request_scroll_to() is no longer used. - set_viewport_rect() is changed to set_viewport_size().
2024-06-03 14:53:55 +00:00
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 13:23:41 +00:00
{
LibWeb+WebContent: Move scrollbar painting into WebContent The main intention of this change is to have a consistent look and behavior across all scrollbars, including elements with `overflow: scroll` and `overflow: auto`, iframes, and a page. Before: - Page's scrollbar is painted by Browser (Qt/AppKit) using the corresponding UI framework style, - Both WebContent and Browser know the scroll position offset. - WebContent uses did_request_scroll_to() IPC call to send updates. - Browser uses set_viewport_rect() to send updates. After: - Page's scrollbar is painted on WebContent side using the same style as currently used for elements with `overflow: scroll` and `overflow: auto`. A nice side effects: scrollbars are now painted for iframes, and page's scrollbar respects scrollbar-width CSS property. - Only WebContent knows scroll position offset. - did_request_scroll_to() is no longer used. - set_viewport_rect() is changed to set_viewport_size().
2024-06-03 14:53:55 +00: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 13:23:41 +00: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 15:17:49 +00: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-11 02:15:06 +00: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 14:12:13 +00: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 14:53:55 +00: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 14:12:13 +00: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 14:53:55 +00: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 14:12:13 +00: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 15:17:49 +00: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;
}
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 21:56:47 +00:00
if (event->type() == QEvent::PaletteChange) {
update_palette();
return QAbstractScrollArea::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 12:53:57 +00:00
if (event->type() == QEvent::ShortcutOverride) {
event->accept();
return true;
}
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 15:17:49 +00:00
return QAbstractScrollArea::event(event);
}
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 16:36:26 +00:00
Ladybird: Add --dump-layout-tree mode that dumps layout tree and exits
2023-01-27 09:41:24 +00:00
ErrorOr<String> WebContentView::dump_layout_tree()
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-03 01:00:48 +00:00
return String::from_byte_string(client().dump_layout_tree(m_client_state.page_index));
Ladybird: Add --dump-layout-tree mode that dumps layout tree and exits
2023-01-27 09:41:24 +00:00
}
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 17:52:59 +00: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 12:53:57 +00: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 14:53:55 +00: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 12:53:57 +00:00
auto screen_position = Gfx::IntPoint { event.globalPosition().x() * m_device_pixel_ratio, event.globalPosition().y() * m_device_pixel_ratio };
auto button = get_button_from_qt_event(event);
auto buttons = get_buttons_from_qt_event(event);
auto modifiers = get_modifiers_from_qt_mouse_event(event);
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;
}
int wheel_delta_x = 0;
int wheel_delta_y = 0;
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 12:21:00 +00: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 12:53:57 +00: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();
float delta_x = -static_cast<float>(angle_delta.x()) / 120.0f;
float delta_y = static_cast<float>(angle_delta.y()) / 120.0f;
auto step_x = delta_x * static_cast<float>(QApplication::wheelScrollLines()) * m_device_pixel_ratio;
auto step_y = delta_y * static_cast<float>(QApplication::wheelScrollLines()) * m_device_pixel_ratio;
auto scroll_step_size = static_cast<float>(verticalScrollBar()->singleStep());
wheel_delta_x = static_cast<int>(step_x * scroll_step_size);
wheel_delta_y = static_cast<int>(step_y * scroll_step_size);
}
}
LibWeb+WebContent: Move scrollbar painting into WebContent The main intention of this change is to have a consistent look and behavior across all scrollbars, including elements with `overflow: scroll` and `overflow: auto`, iframes, and a page. Before: - Page's scrollbar is painted by Browser (Qt/AppKit) using the corresponding UI framework style, - Both WebContent and Browser know the scroll position offset. - WebContent uses did_request_scroll_to() IPC call to send updates. - Browser uses set_viewport_rect() to send updates. After: - Page's scrollbar is painted on WebContent side using the same style as currently used for elements with `overflow: scroll` and `overflow: auto`. A nice side effects: scrollbars are now painted for iframes, and page's scrollbar respects scrollbar-width CSS property. - Only WebContent knows scroll position offset. - did_request_scroll_to() is no longer used. - set_viewport_rect() is changed to set_viewport_size().
2024-06-03 14:53:55 +00:00
enqueue_input_event(Web::MouseEvent { type, position, screen_position.to_type<Web::DevicePixels>(), button, buttons, modifiers, wheel_delta_x, wheel_delta_y, 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 12:53:57 +00:00
}
struct KeyData : Web::ChromeInputData {
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)
{
auto keycode = get_keycode_from_qt_keyboard_event(event);
auto modifiers = get_modifiers_from_qt_keyboard_event(event);
auto text = event.text();
auto code_point = text.isEmpty() ? 0u : event.text()[0].unicode();
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: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 19:29:08 +00:00
return { type, Web::UIEvents::KeyCode::Key_Tab, Web::UIEvents::Mod_Shift, '\t', 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 12:53:57 +00: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: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 19:29:08 +00:00
return { type, Web::UIEvents::KeyCode::Key_Return, Web::UIEvents::Mod_Shift, '\n', 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 12:53:57 +00:00
}
return { type, keycode, modifiers, code_point, make<KeyData>(event) };
};
enqueue_input_event(to_web_event());
}
void WebContentView::finish_handling_key_event(Web::KeyEvent const& key_event)
{
auto& chrome_data = verify_cast<KeyData>(*key_event.chrome_data);
auto& event = *chrome_data.event;
switch (key_event.type) {
case Web::KeyEvent::Type::KeyDown:
QAbstractScrollArea::keyPressEvent(&event);
break;
case Web::KeyEvent::Type::KeyUp:
QAbstractScrollArea::keyReleaseEvent(&event);
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 17:52:59 +00:00
}
Reference in a new issue Copy permalink