beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 23:50:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Ladybird/WebContentView.cpp
Karol Kosek e3d9a3426e Ladybird: Port to Core::Stream::File
2023-01-09 22:50:53 +00:00

1100 lines
36 KiB
C++
Raw Blame History

/*
* Copyright (c) 2022, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#define AK_DONT_REPLACE_STD
#include "WebContentView.h"
#include "ConsoleWidget.h"
#include "InspectorWidget.h"
#include "Utilities.h"
#include <AK/Assertions.h>
#include <AK/ByteBuffer.h>
#include <AK/Format.h>
#include <AK/HashTable.h>
#include <AK/LexicalPath.h>
#include <AK/NonnullOwnPtr.h>
#include <AK/StringBuilder.h>
#include <AK/Types.h>
#include <Browser/CookieJar.h>
#include <Kernel/API/KeyCode.h>
#include <LibCore/ArgsParser.h>
#include <LibCore/EventLoop.h>
#include <LibCore/File.h>
#include <LibCore/IODevice.h>
#include <LibCore/MemoryStream.h>
#include <LibCore/Stream.h>
#include <LibCore/System.h>
#include <LibCore/Timer.h>
#include <LibGfx/Bitmap.h>
#include <LibGfx/Font/FontDatabase.h>
#include <LibGfx/PNGWriter.h>
#include <LibGfx/Painter.h>
#include <LibGfx/Rect.h>
#include <LibGfx/SystemTheme.h>
#include <LibJS/Runtime/ConsoleObject.h>
#include <LibMain/Main.h>
#include <LibWeb/Loader/ContentFilter.h>
#include <LibWebView/WebContentClient.h>
#include <QApplication>
#include <QCursor>
#include <QIcon>
#include <QInputDialog>
#include <QLineEdit>
#include <QMessageBox>
#include <QMouseEvent>
#include <QPaintEvent>
#include <QPainter>
#include <QScrollBar>
#include <QSocketNotifier>
#include <QTextEdit>
#include <QTimer>
#include <QToolTip>
WebContentView::WebContentView(StringView webdriver_content_ipc_path)
: m_webdriver_content_ipc_path(webdriver_content_ipc_path)
{
setMouseTracking(true);
setFocusPolicy(Qt::FocusPolicy::StrongFocus);
m_inverse_pixel_scaling_ratio = 1.0 / devicePixelRatio();
verticalScrollBar()->setSingleStep(24);
horizontalScrollBar()->setSingleStep(24);
QObject::connect(verticalScrollBar(), &QScrollBar::valueChanged, [this](int) {
update_viewport_rect();
});
QObject::connect(horizontalScrollBar(), &QScrollBar::valueChanged, [this](int) {
update_viewport_rect();
});
create_client();
}
WebContentView::~WebContentView()
{
close_sub_widgets();
}
void WebContentView::load(AK::URL const& url)
{
m_url = url;
client().async_load_url(url);
}
void WebContentView::load_html(StringView html, AK::URL const& url)
{
m_url = url;
client().async_load_html(html, url);
}
unsigned get_button_from_qt_event(QMouseEvent const& event)
{
if (event.button() == Qt::MouseButton::LeftButton)
return 1;
if (event.button() == Qt::MouseButton::RightButton)
return 2;
if (event.button() == Qt::MouseButton::MiddleButton)
return 4;
if (event.button() == Qt::MouseButton::BackButton)
return 8;
if (event.buttons() == Qt::MouseButton::ForwardButton)
return 16;
return 0;
}
unsigned get_buttons_from_qt_event(QMouseEvent const& event)
{
unsigned buttons = 0;
if (event.buttons() & Qt::MouseButton::LeftButton)
buttons |= 1;
if (event.buttons() & Qt::MouseButton::RightButton)
buttons |= 2;
if (event.buttons() & Qt::MouseButton::MiddleButton)
buttons |= 4;
if (event.buttons() & Qt::MouseButton::BackButton)
buttons |= 8;
if (event.buttons() & Qt::MouseButton::ForwardButton)
buttons |= 16;
return buttons;
}
unsigned get_modifiers_from_qt_mouse_event(QMouseEvent const& event)
{
unsigned modifiers = 0;
if (event.modifiers() & Qt::Modifier::ALT)
modifiers |= 1;
if (event.modifiers() & Qt::Modifier::CTRL)
modifiers |= 2;
if (event.modifiers() & Qt::Modifier::SHIFT)
modifiers |= 4;
return modifiers;
}
unsigned get_modifiers_from_qt_keyboard_event(QKeyEvent const& event)
{
auto modifiers = 0;
if (event.modifiers().testFlag(Qt::AltModifier))
modifiers |= KeyModifier::Mod_Alt;
if (event.modifiers().testFlag(Qt::ControlModifier))
modifiers |= KeyModifier::Mod_Ctrl;
if (event.modifiers().testFlag(Qt::MetaModifier))
modifiers |= KeyModifier::Mod_Super;
if (event.modifiers().testFlag(Qt::ShiftModifier))
modifiers |= KeyModifier::Mod_Shift;
if (event.modifiers().testFlag(Qt::AltModifier))
modifiers |= KeyModifier::Mod_AltGr;
return modifiers;
}
KeyCode get_keycode_from_qt_keyboard_event(QKeyEvent const& event)
{
struct Mapping {
constexpr Mapping(Qt::Key q, KeyCode s)
: qt_key(q)
, serenity_key(s)
{
}
Qt::Key qt_key;
KeyCode serenity_key;
};
constexpr Mapping mappings[] = {
{ Qt::Key_0, Key_0 },
{ Qt::Key_1, Key_1 },
{ Qt::Key_2, Key_2 },
{ Qt::Key_3, Key_3 },
{ Qt::Key_4, Key_4 },
{ Qt::Key_5, Key_5 },
{ Qt::Key_6, Key_6 },
{ Qt::Key_7, Key_7 },
{ Qt::Key_8, Key_8 },
{ Qt::Key_9, Key_9 },
{ Qt::Key_A, Key_A },
{ Qt::Key_Alt, Key_Alt },
{ Qt::Key_Ampersand, Key_Ampersand },
{ Qt::Key_Apostrophe, Key_Apostrophe },
{ Qt::Key_AsciiCircum, Key_Circumflex },
{ Qt::Key_AsciiTilde, Key_Tilde },
{ Qt::Key_Asterisk, Key_Asterisk },
{ Qt::Key_At, Key_AtSign },
{ Qt::Key_B, Key_B },
{ Qt::Key_Backslash, Key_Backslash },
{ Qt::Key_Backspace, Key_Backspace },
{ Qt::Key_Bar, Key_Pipe },
{ Qt::Key_BraceLeft, Key_LeftBrace },
{ Qt::Key_BraceRight, Key_RightBrace },
{ Qt::Key_BracketLeft, Key_LeftBracket },
{ Qt::Key_BracketRight, Key_RightBracket },
{ Qt::Key_C, Key_C },
{ Qt::Key_CapsLock, Key_CapsLock },
{ Qt::Key_Colon, Key_Colon },
{ Qt::Key_Comma, Key_Comma },
{ Qt::Key_Control, Key_Control },
{ Qt::Key_D, Key_D },
{ Qt::Key_Delete, Key_Delete },
{ Qt::Key_Dollar, Key_Dollar },
{ Qt::Key_Down, Key_Down },
{ Qt::Key_E, Key_E },
{ Qt::Key_End, Key_End },
{ Qt::Key_Equal, Key_Equal },
{ Qt::Key_Escape, Key_Escape },
{ Qt::Key_exclamdown, Key_ExclamationPoint },
{ Qt::Key_F, Key_F },
{ Qt::Key_F1, Key_F1 },
{ Qt::Key_F10, Key_F10 },
{ Qt::Key_F11, Key_F11 },
{ Qt::Key_F12, Key_F12 },
{ Qt::Key_F2, Key_F2 },
{ Qt::Key_F3, Key_F3 },
{ Qt::Key_F4, Key_F4 },
{ Qt::Key_F5, Key_F5 },
{ Qt::Key_F6, Key_F6 },
{ Qt::Key_F7, Key_F7 },
{ Qt::Key_F8, Key_F8 },
{ Qt::Key_F9, Key_F9 },
{ Qt::Key_G, Key_G },
{ Qt::Key_Greater, Key_GreaterThan },
{ Qt::Key_H, Key_H },
{ Qt::Key_Home, Key_Home },
{ Qt::Key_I, Key_I },
{ Qt::Key_Insert, Key_Insert },
{ Qt::Key_J, Key_J },
{ Qt::Key_K, Key_K },
{ Qt::Key_L, Key_L },
{ Qt::Key_Left, Key_Left },
{ Qt::Key_Less, Key_LessThan },
{ Qt::Key_M, Key_M },
{ Qt::Key_Menu, Key_Menu },
{ Qt::Key_Minus, Key_Minus },
{ Qt::Key_N, Key_N },
{ Qt::Key_NumLock, Key_NumLock },
{ Qt::Key_O, Key_O },
{ Qt::Key_P, Key_P },
{ Qt::Key_PageDown, Key_PageDown },
{ Qt::Key_PageUp, Key_PageUp },
{ Qt::Key_ParenLeft, Key_LeftParen },
{ Qt::Key_ParenRight, Key_RightParen },
{ Qt::Key_Percent, Key_Percent },
{ Qt::Key_Period, Key_Period },
{ Qt::Key_Plus, Key_Plus },
{ Qt::Key_Print, Key_PrintScreen },
{ Qt::Key_Q, Key_Q },
{ Qt::Key_Question, Key_QuestionMark },
{ Qt::Key_QuoteDbl, Key_DoubleQuote },
{ Qt::Key_R, Key_R },
{ Qt::Key_Return, Key_Return },
{ Qt::Key_Right, Key_Right },
{ Qt::Key_S, Key_S },
{ Qt::Key_ScrollLock, Key_ScrollLock },
{ Qt::Key_Semicolon, Key_Semicolon },
{ Qt::Key_Shift, Key_LeftShift },
{ Qt::Key_Slash, Key_Slash },
{ Qt::Key_Space, Key_Space },
{ Qt::Key_Super_L, Key_Super },
{ Qt::Key_SysReq, Key_SysRq },
{ Qt::Key_T, Key_T },
{ Qt::Key_Tab, Key_Tab },
{ Qt::Key_U, Key_U },
{ Qt::Key_Underscore, Key_Underscore },
{ Qt::Key_Up, Key_Up },
{ Qt::Key_V, Key_V },
{ Qt::Key_W, Key_W },
{ Qt::Key_X, Key_X },
{ Qt::Key_Y, Key_Y },
{ Qt::Key_Z, Key_Z },
};
for (auto const& mapping : mappings) {
if (event.key() == mapping.qt_key)
return mapping.serenity_key;
}
return Key_Invalid;
}
void WebContentView::mouseMoveEvent(QMouseEvent* event)
{
Gfx::IntPoint position(event->position().x() / m_inverse_pixel_scaling_ratio, event->position().y() / m_inverse_pixel_scaling_ratio);
auto buttons = get_buttons_from_qt_event(*event);
auto modifiers = get_modifiers_from_qt_mouse_event(*event);
client().async_mouse_move(to_content(position), 0, buttons, modifiers);
}
void WebContentView::mousePressEvent(QMouseEvent* event)
{
Gfx::IntPoint position(event->position().x() / m_inverse_pixel_scaling_ratio, event->position().y() / m_inverse_pixel_scaling_ratio);
auto button = get_button_from_qt_event(*event);
if (button == 0) {
// We could not convert Qt buttons to something that Lagom 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;
}
auto modifiers = get_modifiers_from_qt_mouse_event(*event);
auto buttons = get_buttons_from_qt_event(*event);
client().async_mouse_down(to_content(position), button, buttons, modifiers);
}
void WebContentView::mouseReleaseEvent(QMouseEvent* event)
{
Gfx::IntPoint position(event->position().x() / m_inverse_pixel_scaling_ratio, event->position().y() / m_inverse_pixel_scaling_ratio);
auto button = get_button_from_qt_event(*event);
if (event->button() & Qt::MouseButton::BackButton) {
emit back_mouse_button();
} else if (event->button() & Qt::MouseButton::ForwardButton) {
emit forward_mouse_button();
}
if (button == 0) {
// We could not convert Qt buttons to something that Lagom 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;
}
auto modifiers = get_modifiers_from_qt_mouse_event(*event);
auto buttons = get_buttons_from_qt_event(*event);
client().async_mouse_up(to_content(position), button, buttons, modifiers);
}
void WebContentView::keyPressEvent(QKeyEvent* event)
{
switch (event->key()) {
case Qt::Key_Left:
case Qt::Key_Right:
case Qt::Key_Up:
case Qt::Key_Down:
case Qt::Key_PageUp:
case Qt::Key_PageDown:
QAbstractScrollArea::keyPressEvent(event);
break;
default:
break;
}
if (event->key() == Qt::Key_Backtab) {
// NOTE: Qt transforms Shift+Tab into a "Backtab", so we undo that transformation here.
client().async_key_down(KeyCode::Key_Tab, Mod_Shift, '\t');
return;
}
auto text = event->text();
if (text.isEmpty()) {
return;
}
auto point = event->text()[0].unicode();
auto keycode = get_keycode_from_qt_keyboard_event(*event);
auto modifiers = get_modifiers_from_qt_keyboard_event(*event);
client().async_key_down(keycode, modifiers, point);
}
void WebContentView::keyReleaseEvent(QKeyEvent* event)
{
auto text = event->text();
if (text.isEmpty()) {
return;
}
auto point = event->text()[0].unicode();
auto keycode = get_keycode_from_qt_keyboard_event(*event);
auto modifiers = get_modifiers_from_qt_keyboard_event(*event);
client().async_key_up(keycode, modifiers, point);
}
void WebContentView::focusInEvent(QFocusEvent*)
{
client().async_set_has_focus(true);
}
void WebContentView::focusOutEvent(QFocusEvent*)
{
client().async_set_has_focus(false);
}
Gfx::IntPoint WebContentView::to_content(Gfx::IntPoint viewport_position) const
{
return viewport_position.translated(horizontalScrollBar()->value(), verticalScrollBar()->value());
}
Gfx::IntPoint WebContentView::to_widget(Gfx::IntPoint content_position) const
{
return content_position.translated(-horizontalScrollBar()->value(), -verticalScrollBar()->value());
}
void WebContentView::paintEvent(QPaintEvent*)
{
QPainter painter(viewport());
painter.scale(m_inverse_pixel_scaling_ratio, m_inverse_pixel_scaling_ratio);
if (auto* bitmap = m_client_state.has_usable_bitmap ? m_client_state.front_bitmap.bitmap.ptr() : m_backup_bitmap.ptr()) {
QImage q_image(bitmap->scanline_u8(0), bitmap->width(), bitmap->height(), QImage::Format_RGB32);
painter.drawImage(QPoint(0, 0), q_image);
return;
}
painter.fillRect(rect(), palette().base());
}
void WebContentView::resizeEvent(QResizeEvent* event)
{
QAbstractScrollArea::resizeEvent(event);
handle_resize();
}
void WebContentView::handle_resize()
{
update_viewport_rect();
if (m_client_state.has_usable_bitmap) {
// NOTE: We keep the outgoing front bitmap as a backup so we have something to paint until we get a new one.
m_backup_bitmap = m_client_state.front_bitmap.bitmap;
}
if (m_client_state.front_bitmap.bitmap)
client().async_remove_backing_store(m_client_state.front_bitmap.id);
if (m_client_state.back_bitmap.bitmap)
client().async_remove_backing_store(m_client_state.back_bitmap.id);
m_client_state.front_bitmap = {};
m_client_state.back_bitmap = {};
m_client_state.has_usable_bitmap = false;
auto available_size = m_viewport_rect.size();
if (available_size.is_empty())
return;
if (auto new_bitmap_or_error = Gfx::Bitmap::try_create_shareable(Gfx::BitmapFormat::BGRx8888, available_size); !new_bitmap_or_error.is_error()) {
m_client_state.front_bitmap.bitmap = new_bitmap_or_error.release_value();
m_client_state.front_bitmap.id = m_client_state.next_bitmap_id++;
client().async_add_backing_store(m_client_state.front_bitmap.id, m_client_state.front_bitmap.bitmap->to_shareable_bitmap());
}
if (auto new_bitmap_or_error = Gfx::Bitmap::try_create_shareable(Gfx::BitmapFormat::BGRx8888, available_size); !new_bitmap_or_error.is_error()) {
m_client_state.back_bitmap.bitmap = new_bitmap_or_error.release_value();
m_client_state.back_bitmap.id = m_client_state.next_bitmap_id++;
client().async_add_backing_store(m_client_state.back_bitmap.id, m_client_state.back_bitmap.bitmap->to_shareable_bitmap());
}
request_repaint();
}
void WebContentView::update_viewport_rect()
{
auto scaled_width = int(viewport()->width() / m_inverse_pixel_scaling_ratio);
auto scaled_height = int(viewport()->height() / m_inverse_pixel_scaling_ratio);
Gfx::IntRect rect(horizontalScrollBar()->value(), verticalScrollBar()->value(), scaled_width, scaled_height);
m_viewport_rect = rect;
client().async_set_viewport_rect(rect);
request_repaint();
}
void WebContentView::debug_request(DeprecatedString const& request, DeprecatedString const& argument)
{
client().async_debug_request(request, argument);
}
void WebContentView::run_javascript(DeprecatedString const& js_source)
{
client().async_run_javascript(js_source);
}
void WebContentView::did_output_js_console_message(i32 message_index)
{
if (m_console_widget)
m_console_widget->notify_about_new_console_message(message_index);
}
void WebContentView::did_get_js_console_messages(i32 start_index, Vector<DeprecatedString> message_types, Vector<DeprecatedString> messages)
{
if (m_console_widget)
m_console_widget->handle_console_messages(start_index, message_types, messages);
}
void WebContentView::ensure_js_console_widget()
{
if (!m_console_widget) {
m_console_widget = new Ladybird::ConsoleWidget;
m_console_widget->setWindowTitle("JS Console");
m_console_widget->resize(640, 480);
m_console_widget->on_js_input = [this](auto js_source) {
client().async_js_console_input(js_source);
};
m_console_widget->on_request_messages = [this](i32 start_index) {
client().async_js_console_request_messages(start_index);
};
}
}
void WebContentView::show_js_console()
{
ensure_js_console_widget();
m_console_widget->show();
}
void WebContentView::ensure_inspector_widget()
{
if (m_inspector_widget)
return;
m_inspector_widget = new Ladybird::InspectorWidget;
m_inspector_widget->setWindowTitle("Inspector");
m_inspector_widget->resize(640, 480);
m_inspector_widget->on_close = [this] {
clear_inspected_dom_node();
};
m_inspector_widget->on_dom_node_inspected = [&](auto id, auto pseudo_element) {
return inspect_dom_node(id, pseudo_element);
};
}
void WebContentView::close_sub_widgets()
{
auto close_widget_window = [](auto* widget) {
if (widget)
widget->close();
};
close_widget_window(m_console_widget);
close_widget_window(m_inspector_widget);
}
bool WebContentView::is_inspector_open() const
{
return m_inspector_widget && m_inspector_widget->isVisible();
}
void WebContentView::inspect_dom_tree()
{
client().async_inspect_dom_tree();
}
ErrorOr<Ladybird::DOMNodeProperties> WebContentView::inspect_dom_node(i32 node_id, Optional<Web::CSS::Selector::PseudoElement> pseudo_element)
{
auto response = client().inspect_dom_node(node_id, pseudo_element);
if (!response.has_style())
return Error::from_string_view("Inspected node returned no style"sv);
return Ladybird::DOMNodeProperties {
.computed_style_json = TRY(String::from_deprecated_string(response.take_computed_style())),
.resolved_style_json = TRY(String::from_deprecated_string(response.take_resolved_style())),
.custom_properties_json = TRY(String::from_deprecated_string(response.take_custom_properties())),
};
}
void WebContentView::clear_inspected_dom_node()
{
(void)inspect_dom_node(0, {});
}
void WebContentView::show_inspector()
{
ensure_inspector_widget();
m_inspector_widget->show();
inspect_dom_tree();
}
void WebContentView::set_color_scheme(ColorScheme color_scheme)
{
switch (color_scheme) {
case ColorScheme::Auto:
client().async_set_preferred_color_scheme(Web::CSS::PreferredColorScheme::Auto);
break;
case ColorScheme::Light:
client().async_set_preferred_color_scheme(Web::CSS::PreferredColorScheme::Light);
break;
case ColorScheme::Dark:
client().async_set_preferred_color_scheme(Web::CSS::PreferredColorScheme::Dark);
break;
}
}
void WebContentView::showEvent(QShowEvent* event)
{
QAbstractScrollArea::showEvent(event);
client().async_set_system_visibility_state(true);
}
void WebContentView::hideEvent(QHideEvent* event)
{
QAbstractScrollArea::hideEvent(event);
client().async_set_system_visibility_state(false);
}
WebContentClient& WebContentView::client()
{
VERIFY(m_client_state.client);
return *m_client_state.client;
}
void WebContentView::create_client()
{
m_client_state = {};
int socket_fds[2] {};
MUST(Core::System::socketpair(AF_LOCAL, SOCK_STREAM, 0, socket_fds));
int ui_fd = socket_fds[0];
int wc_fd = socket_fds[1];
int fd_passing_socket_fds[2] {};
MUST(Core::System::socketpair(AF_LOCAL, SOCK_STREAM, 0, fd_passing_socket_fds));
int ui_fd_passing_fd = fd_passing_socket_fds[0];
int wc_fd_passing_fd = fd_passing_socket_fds[1];
auto child_pid = fork();
if (!child_pid) {
MUST(Core::System::close(ui_fd_passing_fd));
MUST(Core::System::close(ui_fd));
auto takeover_string = DeprecatedString::formatted("WebContent:{}", wc_fd);
MUST(Core::System::setenv("SOCKET_TAKEOVER"sv, takeover_string, true));
auto webcontent_fd_passing_socket_string = DeprecatedString::number(wc_fd_passing_fd);
Vector<StringView> arguments {
"WebContent"sv,
"--webcontent-fd-passing-socket"sv,
webcontent_fd_passing_socket_string
};
if (!m_webdriver_content_ipc_path.is_empty()) {
arguments.append("--webdriver-content-path"sv);
arguments.append(m_webdriver_content_ipc_path);
}
auto result = Core::System::exec("./WebContent/WebContent"sv, arguments, Core::System::SearchInPath::Yes);
if (result.is_error()) {
auto web_content_path = ak_deprecated_string_from_qstring(QCoreApplication::applicationDirPath() + "/WebContent");
result = Core::System::exec(web_content_path, arguments, Core::System::SearchInPath::Yes);
}
if (result.is_error())
warnln("Could not launch WebContent: {}", result.error());
VERIFY_NOT_REACHED();
}
MUST(Core::System::close(wc_fd_passing_fd));
MUST(Core::System::close(wc_fd));
auto socket = MUST(Core::Stream::LocalSocket::adopt_fd(ui_fd));
MUST(socket->set_blocking(true));
auto new_client = MUST(adopt_nonnull_ref_or_enomem(new (nothrow) WebView::WebContentClient(std::move(socket), *this)));
new_client->set_fd_passing_socket(MUST(Core::Stream::LocalSocket::adopt_fd(ui_fd_passing_fd)));
auto* notifier = new QSocketNotifier(new_client->socket().fd().value(), QSocketNotifier::Type::Read);
QObject::connect(notifier, &QSocketNotifier::activated, [new_client = new_client.ptr()] {
if (auto notifier = new_client->socket().notifier())
notifier->on_ready_to_read();
});
struct DeferredInvokerQt final : IPC::DeferredInvoker {
virtual ~DeferredInvokerQt() = default;
virtual void schedule(Function<void()> callback) override
{
QTimer::singleShot(0, std::move(callback));
}
};
new_client->set_deferred_invoker(make<DeferredInvokerQt>());
m_client_state.client = new_client;
m_client_state.client->on_web_content_process_crash = [this] {
QTimer::singleShot(0, [this] {
handle_web_content_process_crash();
});
};
client().async_update_system_theme(MUST(Gfx::load_system_theme(DeprecatedString::formatted("{}/res/themes/Default.ini", s_serenity_resource_root))));
client().async_update_system_fonts(Gfx::FontDatabase::default_font_query(), Gfx::FontDatabase::fixed_width_font_query(), Gfx::FontDatabase::window_title_font_query());
// FIXME: Get the screen rect.
// client().async_update_screen_rects(GUI::Desktop::the().rects(), GUI::Desktop::the().main_screen_index());
}
void WebContentView::handle_web_content_process_crash()
{
dbgln("WebContent process crashed!");
create_client();
VERIFY(m_client_state.client);
// Don't keep a stale backup bitmap around.
m_backup_bitmap = nullptr;
handle_resize();
StringBuilder builder;
builder.append("<html><head><title>Crashed: "sv);
builder.append(escape_html_entities(m_url.to_deprecated_string()));
builder.append("</title></head><body>"sv);
builder.append("<h1>Web page crashed"sv);
if (!m_url.host().is_empty()) {
builder.appendff(" on {}", escape_html_entities(m_url.host()));
}
builder.append("</h1>"sv);
auto escaped_url = escape_html_entities(m_url.to_deprecated_string());
builder.appendff("The web page <a href=\"{}\">{}</a> has crashed.<br><br>You can reload the page to try again.", escaped_url, escaped_url);
builder.append("</body></html>"sv);
load_html(builder.to_deprecated_string(), m_url);
}
void WebContentView::notify_server_did_paint(Badge<WebContentClient>, i32 bitmap_id)
{
if (m_client_state.back_bitmap.id == bitmap_id) {
m_client_state.has_usable_bitmap = true;
m_client_state.back_bitmap.pending_paints--;
swap(m_client_state.back_bitmap, m_client_state.front_bitmap);
// We don't need the backup bitmap anymore, so drop it.
m_backup_bitmap = nullptr;
viewport()->update();
if (m_client_state.got_repaint_requests_while_painting) {
m_client_state.got_repaint_requests_while_painting = false;
request_repaint();
}
}
}
void WebContentView::notify_server_did_invalidate_content_rect(Badge<WebContentClient>, [[maybe_unused]] Gfx::IntRect const& content_rect)
{
request_repaint();
}
void WebContentView::notify_server_did_change_selection(Badge<WebContentClient>)
{
request_repaint();
}
void WebContentView::notify_server_did_request_cursor_change(Badge<WebContentClient>, Gfx::StandardCursor cursor)
{
switch (cursor) {
case Gfx::StandardCursor::Hand:
setCursor(Qt::PointingHandCursor);
break;
case Gfx::StandardCursor::IBeam:
setCursor(Qt::IBeamCursor);
break;
case Gfx::StandardCursor::Arrow:
default:
setCursor(Qt::ArrowCursor);
break;
}
}
void WebContentView::notify_server_did_layout(Badge<WebContentClient>, Gfx::IntSize content_size)
{
verticalScrollBar()->setMinimum(0);
verticalScrollBar()->setMaximum(content_size.height() - m_viewport_rect.height());
verticalScrollBar()->setPageStep(m_viewport_rect.height());
horizontalScrollBar()->setMinimum(0);
horizontalScrollBar()->setMaximum(content_size.width() - m_viewport_rect.width());
horizontalScrollBar()->setPageStep(m_viewport_rect.width());
}
void WebContentView::notify_server_did_change_title(Badge<WebContentClient>, DeprecatedString const& title)
{
emit title_changed(qstring_from_ak_deprecated_string(title));
}
void WebContentView::notify_server_did_request_scroll(Badge<WebContentClient>, i32 x_delta, i32 y_delta)
{
horizontalScrollBar()->setValue(horizontalScrollBar()->value() + x_delta);
verticalScrollBar()->setValue(verticalScrollBar()->value() + y_delta);
}
void WebContentView::notify_server_did_request_scroll_to(Badge<WebContentClient>, Gfx::IntPoint scroll_position)
{
horizontalScrollBar()->setValue(scroll_position.x());
verticalScrollBar()->setValue(scroll_position.y());
}
void WebContentView::notify_server_did_request_scroll_into_view(Badge<WebContentClient>, Gfx::IntRect const& rect)
{
if (m_viewport_rect.contains(rect))
return;
if (rect.top() < m_viewport_rect.top()) {
verticalScrollBar()->setValue(rect.top());
} else if (rect.top() > m_viewport_rect.top() && rect.bottom() > m_viewport_rect.bottom()) {
verticalScrollBar()->setValue(rect.bottom() - m_viewport_rect.height() + 1);
}
}
void WebContentView::notify_server_did_enter_tooltip_area(Badge<WebContentClient>, Gfx::IntPoint content_position, DeprecatedString const& tooltip)
{
auto widget_position = to_widget(content_position);
QToolTip::showText(
mapToGlobal(QPoint(widget_position.x(), widget_position.y())),
qstring_from_ak_deprecated_string(tooltip),
this);
}
void WebContentView::notify_server_did_leave_tooltip_area(Badge<WebContentClient>)
{
QToolTip::hideText();
}
void WebContentView::notify_server_did_hover_link(Badge<WebContentClient>, AK::URL const& url)
{
emit link_hovered(qstring_from_ak_deprecated_string(url.to_deprecated_string()));
}
void WebContentView::notify_server_did_unhover_link(Badge<WebContentClient>)
{
emit link_unhovered();
}
void WebContentView::notify_server_did_click_link(Badge<WebContentClient>, AK::URL const& url, DeprecatedString const& target, unsigned int modifiers)
{
// FIXME
(void)url;
(void)target;
(void)modifiers;
// if (on_link_click)
// on_link_click(url, target, modifiers);
}
void WebContentView::notify_server_did_middle_click_link(Badge<WebContentClient>, AK::URL const& url, DeprecatedString const& target, unsigned int modifiers)
{
(void)url;
(void)target;
(void)modifiers;
}
void WebContentView::notify_server_did_start_loading(Badge<WebContentClient>, AK::URL const& url, bool is_redirect)
{
m_url = url;
emit load_started(url, is_redirect);
if (m_inspector_widget)
m_inspector_widget->clear_dom_json();
}
void WebContentView::notify_server_did_finish_loading(Badge<WebContentClient>, AK::URL const& url)
{
m_url = url;
if (is_inspector_open())
inspect_dom_tree();
}
void WebContentView::notify_server_did_request_navigate_back(Badge<WebContentClient>)
{
emit navigate_back();
}
void WebContentView::notify_server_did_request_navigate_forward(Badge<WebContentClient>)
{
emit navigate_forward();
}
void WebContentView::notify_server_did_request_refresh(Badge<WebContentClient>)
{
emit refresh();
}
void WebContentView::notify_server_did_request_context_menu(Badge<WebContentClient>, Gfx::IntPoint content_position)
{
// FIXME
(void)content_position;
}
void WebContentView::notify_server_did_request_link_context_menu(Badge<WebContentClient>, Gfx::IntPoint content_position, AK::URL const& url, DeprecatedString const&, unsigned)
{
// FIXME
(void)content_position;
(void)url;
}
void WebContentView::notify_server_did_request_image_context_menu(Badge<WebContentClient>, Gfx::IntPoint content_position, AK::URL const& url, DeprecatedString const&, unsigned, Gfx::ShareableBitmap const& bitmap)
{
// FIXME
(void)content_position;
(void)url;
(void)bitmap;
}
void WebContentView::notify_server_did_request_alert(Badge<WebContentClient>, DeprecatedString const& message)
{
m_dialog = new QMessageBox(QMessageBox::Icon::Warning, "Ladybird", qstring_from_ak_deprecated_string(message), QMessageBox::StandardButton::Ok, this);
m_dialog->exec();
client().async_alert_closed();
m_dialog = nullptr;
}
void WebContentView::notify_server_did_request_confirm(Badge<WebContentClient>, DeprecatedString const& message)
{
m_dialog = new QMessageBox(QMessageBox::Icon::Question, "Ladybird", qstring_from_ak_deprecated_string(message), QMessageBox::StandardButton::Ok | QMessageBox::StandardButton::Cancel, this);
auto result = m_dialog->exec();
client().async_confirm_closed(result == QMessageBox::StandardButton::Ok || result == QDialog::Accepted);
m_dialog = nullptr;
}
void WebContentView::notify_server_did_request_prompt(Badge<WebContentClient>, DeprecatedString const& message, DeprecatedString const& default_)
{
m_dialog = new QInputDialog(this);
auto& dialog = static_cast<QInputDialog&>(*m_dialog);
dialog.setWindowTitle("Ladybird");
dialog.setLabelText(qstring_from_ak_deprecated_string(message));
dialog.setTextValue(qstring_from_ak_deprecated_string(default_));
if (dialog.exec() == QDialog::Accepted)
client().async_prompt_closed(ak_deprecated_string_from_qstring(dialog.textValue()));
else
client().async_prompt_closed({});
m_dialog = nullptr;
}
void WebContentView::notify_server_did_request_set_prompt_text(Badge<WebContentClient>, DeprecatedString const& message)
{
if (m_dialog && is<QInputDialog>(*m_dialog))
static_cast<QInputDialog&>(*m_dialog).setTextValue(qstring_from_ak_deprecated_string(message));
}
void WebContentView::notify_server_did_request_accept_dialog(Badge<WebContentClient>)
{
if (m_dialog)
m_dialog->accept();
}
void WebContentView::notify_server_did_request_dismiss_dialog(Badge<WebContentClient>)
{
if (m_dialog)
m_dialog->reject();
}
void WebContentView::get_source()
{
client().async_get_source();
}
void WebContentView::notify_server_did_get_source(AK::URL const& url, DeprecatedString const& source)
{
emit got_source(url, qstring_from_ak_deprecated_string(source));
}
void WebContentView::notify_server_did_get_dom_tree(DeprecatedString const& dom_tree)
{
if (on_get_dom_tree)
on_get_dom_tree(dom_tree);
if (m_inspector_widget)
m_inspector_widget->set_dom_json(dom_tree);
}
void WebContentView::notify_server_did_get_dom_node_properties(i32 node_id, DeprecatedString const& specified_style, DeprecatedString const& computed_style, DeprecatedString const& custom_properties, DeprecatedString const& node_box_sizing)
{
if (on_get_dom_node_properties)
on_get_dom_node_properties(node_id, specified_style, computed_style, custom_properties, node_box_sizing);
}
void WebContentView::notify_server_did_output_js_console_message(i32 message_index)
{
if (m_console_widget)
m_console_widget->notify_about_new_console_message(message_index);
}
void WebContentView::notify_server_did_get_js_console_messages(i32 start_index, Vector<DeprecatedString> const& message_types, Vector<DeprecatedString> const& messages)
{
if (m_console_widget)
m_console_widget->handle_console_messages(start_index, message_types, messages);
}
void WebContentView::notify_server_did_change_favicon(Gfx::Bitmap const& bitmap)
{
auto qimage = QImage(bitmap.scanline_u8(0), bitmap.width(), bitmap.height(), QImage::Format_ARGB32);
if (qimage.isNull())
return;
auto qpixmap = QPixmap::fromImage(qimage);
if (qpixmap.isNull())
return;
emit favicon_changed(QIcon(qpixmap));
}
Vector<Web::Cookie::Cookie> WebContentView::notify_server_did_request_all_cookies(Badge<WebContentClient>, AK::URL const& url)
{
if (on_get_all_cookies)
return on_get_all_cookies(url);
return {};
}
Optional<Web::Cookie::Cookie> WebContentView::notify_server_did_request_named_cookie(Badge<WebContentClient>, AK::URL const& url, DeprecatedString const& name)
{
if (on_get_named_cookie)
return on_get_named_cookie(url, name);
return {};
}
DeprecatedString WebContentView::notify_server_did_request_cookie(Badge<WebContentClient>, AK::URL const& url, Web::Cookie::Source source)
{
if (on_get_cookie)
return on_get_cookie(url, source);
return {};
}
void WebContentView::notify_server_did_set_cookie(Badge<WebContentClient>, AK::URL const& url, Web::Cookie::ParsedCookie const& cookie, Web::Cookie::Source source)
{
if (on_set_cookie)
on_set_cookie(url, cookie, source);
}
void WebContentView::notify_server_did_update_cookie(Badge<WebContentClient>, Web::Cookie::Cookie const& cookie)
{
if (on_update_cookie)
on_update_cookie(cookie);
}
void WebContentView::notify_server_did_update_resource_count(i32 count_waiting)
{
// FIXME
(void)count_waiting;
}
void WebContentView::notify_server_did_request_restore_window()
{
emit restore_window();
}
Gfx::IntPoint WebContentView::notify_server_did_request_reposition_window(Gfx::IntPoint position)
{
return emit reposition_window(position);
}
Gfx::IntSize WebContentView::notify_server_did_request_resize_window(Gfx::IntSize size)
{
return emit resize_window(size);
}
Gfx::IntRect WebContentView::notify_server_did_request_maximize_window()
{
return emit maximize_window();
}
Gfx::IntRect WebContentView::notify_server_did_request_minimize_window()
{
return emit minimize_window();
}
Gfx::IntRect WebContentView::notify_server_did_request_fullscreen_window()
{
return emit fullscreen_window();
}
void WebContentView::notify_server_did_request_file(Badge<WebContentClient>, DeprecatedString const& path, i32 request_id)
{
auto file = Core::Stream::File::open(path, Core::Stream::OpenMode::Read);
if (file.is_error())
client().async_handle_file_return(file.error().code(), {}, request_id);
else
client().async_handle_file_return(0, IPC::File(*file.value()), request_id);
}
void WebContentView::request_repaint()
{
// If this widget was instantiated but not yet added to a window,
// it won't have a back bitmap yet, so we can just skip repaint requests.
if (!m_client_state.back_bitmap.bitmap)
return;
// Don't request a repaint until pending paint requests have finished.
if (m_client_state.back_bitmap.pending_paints) {
m_client_state.got_repaint_requests_while_painting = true;
return;
}
m_client_state.back_bitmap.pending_paints++;
client().async_paint(m_client_state.back_bitmap.bitmap->rect().translated(horizontalScrollBar()->value(), verticalScrollBar()->value()), m_client_state.back_bitmap.id);
}
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;
}
return QAbstractScrollArea::event(event);
}
void WebContentView::notify_server_did_finish_handling_input_event(bool event_was_accepted)
{
// FIXME: Currently Ladybird handles the keyboard shortcuts before passing the event to web content, so
// we don't need to do anything here. But we'll need to once we start asking web content first.
(void)event_was_accepted;
}
void WebContentView::notify_server_did_get_accessibility_tree(DeprecatedString const&)
{
dbgln("TODO: support accessibility tree in Ladybird");
}
Reference in a new issue View git blame Copy permalink