Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-03 23:00:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/UI/Qt/WebContentView.cpp

880 lines
32 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 15:23:41 +02:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 13:19:50 +02:00
* Copyright (c) 2022-2023, Andreas Kling <andreas@ladybird.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 15:23:41 +02:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/Assertions.h>
#include <AK/ByteBuffer.h>
#include <AK/Format.h>
#include <AK/LexicalPath.h>
#include <AK/NonnullOwnPtr.h>
#include <AK/Types.h>
#include <LibCore/EventLoop.h>
Ladybird: Convert theme configuration to resource URIs
2023-11-05 09:46:28 -05: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 15:23:41 +02: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 14:58:06 -04:00
#include <LibGfx/ImageFormats/PNGWriter.h>
Ladybird: Get the system's current color theme settings from Qt There isn't a 1:1 equivalent for all ColorRoles between Qt and LibGfx, but we can at least make an effort to translate the various QPalette preferred colors. This makes text selection look a lot more "native" in Ladybird. :^)
2023-03-15 22:56:47 +01: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 15:23:41 +02: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>
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 13:29:08 -06: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 19:00:42 +02:00
#include <LibWeb/UIEvents/MouseButton.h>
LibWebView+UI: Migrate Ladybird's command line flags to LibWebView Currently, if we want to add a new e.g. WebContent command line option, we have to add it to all of Qt, AppKit, and headless-browser. (Or worse, we only add it to one of these, and we have feature disparity). To prevent this, this moves command line flags to WebView::Application. The flags are assigned to ChromeOptions and WebContentOptions structs. Each chrome can still add its platform-specific options; for example, the Qt chrome has a flag to enable Qt networking. There should be no behavior change here, other than that AppKit will now support command line flags that were previously only supported by Qt.
2024-07-30 14:01:05 -04: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 15:23:41 +02:00
#include <LibWebView/WebContentClient.h>
Everywhere: Move the Ladybird folder to UI
2024-11-09 12:50:33 -05:00
#include <UI/Qt/Application.h>
#include <UI/Qt/StringUtils.h>
#include <UI/Qt/WebContentView.h>
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 15:23:41 +02:00
#include <QApplication>
#include <QCursor>
Ladybird: Update screen rects on client creation This makes pages that use CSS rules like '@media (max-device-width: 600px)' render more correctly. Without this change device-width and height queries would return 0.
2023-06-12 12:52:44 +02: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 15:23:41 +02:00
#include <QIcon>
Ladybird: Accept file drops
2023-01-07 17:40:04 +01: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 15:23:41 +02: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 22:56:47 +01: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 15:23:41 +02: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 11:52:59 -06: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 18:35:06 +02: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 14:01:05 -04:00
WebContentView::WebContentView(QWidget* window, RefPtr<WebView::WebContentClient> parent_client, size_t page_index)
UI/Qt: Do not place the WebView inside a scroll view Now that scrolling and rendering scrollbars is handled entirely in the WebContent process, there's no reason to place the WebView inside scroll views.
2024-11-07 12:46:45 -05:00
: QWidget(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 15:23:41 +02:00
{
Ladybird: Add ability to create a tab without creating a new WebContent
2024-01-30 09:12:14 -07:00
m_client_state.client = parent_client;
m_client_state.page_index = page_index;
UI/Qt: Enable basic IME keyboard input for WebContentView This makes dead keys work (e.g. typing ' and e results in é).
2024-08-12 14:06:41 +02:00
setAttribute(Qt::WA_InputMethodEnabled, true);
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 15:23:41 +02:00
setMouseTracking(true);
Ladybird: Accept file drops
2023-01-07 17:40:04 +01: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 15:23:41 +02:00
Ladybird/WebContentView: Accept focus and notify WebContent on change
2022-10-11 11:38:03 +02: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 15:23:41 +02:00
Ladybird/Qt: Wire up screen added and removed events
2024-04-05 19:19:50 +02: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 14:16:24 +02: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 09:12:14 -07: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 10:50:05 -04:00
on_ready_to_paint = [this]() {
UI/Qt: Do not place the WebView inside a scroll view Now that scrolling and rendering scrollbars is handled entirely in the WebContent process, there's no reason to place the WebView inside scroll views.
2024-11-07 12:46:45 -05:00
update();
Ladybird+LibWebView: Move most of paint handling to LibWebView Storing the backup bitmap is the same across Browser and Ladybird. Just peform that work in LibWebView, and handle only the implementation- specific nuances within the browsers.
2023-05-20 10:50:05 -04:00
};
Ladybird+LibWebView: Migrate cursor changes to LibWebView callbacks
2023-08-23 10:43:27 -04:00
on_cursor_change = [this](auto cursor) {
update_cursor(cursor);
};
Ladybird+LibWebView: Migrate tooltip changes to LibWebView callbacks
2023-08-23 11:11:39 -04: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 16:48:57 +02: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 14:16:24 +02: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 01:11:30 +01: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 11:11:39 -04: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 14:16:24 +02:00
on_leave_tooltip_area = [this]() {
m_tooltip_text.clear();
Ladybird+LibWebView: Migrate tooltip changes to LibWebView callbacks
2023-08-23 11:11:39 -04: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 13:13:59 -07: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 07:53:57 -05:00
on_finish_handling_key_event = [this](auto const& event) {
finish_handling_key_event(event);
};
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 14:47:28 -04:00
on_finish_handling_drag_event = [this](auto const& event) {
finish_handling_drag_event(event);
};
UI/Qt: Assign dropdown handler for select in WebContentView, not Tab This makes `<select>` elements also work outside of Tab content, for example in the Inspector. Co-authored-by: Tim Flynn <trflynn89@serenityos.org>
2024-08-21 11:10:41 +01:00
m_select_dropdown = new QMenu("Select Dropdown", this);
QObject::connect(m_select_dropdown, &QMenu::aboutToHide, this, [this]() {
if (!m_select_dropdown->activeAction())
select_dropdown_closed({});
});
on_request_select_dropdown = [this](Gfx::IntPoint content_position, i32 minimum_width, Vector<Web::HTML::SelectItem> items) {
m_select_dropdown->clear();
m_select_dropdown->setMinimumWidth(minimum_width / device_pixel_ratio());
auto add_menu_item = [this](Web::HTML::SelectItemOption const& item_option, bool in_option_group) {
QAction* action = new QAction(qstring_from_ak_string(in_option_group ? MUST(String::formatted(" {}", item_option.label)) : item_option.label), this);
action->setCheckable(true);
action->setChecked(item_option.selected);
action->setDisabled(item_option.disabled);
action->setData(QVariant(static_cast<uint>(item_option.id)));
QObject::connect(action, &QAction::triggered, this, &WebContentView::select_dropdown_action);
m_select_dropdown->addAction(action);
};
for (auto const& item : items) {
if (item.has<Web::HTML::SelectItemOptionGroup>()) {
auto const& item_option_group = item.get<Web::HTML::SelectItemOptionGroup>();
QAction* subtitle = new QAction(qstring_from_ak_string(item_option_group.label), this);
subtitle->setDisabled(true);
m_select_dropdown->addAction(subtitle);
for (auto const& item_option : item_option_group.items)
add_menu_item(item_option, true);
}
if (item.has<Web::HTML::SelectItemOption>())
add_menu_item(item.get<Web::HTML::SelectItemOption>(), false);
if (item.has<Web::HTML::SelectItemSeparator>())
m_select_dropdown->addSeparator();
}
m_select_dropdown->exec(map_point_to_global_position(content_position));
};
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 15:23:41 +02: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 12:48:00 -04: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 15:23:41 +02:00
UI/Qt: Assign dropdown handler for select in WebContentView, not Tab This makes `<select>` elements also work outside of Tab content, for example in the Inspector. Co-authored-by: Tim Flynn <trflynn89@serenityos.org>
2024-08-21 11:10:41 +01:00
void WebContentView::select_dropdown_action()
{
QAction* action = qobject_cast<QAction*>(sender());
select_dropdown_closed(action->data().value<uint>());
}
Ladybird/Qt: Rename convert functions to reflect their new types This is a follow up to GH-1111 to reflect the new signatures that these functions have.
2024-08-20 19:48:41 +01:00
static Web::UIEvents::MouseButton get_button_from_qt_mouse_button(Qt::MouseButton button)
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 15:23:41 +02:00
{
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 14:47:28 -04:00
if (button == Qt::MouseButton::LeftButton)
LibWeb: Add Web::UIEvents::MouseButton enum, drop dependency on LibGUI This was the only thing LibWeb needed from LibGUI, and we can just duplicate the enum in LibWeb and get rid of a bogus dependency.
2024-06-02 19:00:42 +02:00
return Web::UIEvents::MouseButton::Primary;
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 14:47:28 -04:00
if (button == Qt::MouseButton::RightButton)
LibWeb: Add Web::UIEvents::MouseButton enum, drop dependency on LibGUI This was the only thing LibWeb needed from LibGUI, and we can just duplicate the enum in LibWeb and get rid of a bogus dependency.
2024-06-02 19:00:42 +02:00
return Web::UIEvents::MouseButton::Secondary;
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 14:47:28 -04:00
if (button == Qt::MouseButton::MiddleButton)
LibWeb: Add Web::UIEvents::MouseButton enum, drop dependency on LibGUI This was the only thing LibWeb needed from LibGUI, and we can just duplicate the enum in LibWeb and get rid of a bogus dependency.
2024-06-02 19:00:42 +02:00
return Web::UIEvents::MouseButton::Middle;
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 14:47:28 -04:00
if (button == Qt::MouseButton::BackButton)
LibWeb: Add Web::UIEvents::MouseButton enum, drop dependency on LibGUI This was the only thing LibWeb needed from LibGUI, and we can just duplicate the enum in LibWeb and get rid of a bogus dependency.
2024-06-02 19:00:42 +02:00
return Web::UIEvents::MouseButton::Backward;
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 14:47:28 -04:00
if (button == Qt::MouseButton::ForwardButton)
LibWeb: Add Web::UIEvents::MouseButton enum, drop dependency on LibGUI This was the only thing LibWeb needed from LibGUI, and we can just duplicate the enum in LibWeb and get rid of a bogus dependency.
2024-06-02 19:00:42 +02: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 07:53:57 -05:00
}
Ladybird/Qt: Rename convert functions to reflect their new types This is a follow up to GH-1111 to reflect the new signatures that these functions have.
2024-08-20 19:48:41 +01:00
static Web::UIEvents::MouseButton get_buttons_from_qt_mouse_buttons(Qt::MouseButtons buttons)
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 07:53:57 -05:00
{
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 14:47:28 -04:00
auto result = Web::UIEvents::MouseButton::None;
if (buttons.testFlag(Qt::MouseButton::LeftButton))
result |= Web::UIEvents::MouseButton::Primary;
if (buttons.testFlag(Qt::MouseButton::RightButton))
result |= Web::UIEvents::MouseButton::Secondary;
if (buttons.testFlag(Qt::MouseButton::MiddleButton))
result |= Web::UIEvents::MouseButton::Middle;
if (buttons.testFlag(Qt::MouseButton::BackButton))
result |= Web::UIEvents::MouseButton::Backward;
if (buttons.testFlag(Qt::MouseButton::ForwardButton))
result |= Web::UIEvents::MouseButton::Forward;
return result;
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 15:23:41 +02:00
}
Ladybird/Qt: Rename convert functions to reflect their new types This is a follow up to GH-1111 to reflect the new signatures that these functions have.
2024-08-20 19:48:41 +01:00
static Web::UIEvents::KeyModifier get_modifiers_from_qt_keyboard_modifiers(Qt::KeyboardModifiers modifiers)
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 15:23:41 +02:00
{
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 14:47:28 -04:00
auto result = Web::UIEvents::KeyModifier::Mod_None;
if (modifiers.testFlag(Qt::AltModifier))
result |= Web::UIEvents::KeyModifier::Mod_Alt;
if (modifiers.testFlag(Qt::ControlModifier))
result |= Web::UIEvents::KeyModifier::Mod_Ctrl;
if (modifiers.testFlag(Qt::ShiftModifier))
result |= Web::UIEvents::KeyModifier::Mod_Shift;
return result;
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 15:23:41 +02:00
}
Ladybird/Qt: Rename convert functions to reflect their new types This is a follow up to GH-1111 to reflect the new signatures that these functions have.
2024-08-20 19:48:41 +01:00
static Web::UIEvents::KeyModifier get_modifiers_from_qt_key_event(QKeyEvent const& event)
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 15:23:41 +02: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 13:29:08 -06: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 15:23:41 +02: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 13:29:08 -06: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 15:23:41 +02: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 13:29:08 -06: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 15:23:41 +02: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 13:29:08 -06: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 15:23:41 +02: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 13:29:08 -06:00
modifiers |= Web::UIEvents::KeyModifier::Mod_Shift;
Ladybird: Include the keypad modifier in key events sent to WebContent
2023-07-08 16:01:32 -04: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 13:29:08 -06: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 15:23:41 +02:00
return modifiers;
}
Ladybird/Qt: Rename convert functions to reflect their new types This is a follow up to GH-1111 to reflect the new signatures that these functions have.
2024-08-20 19:48:41 +01:00
static Web::UIEvents::KeyCode get_keycode_from_qt_key_event(QKeyEvent const& event)
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 15:23:41 +02: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 13:29:08 -06: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 15:23:41 +02: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 13:29:08 -06: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 15:23:41 +02:00
};
LibWeb+UI: Detect and handle left vs. right modifier keys Our handling of left vs. right modifiers keys (shift, ctrl, etc.) was largely not to spec. This patch adds explicit UIEvents::KeyCode values for these keys, and updates the UI to match native key events to these keys (as best as we are able).
2024-10-09 08:56:55 -04:00
// FIXME: Qt does not differentiate between left-and-right modifier keys. Unfortunately, it seems like we would have
// to inspect event.nativeScanCode() / event.nativeVirtualKey() to do so, which has platform-dependent values.
// For now, we default to left keys.
Ladybird: Add a few missing Qt-to-Serenity keycode mappings And add a link to the Qt documentation that maps event keys to their enumerated names for convenience.
2023-07-08 16:58:22 -04:00
// https://doc.qt.io/qt-6/qt.html#Key-enum
LibWeb+UI: Detect and handle left vs. right modifier keys Our handling of left vs. right modifiers keys (shift, ctrl, etc.) was largely not to spec. This patch adds explicit UIEvents::KeyCode values for these keys, and updates the UI to match native key events to these keys (as best as we are able).
2024-10-09 08:56:55 -04:00
static constexpr Mapping mappings[] = {
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 13:29:08 -06:00
{ Qt::Key_0, Web::UIEvents::Key_0 },
{ Qt::Key_1, Web::UIEvents::Key_1 },
{ Qt::Key_2, Web::UIEvents::Key_2 },
{ Qt::Key_3, Web::UIEvents::Key_3 },
{ Qt::Key_4, Web::UIEvents::Key_4 },
{ Qt::Key_5, Web::UIEvents::Key_5 },
{ Qt::Key_6, Web::UIEvents::Key_6 },
{ Qt::Key_7, Web::UIEvents::Key_7 },
{ Qt::Key_8, Web::UIEvents::Key_8 },
{ Qt::Key_9, Web::UIEvents::Key_9 },
{ Qt::Key_A, Web::UIEvents::Key_A },
LibWeb+UI: Detect and handle left vs. right modifier keys Our handling of left vs. right modifiers keys (shift, ctrl, etc.) was largely not to spec. This patch adds explicit UIEvents::KeyCode values for these keys, and updates the UI to match native key events to these keys (as best as we are able).
2024-10-09 08:56:55 -04:00
{ Qt::Key_Alt, Web::UIEvents::Key_LeftAlt },
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 13:29:08 -06:00
{ Qt::Key_Ampersand, Web::UIEvents::Key_Ampersand },
{ Qt::Key_Apostrophe, Web::UIEvents::Key_Apostrophe },
{ Qt::Key_AsciiCircum, Web::UIEvents::Key_Circumflex },
{ Qt::Key_AsciiTilde, Web::UIEvents::Key_Tilde },
{ Qt::Key_Asterisk, Web::UIEvents::Key_Asterisk },
{ Qt::Key_At, Web::UIEvents::Key_AtSign },
{ Qt::Key_B, Web::UIEvents::Key_B },
{ Qt::Key_Backslash, Web::UIEvents::Key_Backslash },
{ Qt::Key_Backspace, Web::UIEvents::Key_Backspace },
{ Qt::Key_Bar, Web::UIEvents::Key_Pipe },
{ Qt::Key_BraceLeft, Web::UIEvents::Key_LeftBrace },
{ Qt::Key_BraceRight, Web::UIEvents::Key_RightBrace },
{ Qt::Key_BracketLeft, Web::UIEvents::Key_LeftBracket },
{ Qt::Key_BracketRight, Web::UIEvents::Key_RightBracket },
{ Qt::Key_C, Web::UIEvents::Key_C },
{ Qt::Key_CapsLock, Web::UIEvents::Key_CapsLock },
{ Qt::Key_Colon, Web::UIEvents::Key_Colon },
{ Qt::Key_Comma, Web::UIEvents::Key_Comma },
LibWeb+UI: Detect and handle left vs. right modifier keys Our handling of left vs. right modifiers keys (shift, ctrl, etc.) was largely not to spec. This patch adds explicit UIEvents::KeyCode values for these keys, and updates the UI to match native key events to these keys (as best as we are able).
2024-10-09 08:56:55 -04:00
{ Qt::Key_Control, Web::UIEvents::Key_LeftControl },
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 13:29:08 -06:00
{ Qt::Key_D, Web::UIEvents::Key_D },
{ Qt::Key_Delete, Web::UIEvents::Key_Delete },
{ Qt::Key_Dollar, Web::UIEvents::Key_Dollar },
{ Qt::Key_Down, Web::UIEvents::Key_Down },
{ Qt::Key_E, Web::UIEvents::Key_E },
{ Qt::Key_End, Web::UIEvents::Key_End },
{ Qt::Key_Equal, Web::UIEvents::Key_Equal },
{ Qt::Key_Enter, Web::UIEvents::Key_Return },
{ Qt::Key_Escape, Web::UIEvents::Key_Escape },
{ Qt::Key_Exclam, Web::UIEvents::Key_ExclamationPoint },
{ Qt::Key_exclamdown, Web::UIEvents::Key_ExclamationPoint },
{ Qt::Key_F, Web::UIEvents::Key_F },
{ Qt::Key_F1, Web::UIEvents::Key_F1 },
{ Qt::Key_F10, Web::UIEvents::Key_F10 },
{ Qt::Key_F11, Web::UIEvents::Key_F11 },
{ Qt::Key_F12, Web::UIEvents::Key_F12 },
{ Qt::Key_F2, Web::UIEvents::Key_F2 },
{ Qt::Key_F3, Web::UIEvents::Key_F3 },
{ Qt::Key_F4, Web::UIEvents::Key_F4 },
{ Qt::Key_F5, Web::UIEvents::Key_F5 },
{ Qt::Key_F6, Web::UIEvents::Key_F6 },
{ Qt::Key_F7, Web::UIEvents::Key_F7 },
{ Qt::Key_F8, Web::UIEvents::Key_F8 },
{ Qt::Key_F9, Web::UIEvents::Key_F9 },
{ Qt::Key_G, Web::UIEvents::Key_G },
{ Qt::Key_Greater, Web::UIEvents::Key_GreaterThan },
{ Qt::Key_H, Web::UIEvents::Key_H },
{ Qt::Key_Home, Web::UIEvents::Key_Home },
{ Qt::Key_I, Web::UIEvents::Key_I },
{ Qt::Key_Insert, Web::UIEvents::Key_Insert },
{ Qt::Key_J, Web::UIEvents::Key_J },
{ Qt::Key_K, Web::UIEvents::Key_K },
{ Qt::Key_L, Web::UIEvents::Key_L },
{ Qt::Key_Left, Web::UIEvents::Key_Left },
{ Qt::Key_Less, Web::UIEvents::Key_LessThan },
{ Qt::Key_M, Web::UIEvents::Key_M },
{ Qt::Key_Menu, Web::UIEvents::Key_Menu },
LibWeb+UI: Detect and handle left vs. right modifier keys Our handling of left vs. right modifiers keys (shift, ctrl, etc.) was largely not to spec. This patch adds explicit UIEvents::KeyCode values for these keys, and updates the UI to match native key events to these keys (as best as we are able).
2024-10-09 08:56:55 -04:00
{ Qt::Key_Meta, Web::UIEvents::Key_LeftSuper },
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 13:29:08 -06:00
{ Qt::Key_Minus, Web::UIEvents::Key_Minus },
{ Qt::Key_N, Web::UIEvents::Key_N },
{ Qt::Key_NumberSign, Web::UIEvents::Key_Hashtag },
{ Qt::Key_NumLock, Web::UIEvents::Key_NumLock },
{ Qt::Key_O, Web::UIEvents::Key_O },
{ Qt::Key_P, Web::UIEvents::Key_P },
{ Qt::Key_PageDown, Web::UIEvents::Key_PageDown },
{ Qt::Key_PageUp, Web::UIEvents::Key_PageUp },
{ Qt::Key_ParenLeft, Web::UIEvents::Key_LeftParen },
{ Qt::Key_ParenRight, Web::UIEvents::Key_RightParen },
{ Qt::Key_Percent, Web::UIEvents::Key_Percent },
{ Qt::Key_Period, Web::UIEvents::Key_Period },
{ Qt::Key_Plus, Web::UIEvents::Key_Plus },
{ Qt::Key_Print, Web::UIEvents::Key_PrintScreen },
{ Qt::Key_Q, Web::UIEvents::Key_Q },
{ Qt::Key_Question, Web::UIEvents::Key_QuestionMark },
{ Qt::Key_QuoteDbl, Web::UIEvents::Key_DoubleQuote },
{ Qt::Key_QuoteLeft, Web::UIEvents::Key_Backtick },
{ Qt::Key_R, Web::UIEvents::Key_R },
{ Qt::Key_Return, Web::UIEvents::Key_Return },
{ Qt::Key_Right, Web::UIEvents::Key_Right },
{ Qt::Key_S, Web::UIEvents::Key_S },
{ Qt::Key_ScrollLock, Web::UIEvents::Key_ScrollLock },
{ Qt::Key_Semicolon, Web::UIEvents::Key_Semicolon },
{ Qt::Key_Shift, Web::UIEvents::Key_LeftShift },
{ Qt::Key_Slash, Web::UIEvents::Key_Slash },
{ Qt::Key_Space, Web::UIEvents::Key_Space },
LibWeb+UI: Detect and handle left vs. right modifier keys Our handling of left vs. right modifiers keys (shift, ctrl, etc.) was largely not to spec. This patch adds explicit UIEvents::KeyCode values for these keys, and updates the UI to match native key events to these keys (as best as we are able).
2024-10-09 08:56:55 -04:00
{ Qt::Key_Super_L, Web::UIEvents::Key_LeftSuper },
{ Qt::Key_Super_R, Web::UIEvents::Key_RightSuper },
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 13:29:08 -06:00
{ Qt::Key_SysReq, Web::UIEvents::Key_SysRq },
{ Qt::Key_T, Web::UIEvents::Key_T },
{ Qt::Key_Tab, Web::UIEvents::Key_Tab },
{ Qt::Key_U, Web::UIEvents::Key_U },
{ Qt::Key_Underscore, Web::UIEvents::Key_Underscore },
{ Qt::Key_Up, Web::UIEvents::Key_Up },
{ Qt::Key_V, Web::UIEvents::Key_V },
{ Qt::Key_W, Web::UIEvents::Key_W },
{ Qt::Key_X, Web::UIEvents::Key_X },
{ Qt::Key_Y, Web::UIEvents::Key_Y },
{ Qt::Key_Z, Web::UIEvents::Key_Z },
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 15:23:41 +02: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 13:29:08 -06: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 15:23:41 +02: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 07:53:57 -05: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);
}
UI/Qt: Enable basic IME keyboard input for WebContentView This makes dead keys work (e.g. typing ' and e results in é).
2024-08-12 14:06:41 +02:00
void WebContentView::inputMethodEvent(QInputMethodEvent* event)
{
if (!event->commitString().isEmpty()) {
QKeyEvent keyEvent(QEvent::KeyPress, 0, Qt::NoModifier, event->commitString());
keyPressEvent(&keyEvent);
}
event->accept();
}
QVariant WebContentView::inputMethodQuery(Qt::InputMethodQuery) const
{
return QVariant();
}
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 15:23:41 +02: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 16:48:57 +02: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 14:16:24 +02: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 07:53:57 -05: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 15:23:41 +02: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 07:53:57 -05: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 15:23:41 +02: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 07:53:57 -05: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 02:00:24 +01:00
LibWebView+UI: Remove history traversal WebView callbacks We can handle these entirely within LibWebView.
2024-09-22 13:29:27 -04:00
if (event->button() == Qt::MouseButton::BackButton)
traverse_the_history_by_delta(-1);
else if (event->button() == Qt::MouseButton::ForwardButton)
traverse_the_history_by_delta(1);
LibWeb: Refactor WebContentServer mouse input message to DevicePixel
2023-12-15 17:46:09 +01: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 07:21:00 -05: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 07:53:57 -05: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 15:23:41 +02:00
}
Ladybird: Send the double click event to WebContent
2023-05-13 15:55:10 +01: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 07:53:57 -05:00
enqueue_native_event(Web::MouseEvent::Type::DoubleClick, *event);
Ladybird: Send the double click event to WebContent
2023-05-13 15:55:10 +01:00
}
Ladybird: Accept file drops
2023-01-07 17:40:04 +01:00
void WebContentView::dragEnterEvent(QDragEnterEvent* event)
{
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 14:47:28 -04:00
if (!event->mimeData()->hasUrls())
return;
enqueue_native_event(Web::DragEvent::Type::DragStart, *event);
event->acceptProposedAction();
}
void WebContentView::dragMoveEvent(QDragMoveEvent* event)
{
enqueue_native_event(Web::DragEvent::Type::DragMove, *event);
event->acceptProposedAction();
}
void WebContentView::dragLeaveEvent(QDragLeaveEvent*)
{
// QDragLeaveEvent does not contain any mouse position or button information.
Web::DragEvent event {};
event.type = Web::DragEvent::Type::DragEnd;
enqueue_input_event(AK::move(event));
Ladybird: Accept file drops
2023-01-07 17:40:04 +01:00
}
void WebContentView::dropEvent(QDropEvent* event)
{
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 14:47:28 -04:00
enqueue_native_event(Web::DragEvent::Type::Drop, *event);
Ladybird: Accept file drops
2023-01-07 17:40:04 +01:00
event->acceptProposedAction();
}
Ladybird/WebContentView: Accept focus and notify WebContent on change
2022-10-11 11:38:03 +02:00
void WebContentView::focusInEvent(QFocusEvent*)
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 18:00:48 -07:00
client().async_set_has_focus(m_client_state.page_index, true);
Ladybird/WebContentView: Accept focus and notify WebContent on change
2022-10-11 11:38:03 +02:00
}
void WebContentView::focusOutEvent(QFocusEvent*)
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 18:00:48 -07:00
client().async_set_has_focus(m_client_state.page_index, false);
Ladybird/WebContentView: Accept focus and notify WebContent on change
2022-10-11 11:38:03 +02: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 15:23:41 +02:00
void WebContentView::paintEvent(QPaintEvent*)
{
UI/Qt: Do not place the WebView inside a scroll view Now that scrolling and rendering scrollbars is handled entirely in the WebContent process, there's no reason to place the WebView inside scroll views.
2024-11-07 12:46:45 -05:00
QPainter painter(this);
Ladybird/Qt: Listen to DPI changes and update WebContentView accordingly
2023-12-13 19:10:05 +01: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 15:23:41 +02: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 18:57:14 +02: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 07:17:00 +01: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 18:57:14 +02:00
} else {
bitmap = m_backup_bitmap.ptr();
LibWeb: Refactor int types in WebContentServer to DevicePixels
2023-12-14 07:17:00 +01: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 18:57:14 +02: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 17:56:20 +02: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 18:57:14 +02: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 15:23:41 +02:00
return;
}
painter.fillRect(rect(), palette().base());
}
void WebContentView::resizeEvent(QResizeEvent* event)
{
UI/Qt: Do not place the WebView inside a scroll view Now that scrolling and rendering scrollbars is handled entirely in the WebContent process, there's no reason to place the WebView inside scroll views.
2024-11-07 12:46:45 -05:00
QWidget::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 17:53:55 +03:00
update_viewport_size();
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 07:59:51 +02: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 15:23:41 +02:00
}
Ladybird: Specify window size in layout dump mode
2023-01-30 23:38:19 +03:00
void WebContentView::set_viewport_rect(Gfx::IntRect rect)
{
LibWeb+WebContent: Move scrollbar painting into WebContent The main intention of this change is to have a consistent look and behavior across all scrollbars, including elements with `overflow: scroll` and `overflow: auto`, iframes, and a page. Before: - Page's scrollbar is painted by Browser (Qt/AppKit) using the corresponding UI framework style, - Both WebContent and Browser know the scroll position offset. - WebContent uses did_request_scroll_to() IPC call to send updates. - Browser uses set_viewport_rect() to send updates. After: - Page's scrollbar is painted on WebContent side using the same style as currently used for elements with `overflow: scroll` and `overflow: auto`. A nice side effects: scrollbars are now painted for iframes, and page's scrollbar respects scrollbar-width CSS property. - Only WebContent knows scroll position offset. - did_request_scroll_to() is no longer used. - set_viewport_rect() is changed to set_viewport_size().
2024-06-03 17:53:55 +03: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 23:38:19 +03:00
}
Ladybird/Qt: Listen to DPI changes and update WebContentView accordingly
2023-12-13 19:10:05 +01: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-02 18:00:48 -07: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 17:53:55 +03:00
update_viewport_size();
Ladybird/Qt: Listen to DPI changes and update WebContentView accordingly
2023-12-13 19:10:05 +01: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 17:53:55 +03:00
void WebContentView::update_viewport_size()
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 15:23:41 +02:00
{
UI/Qt: Do not place the WebView inside a scroll view Now that scrolling and rendering scrollbars is handled entirely in the WebContent process, there's no reason to place the WebView inside scroll views.
2024-11-07 12:46:45 -05:00
auto scaled_width = int(width() * m_device_pixel_ratio);
auto scaled_height = int(height() * m_device_pixel_ratio);
LibWeb+WebContent: Move scrollbar painting into WebContent The main intention of this change is to have a consistent look and behavior across all scrollbars, including elements with `overflow: scroll` and `overflow: auto`, iframes, and a page. Before: - Page's scrollbar is painted by Browser (Qt/AppKit) using the corresponding UI framework style, - Both WebContent and Browser know the scroll position offset. - WebContent uses did_request_scroll_to() IPC call to send updates. - Browser uses set_viewport_rect() to send updates. After: - Page's scrollbar is painted on WebContent side using the same style as currently used for elements with `overflow: scroll` and `overflow: auto`. A nice side effects: scrollbars are now painted for iframes, and page's scrollbar respects scrollbar-width CSS property. - Only WebContent knows scroll position offset. - did_request_scroll_to() is no longer used. - set_viewport_rect() is changed to set_viewport_size().
2024-06-03 17:53:55 +03:00
Gfx::IntRect rect(0, 0, scaled_width, scaled_height);
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 15:23:41 +02:00
Ladybird: Specify window size in layout dump mode
2023-01-30 23:38:19 +03:00
set_viewport_rect(rect);
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 15:23:41 +02: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-02 18:00:48 -07: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 17:53:55 +03: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 15:23:41 +02:00
void WebContentView::showEvent(QShowEvent* event)
{
UI/Qt: Do not place the WebView inside a scroll view Now that scrolling and rendering scrollbars is handled entirely in the WebContent process, there's no reason to place the WebView inside scroll views.
2024-11-07 12:46:45 -05:00
QWidget::showEvent(event);
LibWebView+WebContent+UI: Remember the current system visibility state We will want to re-inform WebContent of the system visibility state when we create a new process after a crash. This changes the IPC to just send the enum value directly, instead of a boolean, so that we can just store that enum value directly on the ViewImplementation class.
2024-11-13 11:24:16 -05:00
set_system_visibility_state(Web::HTML::VisibilityState::Visible);
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 15:23:41 +02:00
}
void WebContentView::hideEvent(QHideEvent* event)
{
UI/Qt: Do not place the WebView inside a scroll view Now that scrolling and rendering scrollbars is handled entirely in the WebContent process, there's no reason to place the WebView inside scroll views.
2024-11-07 12:46:45 -05:00
QWidget::hideEvent(event);
LibWebView+WebContent+UI: Remember the current system visibility state We will want to re-inform WebContent of the system visibility state when we create a new process after a crash. This changes the IPC to just send the enum value directly, instead of a boolean, so that we can just store that enum value directly on the ViewImplementation class.
2024-11-13 11:24:16 -05:00
set_system_visibility_state(Web::HTML::VisibilityState::Hidden);
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 15:23:41 +02:00
}
Ladybird: Implement the JavaScript console using a WebContentView This aligns the Ladybird console implementation with the Browser console a bit more, which uses OutOfProcessWebView for rendering console output. This allows us to style the console output to try and match the system theme. Using a WebContentView is simpler than trying to style the old QTextEdit widget, as the console output is HTML with built-in "-libweb-palette-*" colors. These will override any color we set on the QTextEdit widget.
2023-04-22 21:57:08 -04: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 22:56:47 +01:00
{
auto qt_palette = widget.palette();
Ladybird: Implement the JavaScript console using a WebContentView This aligns the Ladybird console implementation with the Browser console a bit more, which uses OutOfProcessWebView for rendering console output. This allows us to style the console output to try and match the system theme. Using a WebContentView is simpler than trying to style the old QTextEdit widget, as the console output is HTML with built-in "-libweb-palette-*" colors. These will override any color we set on the QTextEdit widget.
2023-04-22 21:57:08 -04:00
auto theme_file = mode == WebContentView::PaletteMode::Default ? "Default"sv : "Dark"sv;
Ladybird: Convert theme configuration to resource URIs
2023-11-05 09:46:28 -05: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 17:49:34 +03:30
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 09:46:28 -05: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 22:56:47 +01: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 18:35:06 +02: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 22:56:47 +01:00
return theme;
}
Ladybird: Implement the JavaScript console using a WebContentView This aligns the Ladybird console implementation with the Browser console a bit more, which uses OutOfProcessWebView for rendering console output. This allows us to style the console output to try and match the system theme. Using a WebContentView is simpler than trying to style the old QTextEdit widget, as the console output is HTML with built-in "-libweb-palette-*" colors. These will override any color we set on the QTextEdit widget.
2023-04-22 21:57:08 -04: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 22:56:47 +01: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-02 18:00:48 -07: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 22:56:47 +01:00
}
Ladybird/Qt: Factor out a method to update the screen rects
2024-05-11 15:00:00 +12: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 22:37:39 +01: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 15:00:00 +12: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 22:37:39 +01: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 15:00:00 +12: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 09:12:14 -07: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 15:23:41 +02:00
{
LibWebView+UI: Handle common WebView client initialization in LibWebView No need to have every UI manually implement these common steps.
2024-11-13 16:35:17 -05:00
ViewImplementation::initialize_client(create_new_client);
UI: Send the current system visibility state to new WebContent clients After a crash, we need to inform the new WebContent process of the current system visibility state.
2024-11-13 11:31:06 -05:00
update_palette();
Ladybird/Qt: Factor out a method to update the screen rects
2024-05-11 15:00:00 +12:00
update_screen_rects();
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 15:23:41 +02:00
}
Ladybird+LibWebView: Migrate cursor changes to LibWebView callbacks
2023-08-23 10:43:27 -04: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 15:23:41 +02:00
{
switch (cursor) {
Ladybird: Display Qt cursors corresponding to missing CSS cursors
2023-04-13 20:07:54 -04: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 15:23:41 +02:00
break;
case Gfx::StandardCursor::IBeam:
setCursor(Qt::IBeamCursor);
break;
Ladybird: Display Qt cursors corresponding to missing CSS cursors
2023-04-13 20:07:54 -04: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 15:23:41 +02: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 17:53:55 +03:00
Web::DevicePixelSize WebContentView::viewport_size() const
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 15:23:41 +02:00
{
LibWeb+WebContent: Move scrollbar painting into WebContent The main intention of this change is to have a consistent look and behavior across all scrollbars, including elements with `overflow: scroll` and `overflow: auto`, iframes, and a page. Before: - Page's scrollbar is painted by Browser (Qt/AppKit) using the corresponding UI framework style, - Both WebContent and Browser know the scroll position offset. - WebContent uses did_request_scroll_to() IPC call to send updates. - Browser uses set_viewport_rect() to send updates. After: - Page's scrollbar is painted on WebContent side using the same style as currently used for elements with `overflow: scroll` and `overflow: auto`. A nice side effects: scrollbars are now painted for iframes, and page's scrollbar respects scrollbar-width CSS property. - Only WebContent knows scroll position offset. - did_request_scroll_to() is no longer used. - set_viewport_rect() is changed to set_viewport_size().
2024-06-03 17:53:55 +03:00
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 15:23:41 +02: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 17:17:49 +02:00
Ladybird/Qt: Move positional device pixel ratio adjustment to a helper The code to convert a Gfx::IntPoint to a QPoint adjusted for the device pixel ratio is a bit of a mouthful, and will be needed outside of Tab, so move it to a helper that can be reused.
2024-03-10 22:15:06 -04: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 10:12:13 -04: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 17:53:55 +03:00
return widget_position;
Browser+Ladybird+LibWebView: Virtualize computing content/widget points This will allow moving some copy-pasted functionality from web view implementations to the base LibWebView class.
2023-05-17 10:12:13 -04: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 17:53:55 +03:00
return content_position;
Browser+Ladybird+LibWebView: Virtualize computing content/widget points This will allow moving some copy-pasted functionality from web view implementations to the base LibWebView class.
2023-05-17 10:12:13 -04: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 17:17:49 +02: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 22:56:47 +01:00
if (event->type() == QEvent::PaletteChange) {
update_palette();
UI/Qt: Do not place the WebView inside a scroll view Now that scrolling and rendering scrollbars is handled entirely in the WebContent process, there's no reason to place the WebView inside scroll views.
2024-11-07 12:46:45 -05:00
return QWidget::event(event);
Ladybird: Get the system's current color theme settings from Qt There isn't a 1:1 equivalent for all ColorRoles between Qt and LibGfx, but we can at least make an effort to translate the various QPalette preferred colors. This makes text selection look a lot more "native" in Ladybird. :^)
2023-03-15 22:56:47 +01: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 07:53:57 -05:00
if (event->type() == QEvent::ShortcutOverride) {
event->accept();
return true;
}
UI/Qt: Do not place the WebView inside a scroll view Now that scrolling and rendering scrollbars is handled entirely in the WebContent process, there's no reason to place the WebView inside scroll views.
2024-11-07 12:46:45 -05:00
return QWidget::event(event);
Ladybird/WebContentView: Make Tab and Shift+Tab work These didn't work, for two reasons: 1. Qt swallows all Tab key presses by default. We have to override the event() function in order to receive them. 2. Qt transforms Shift+Tab into a fake "Backtab" key. We have to undo this transformation and send Shift+Tab to WebContent.
2022-10-11 17:17:49 +02:00
}
Ladybird: Add stub for notify_server_did_finish_handling_input_event This doesn't need to do anything yet, but will do once we start passing events to web content *before* they're passed to our GUI.
2022-11-21 16:36:26 +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 07:53:57 -05: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 17:53:55 +03:00
Web::DevicePixelPoint position = { event.position().x() * m_device_pixel_ratio, event.position().y() * m_device_pixel_ratio };
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 07:53:57 -05:00
auto screen_position = Gfx::IntPoint { event.globalPosition().x() * m_device_pixel_ratio, event.globalPosition().y() * m_device_pixel_ratio };
Ladybird/Qt: Rename convert functions to reflect their new types This is a follow up to GH-1111 to reflect the new signatures that these functions have.
2024-08-20 19:48:41 +01:00
auto button = get_button_from_qt_mouse_button(event.button());
auto buttons = get_buttons_from_qt_mouse_buttons(event.buttons());
auto modifiers = get_modifiers_from_qt_keyboard_modifiers(event.modifiers());
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 07:53:57 -05:00
if (button == 0 && (type == Web::MouseEvent::Type::MouseDown || type == Web::MouseEvent::Type::MouseUp)) {
// We could not convert Qt buttons to something that LibWeb can recognize - don't even bother propagating this
// to the web engine as it will not handle it anyway, and it will (currently) assert.
return;
}
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 07:21:00 -05: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 07:53:57 -05: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;
UI/Qt: Do not place the WebView inside a scroll view Now that scrolling and rendering scrollbars is handled entirely in the WebContent process, there's no reason to place the WebView inside scroll views.
2024-11-07 12:46:45 -05:00
static constexpr float scroll_step_size = 24;
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 07:53:57 -05:00
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;
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 17:53:55 +03: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 07:53:57 -05:00
}
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 14:47:28 -04:00
struct DragData : Web::ChromeInputData {
explicit DragData(QDropEvent const& event)
: urls(event.mimeData()->urls())
{
}
QList<QUrl> urls;
};
void WebContentView::enqueue_native_event(Web::DragEvent::Type type, QDropEvent const& event)
{
Web::DevicePixelPoint position = { event.position().x() * m_device_pixel_ratio, event.position().y() * m_device_pixel_ratio };
auto global_position = mapToGlobal(event.position());
auto screen_position = Gfx::IntPoint { global_position.x() * m_device_pixel_ratio, global_position.y() * m_device_pixel_ratio };
Ladybird/Qt: Rename convert functions to reflect their new types This is a follow up to GH-1111 to reflect the new signatures that these functions have.
2024-08-20 19:48:41 +01:00
auto button = get_button_from_qt_mouse_button(Qt::LeftButton);
auto buttons = get_buttons_from_qt_mouse_buttons(event.buttons());
auto modifiers = get_modifiers_from_qt_keyboard_modifiers(event.modifiers());
UI/Qt: Process drag-and-drop events through the web view This forwards all drag-and-drop events from the UI to the WebContent process. If the page accepts the events, the UI does not handle them. Otherwise, we will open the dropped files as file:// URLs.
2024-08-17 14:47:28 -04:00
Vector<Web::HTML::SelectedFile> files;
OwnPtr<DragData> chrome_data;
if (type == Web::DragEvent::Type::DragStart) {
VERIFY(event.mimeData()->hasUrls());
for (auto const& url : event.mimeData()->urls()) {
auto file_path = ak_byte_string_from_qstring(url.toLocalFile());
if (auto file = Web::HTML::SelectedFile::from_file_path(file_path); file.is_error())
warnln("Unable to open file {}: {}", file_path, file.error());
else
files.append(file.release_value());
}
} else if (type == Web::DragEvent::Type::Drop) {
chrome_data = make<DragData>(event);
}
enqueue_input_event(Web::DragEvent { type, position, screen_position.to_type<Web::DevicePixels>(), button, buttons, modifiers, AK::move(files), AK::move(chrome_data) });
}
void WebContentView::finish_handling_drag_event(Web::DragEvent const& event)
{
if (event.type != Web::DragEvent::Type::Drop)
return;
auto const& chrome_data = verify_cast<DragData>(*event.chrome_data);
emit urls_dropped(chrome_data.urls);
}
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 07:53:57 -05: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)
{
Ladybird/Qt: Rename convert functions to reflect their new types This is a follow up to GH-1111 to reflect the new signatures that these functions have.
2024-08-20 19:48:41 +01:00
auto keycode = get_keycode_from_qt_key_event(event);
auto modifiers = get_modifiers_from_qt_key_event(event);
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 07:53:57 -05:00
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.
UI+LibWeb+WebContent: Implement KeyEvent repeat property When a platform key press or release event is repeated, we now pass along a `repeat` flag to indicate that auto-repeating is happening. This flag eventually ends up in `KeyboardEvent.repeat`.
2024-10-22 15:32:42 +02:00
return { type, Web::UIEvents::KeyCode::Key_Tab, Web::UIEvents::Mod_Shift, '\t', event.isAutoRepeat(), 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 07:53:57 -05: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'
UI/Qt: Do not pass left shift modifier on every return
2024-12-01 20:14:46 +04:00
return { type, Web::UIEvents::KeyCode::Key_Return, modifiers, '\n', event.isAutoRepeat(), 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 07:53:57 -05:00
}
UI+LibWeb+WebContent: Implement KeyEvent repeat property When a platform key press or release event is repeated, we now pass along a `repeat` flag to indicate that auto-repeating is happening. This flag eventually ends up in `KeyboardEvent.repeat`.
2024-10-22 15:32:42 +02:00
return { type, keycode, modifiers, code_point, event.isAutoRepeat(), 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 07:53:57 -05:00
};
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:
UI/Qt: Do not place the WebView inside a scroll view Now that scrolling and rendering scrollbars is handled entirely in the WebContent process, there's no reason to place the WebView inside scroll views.
2024-11-07 12:46:45 -05:00
QWidget::keyPressEvent(&event);
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 07:53:57 -05:00
break;
case Web::KeyEvent::Type::KeyUp:
UI/Qt: Do not place the WebView inside a scroll view Now that scrolling and rendering scrollbars is handled entirely in the WebContent process, there's no reason to place the WebView inside scroll views.
2024-11-07 12:46:45 -05:00
QWidget::keyReleaseEvent(&event);
Ladybird/Qt: Handle input events through LibWebView The Qt chrome currently handles all input events before selectively forwarding those events to WebContent. This means that WebContent does not see events like ctrl+c. Here, we make use of LibWebView's input handling and wait for LibWebView to inform the chrome that it should handle the event itself.
2024-03-05 07:53:57 -05:00
break;
}
if (!event.isAccepted())
QApplication::sendEvent(parent(), &event);
}
Ladybird: Move classes and types into the Ladybird namespace We were super inconsistent about this, with most "new" classes living in the Ladybird namespace, while "old" ones were in the global namespace, or even sitting in the Browser namespace.
2023-08-02 11:52:59 -06:00
}
Reference in a new issue Copy permalink