beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-25 09:00:22 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7
ladybird/Ladybird/Qt/Tab.cpp

828 lines
32 KiB
C++
Raw Normal View History

Ladybird: Rudimentary tabbed browsing support This patch removes the browser WebView from the window and places it inside a Tab object, all wrapped up in a QT tab control. So far you can create tabs, but can't close them.
2022-07-05 22:18:21 +00:00
/*
Ladybird: Tweak inaccurate copyright year :^)
2022-07-19 10:23:11 +00:00
* Copyright (c) 2022, Andreas Kling <kling@serenityos.org>
Ladybird: Rudimentary tabbed browsing support This patch removes the browser WebView from the window and places it inside a Tab object, all wrapped up in a QT tab control. So far you can create tabs, but can't close them.
2022-07-05 22:18:21 +00:00
* Copyright (c) 2022, Matthew Costa <ucosty@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include "BrowserWindow.h"
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
#include "Icon.h"
Ladybird: Move ownership of the JS console/inspector to the tab object This is to match Browser, where ownership of all "subwidgets" is placed on the tab as well. This further lets us align the web view callbacks to match Browser's OOPWV as well, which will later let us move them into the base LibWebView class.
2023-05-17 15:54:36 +00:00
#include "InspectorWidget.h"
Ladybird: Add Settings class
2022-07-14 03:41:13 +00:00
#include "Settings.h"
Ladybird: Move Qt-specific classes and functions to a Qt subdirectory This will help a lot with developing chromes for different UI frameworks where we can see which helper classes and processes are really using Qt vs just using it to get at helper data. As a bonus, remove Qt dependency from WebDriver.
2023-08-05 16:42:26 +00:00
#include "StringUtils.h"
Ladybird: Use custom QIconEngine to render scalable/vector icons Rather than render the icons to a 16x16 bitmap, keep them as vector graphics and render them on request. This keeps the icons crisp on high DPI displays.
2023-07-29 18:46:47 +00:00
#include "TVGIconEngine.h"
Ladybird/Qt: Add a couple of missing header includes These are currently included implicitly, but this will no longer be the case after upcoming refactoring.
2023-11-04 20:40:12 +00:00
#include <AK/TemporaryChange.h>
Ladybird: Add a context menu for image elements
2023-05-15 17:43:58 +00:00
#include <LibGfx/ImageFormats/BMPWriter.h>
Ladybird: Replace forward/back/reload SVGs with TVGs Doing this removes the qt6-svg dependency and allows our rasterizer to be used for these little icons (and happens to be a fair bit smaller than the old SVGs).
2023-07-02 21:37:59 +00:00
#include <LibGfx/Painter.h>
Ladybird/Qt: Implement the <input type=file> UI
2024-02-25 18:09:26 +00:00
#include <LibWeb/HTML/SelectedFile.h>
Ladybird/Qt: Add a context menu item to search for the selected text
2023-10-23 16:49:53 +00:00
#include <LibWebView/SearchEngine.h>
Ladybird: Use a web view for the Qt chrome's View Source action Unlike the existing popup window, this will provide syntax highlighting.
2023-08-28 20:36:51 +00:00
#include <LibWebView/SourceHighlighter.h>
Ladybird/Qt: Sanitize user-provided URLs with LibWebView
2023-10-13 13:52:06 +00:00
#include <LibWebView/URL.h>
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
#include <QClipboard>
Ladybird/Qt: Add support for color pickers
2023-09-04 13:46:20 +00:00
#include <QColorDialog>
Ladybird: Rudimentary tabbed browsing support This patch removes the browser WebView from the window and places it inside a Tab object, all wrapped up in a QT tab control. So far you can create tabs, but can't close them.
2022-07-05 22:18:21 +00:00
#include <QCoreApplication>
Ladybird: Use cursor position for context menu
2023-05-21 04:53:38 +00:00
#include <QCursor>
Ladybird/Qt: Show an informational dialog after taking a screenshot The dialog displays where the screenshot is saved and presents an option to open its containing folder.
2024-01-06 15:00:03 +00:00
#include <QDesktopServices>
Ladybird: Add "Open File..." to menu
2023-05-25 21:47:12 +00:00
#include <QFileDialog>
Ladybird: Show hovered link URLs in a conditional UI label The tooltips for hovered links were super awkward when in a tooltip
2022-09-09 12:23:36 +00:00
#include <QFont>
#include <QFontMetrics>
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
#include <QGuiApplication>
Ladybird: Add a context menu for image elements
2023-05-15 17:43:58 +00:00
#include <QImage>
Ladybird+LibWebView: Migrate dialog APIs to LibWebView callbacks
2023-05-17 18:23:34 +00:00
#include <QInputDialog>
Ladybird: Move the page context menu from the BrowserWindow to the Tab This will allow us to show different context menus depending on what element is clicked, much like we do for Browser on Serenity.
2023-05-15 15:49:44 +00:00
#include <QMenu>
Ladybird: Add screenshot actions to the page context menu Browser on Serenity has these actions already.
2023-05-16 11:56:12 +00:00
#include <QMessageBox>
Ladybird/Qt: Implement pasting Web data to the clipboard
2023-11-10 18:44:12 +00:00
#include <QMimeData>
Ladybird: Use vector icons in the browser toolbar We now load SVG icons (via the Qt resource system) and render them into a QIcon (with normal and disabled variants) using system colors. We also re-render them if the system color theme changes. This instantly makes Ladybird look less foreign on my Linux box. I drew the icons myself, and they could definitely be more optimized, but this was my first time using Inkscape. :^)
2023-05-05 13:38:46 +00:00
#include <QPainter>
Ladybird: Replace StatusBar with ToolTip This gives the actual webcontent more space to work with, it also emulates how other browsers does it. In the future we'd like to do something else since only ToolTip can be visible at the same time.
2022-07-13 02:39:38 +00:00
#include <QPoint>
Ladybird/Qt: Show an informational dialog after taking a screenshot The dialog displays where the screenshot is saved and presents an option to open its containing folder.
2024-01-06 15:00:03 +00:00
#include <QPushButton>
Ladybird: Show hovered link URLs in a conditional UI label The tooltips for hovered links were super awkward when in a tooltip
2022-09-09 12:23:36 +00:00
#include <QResizeEvent>
Ladybird: Rudimentary tabbed browsing support This patch removes the browser WebView from the window and places it inside a Tab object, all wrapped up in a QT tab control. So far you can create tabs, but can't close them.
2022-07-05 22:18:21 +00:00
Ladybird: Move classes and types into the Ladybird namespace We were super inconsistent about this, with most "new" classes living in the Ladybird namespace, while "old" ones were in the global namespace, or even sitting in the Browser namespace.
2023-08-02 17:52:59 +00:00
namespace Ladybird {
Ladybird: Use custom QIconEngine to render scalable/vector icons Rather than render the icons to a 16x16 bitmap, keep them as vector graphics and render them on request. This keeps the icons crisp on high DPI displays.
2023-07-29 18:46:47 +00:00
static QIcon create_tvg_icon_with_theme_colors(QString name, QPalette const& palette)
Ladybird: Use vector icons in the browser toolbar We now load SVG icons (via the Qt resource system) and render them into a QIcon (with normal and disabled variants) using system colors. We also re-render them if the system color theme changes. This instantly makes Ladybird look less foreign on my Linux box. I drew the icons myself, and they could definitely be more optimized, but this was my first time using Inkscape. :^)
2023-05-05 13:38:46 +00:00
{
Ladybird: Replace forward/back/reload SVGs with TVGs Doing this removes the qt6-svg dependency and allows our rasterizer to be used for these little icons (and happens to be a fair bit smaller than the old SVGs).
2023-07-02 21:37:59 +00:00
auto path = QString(":/Icons/%1.tvg").arg(name);
Ladybird: Use custom QIconEngine to render scalable/vector icons Rather than render the icons to a 16x16 bitmap, keep them as vector graphics and render them on request. This keeps the icons crisp on high DPI displays.
2023-07-29 18:46:47 +00:00
auto icon_engine = TVGIconEngine::from_file(path);
VERIFY(icon_engine);
auto icon_filter = [](QColor color) {
return [color = Color::from_argb(color.rgba64().toArgb32())](Gfx::Color icon_color) {
return color.with_alpha((icon_color.alpha() * color.alpha()) / 255);
};
Ladybird: Use vector icons in the browser toolbar We now load SVG icons (via the Qt resource system) and render them into a QIcon (with normal and disabled variants) using system colors. We also re-render them if the system color theme changes. This instantly makes Ladybird look less foreign on my Linux box. I drew the icons myself, and they could definitely be more optimized, but this was my first time using Inkscape. :^)
2023-05-05 13:38:46 +00:00
};
Ladybird: Use custom QIconEngine to render scalable/vector icons Rather than render the icons to a 16x16 bitmap, keep them as vector graphics and render them on request. This keeps the icons crisp on high DPI displays.
2023-07-29 18:46:47 +00:00
icon_engine->add_filter(QIcon::Mode::Normal, icon_filter(palette.color(QPalette::ColorGroup::Normal, QPalette::ColorRole::ButtonText)));
icon_engine->add_filter(QIcon::Mode::Disabled, icon_filter(palette.color(QPalette::ColorGroup::Disabled, QPalette::ColorRole::ButtonText)));
return QIcon(icon_engine);
Ladybird: Use vector icons in the browser toolbar We now load SVG icons (via the Qt resource system) and render them into a QIcon (with normal and disabled variants) using system colors. We also re-render them if the system color theme changes. This instantly makes Ladybird look less foreign on my Linux box. I drew the icons myself, and they could definitely be more optimized, but this was my first time using Inkscape. :^)
2023-05-05 13:38:46 +00:00
}
Ladybird: Add ability to create a tab without creating a new WebContent
2024-01-30 16:12:14 +00:00
Tab::Tab(BrowserWindow* window, WebContentOptions const& web_content_options, StringView webdriver_content_ipc_path, RefPtr<WebView::WebContentClient> parent_client, size_t page_index)
Ladybird/Everywhere: Ensure that Qt objects are created with parents This prevents memory leaks detected by both Valgrind and ASAN/LSAN. Valgrind is still suspicious of the leaked JS::VM from Web::Bindings::main_thread_vm() but there's other issues with leak checking all the GC'd objects. Co-Authored-By: Diego Iastrubni <diegoiast@gmail.com>
2022-10-01 18:46:24 +00:00
: QWidget(window)
, m_window(window)
Ladybird: Rudimentary tabbed browsing support This patch removes the browser WebView from the window and places it inside a Tab object, all wrapped up in a QT tab control. So far you can create tabs, but can't close them.
2022-07-05 22:18:21 +00:00
{
m_layout = new QBoxLayout(QBoxLayout::Direction::TopToBottom, this);
Ladybird: Remove spacing between toolbar and web view
2022-09-09 12:27:59 +00:00
m_layout->setSpacing(0);
Ladybird: Rudimentary tabbed browsing support This patch removes the browser WebView from the window and places it inside a Tab object, all wrapped up in a QT tab control. So far you can create tabs, but can't close them.
2022-07-05 22:18:21 +00:00
m_layout->setContentsMargins(0, 0, 0, 0);
Ladybird/Qt: Properly listen for DPI changes on Wayland Some Wayland compositors have support of fractional-scale-v1 protocol. The protocol allows compositor to announce a preferred fractional scale on a per-wl_surface basis. Qt forwards these Wayland events to an application using a usual DevicePixelRatioChange event. However, in contrast to the other platforms, this DevicePixelRatioChange event is issued directly on widgets and not screens. Additionally, the exact fractional scale is stored in QWindow object and not the current screen. Note that in theory it is possible to obtain per-screen fractional scaling on Wayland by interpolating data provided by wl_output and xdg_output events but qtwayland does not do that. If fractional-scale-v1 is not available, qtwayland will still fire per-Widget DevicePixelRatioChange events, but, obviously, with the per-screen possibly larger ceiled scaling. This whole thing makes handling DPI changes on Wayland really simple. All we need to do is to intercept DevicePixelRatioChange events firing on QWindow objects and call the old device_pixel_ratio_changed handler with the window's devicePixelRatio(). The only caveat here is not forget to always set QWidget's parent before calling devicePixelRatio() on it.
2024-01-27 04:14:41 +00:00
m_view = new WebContentView(this, web_content_options, webdriver_content_ipc_path, parent_client, page_index);
Ladybird/Everywhere: Ensure that Qt objects are created with parents This prevents memory leaks detected by both Valgrind and ASAN/LSAN. Valgrind is still suspicious of the leaked JS::VM from Web::Bindings::main_thread_vm() but there's other issues with leak checking all the GC'd objects. Co-Authored-By: Diego Iastrubni <diegoiast@gmail.com>
2022-10-01 18:46:24 +00:00
m_toolbar = new QToolBar(this);
Ladybird: Make LocationEdit its own class Also make return key behave more like other browsers when editing
2023-01-18 14:12:13 +00:00
m_location_edit = new LocationEdit(this);
Ladybird: Rudimentary tabbed browsing support This patch removes the browser WebView from the window and places it inside a Tab object, all wrapped up in a QT tab control. So far you can create tabs, but can't close them.
2022-07-05 22:18:21 +00:00
Ladybird: Show hovered link URLs in a conditional UI label The tooltips for hovered links were super awkward when in a tooltip
2022-09-09 12:23:36 +00:00
m_hover_label = new QLabel(this);
Ladybird: Hide the hovered URL label on startup
2022-09-09 13:19:18 +00:00
m_hover_label->hide();
Ladybird: Show hovered link URLs in a conditional UI label The tooltips for hovered links were super awkward when in a tooltip
2022-09-09 12:23:36 +00:00
m_hover_label->setFrameShape(QFrame::Shape::Box);
m_hover_label->setAutoFillBackground(true);
Ladybird: Prevent QAction leaking In some places in the code QAction instances are added to a parent directly on instantiation. In the case they are not, Valgrind reports them as leaking.
2023-07-19 16:07:50 +00:00
auto* focus_location_editor_action = new QAction("Edit Location", this);
Ladybird: Focus the location editor when creating a new tab This lets you start typing a new URL right after pressing Ctrl+T.
2022-09-12 07:12:04 +00:00
focus_location_editor_action->setShortcut(QKeySequence("Ctrl+L"));
addAction(focus_location_editor_action);
Ladybird: Add keyboard shortcut for focusing the location edit (Ctrl+L)
2022-07-07 00:56:09 +00:00
Ladybird: Rudimentary tabbed browsing support This patch removes the browser WebView from the window and places it inside a Tab object, all wrapped up in a QT tab control. So far you can create tabs, but can't close them.
2022-07-05 22:18:21 +00:00
m_layout->addWidget(m_toolbar);
m_layout->addWidget(m_view);
Ladybird: Use custom QIconEngine to render scalable/vector icons Rather than render the icons to a 16x16 bitmap, keep them as vector graphics and render them on request. This keeps the icons crisp on high DPI displays.
2023-07-29 18:46:47 +00:00
recreate_toolbar_icons();
Ladybird: Use vector icons in the browser toolbar We now load SVG icons (via the Qt resource system) and render them into a QIcon (with normal and disabled variants) using system colors. We also re-render them if the system color theme changes. This instantly makes Ladybird look less foreign on my Linux box. I drew the icons myself, and they could definitely be more optimized, but this was my first time using Inkscape. :^)
2023-05-05 13:38:46 +00:00
Ladybird: Add common handy actions to context menu This commit adds the common actions you'd expect to the Ladybird context menu, arranged like so: ┌──────────────────────────────┐ │ Go Back Alt+Left │ │ Go Forward Alt+Right │ │ Reload Ctrl+R │ │ ──────────────────────────── │ │ Copy Ctrl+C │ │ Select All Ctrl+A │ │ ──────────────────────────── │ │ View Source Ctrl+U │ │ Inspect Element │ └──────────────────────────────┘
2023-05-13 12:07:12 +00:00
m_toolbar->addAction(&m_window->go_back_action());
m_toolbar->addAction(&m_window->go_forward_action());
m_toolbar->addAction(&m_window->reload_action());
Ladybird: Rudimentary tabbed browsing support This patch removes the browser WebView from the window and places it inside a Tab object, all wrapped up in a QT tab control. So far you can create tabs, but can't close them.
2022-07-05 22:18:21 +00:00
m_toolbar->addWidget(m_location_edit);
Ladybird: Fix silly tiny back/forward/reload icons in context menu Rather than set a hacky scale factor on our QIconEngine, just set the icon size for the toolbar icons. This avoids the icons being unnecessarily scaled in other places (i.e. the context menu).
2023-07-30 22:25:32 +00:00
m_toolbar->setIconSize({ 16, 16 });
// This is a little awkward, but without this Qt shrinks the button to the size of the icon.
// Note: toolButtonStyle="0" -> ToolButtonIconOnly.
m_toolbar->setStyleSheet("QToolButton[toolButtonStyle=\"0\"]{width:24px;height:24px}");
m_reset_zoom_button = new QToolButton(m_toolbar);
m_reset_zoom_button->setToolButtonStyle(Qt::ToolButtonTextOnly);
Ladybird: Add tooltip to reset zoom level button
2023-03-31 20:33:42 +00:00
m_reset_zoom_button->setToolTip("Reset zoom level");
Ladybird: Add reset zoom level button to toolbar This is a port of the Browser feature.
2023-03-28 23:25:42 +00:00
m_reset_zoom_button_action = m_toolbar->addWidget(m_reset_zoom_button);
m_reset_zoom_button_action->setVisible(false);
QObject::connect(m_reset_zoom_button, &QAbstractButton::clicked, [this] {
view().reset_zoom();
update_reset_zoom_button();
Ladybird+Browser: Update zoom text on menu after clicking zoom button
2023-08-04 11:37:52 +00:00
m_window->update_zoom_menu();
Ladybird: Add reset zoom level button to toolbar This is a port of the Browser feature.
2023-03-28 23:25:42 +00:00
});
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
view().on_activate_tab = [this] {
WebContent+Everywhere: Add a WebContent IPC to activate a tab
2023-03-20 23:52:00 +00:00
m_window->activate_tab(tab_index());
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
};
WebContent+Everywhere: Add a WebContent IPC to activate a tab
2023-03-20 23:52:00 +00:00
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
view().on_close = [this] {
Ladybird: Handle close event in WebContentView
2023-03-07 03:13:08 +00:00
m_window->close_tab(tab_index());
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
};
Ladybird: Handle close event in WebContentView
2023-03-07 03:13:08 +00:00
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
view().on_link_hover = [this](auto const& url) {
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 14:19:34 +00:00
m_hover_label->setText(qstring_from_ak_string(url.to_byte_string()));
Ladybird: Show hovered link URLs in a conditional UI label The tooltips for hovered links were super awkward when in a tooltip
2022-09-09 12:23:36 +00:00
update_hover_label();
m_hover_label->show();
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
};
view().on_link_unhover = [this]() {
Ladybird: Show hovered link URLs in a conditional UI label The tooltips for hovered links were super awkward when in a tooltip
2022-09-09 12:23:36 +00:00
m_hover_label->hide();
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
};
Ladybird: Rudimentary tabbed browsing support This patch removes the browser WebView from the window and places it inside a Tab object, all wrapped up in a QT tab control. So far you can create tabs, but can't close them.
2022-07-05 22:18:21 +00:00
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
view().on_load_start = [this](const URL& url, bool is_redirect) {
Ladybird: Replace history entry if loading URL because of a redirect We now replace the current history entry if the page-load has been caused because of a redirect. This makes it able to traverse the history if one of the entries redirects you, which previously caused an infinite history traversion loop. Depends on https://github.com/SerenityOS/serenity/pull/16004
2022-11-24 00:52:16 +00:00
// If we are loading due to a redirect, we replace the current history entry
// with the loaded URL
if (is_redirect) {
m_history.replace_current(url, m_title.toUtf8().data());
}
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 14:19:34 +00:00
m_location_edit->setText(url.to_byte_string().characters());
Ladybird: Left-align long url in address bar Previously when there was a very long url that spanned outside of the address bar, the text shown would be the one starting from the very end of the url instead of from the beginning, so you would be seeing the query parameters for example, instead of the domain.
2023-02-01 18:51:56 +00:00
m_location_edit->setCursorPosition(0);
Ladybird: Don't push to history when loading through history navigation Previously we were always pushing to history on the on_load_start callback. Now we only do that if we are NOT navigating through the history navigation (loading pages by going back/forward). This is what the SerenityOS browser does:^)
2022-11-08 12:01:20 +00:00
// Don't add to history if back or forward is pressed
if (!m_is_history_navigation) {
m_history.push(url, m_title.toUtf8().data());
}
m_is_history_navigation = false;
Ladybird: Add common handy actions to context menu This commit adds the common actions you'd expect to the Ladybird context menu, arranged like so: ┌──────────────────────────────┐ │ Go Back Alt+Left │ │ Go Forward Alt+Right │ │ Reload Ctrl+R │ │ ──────────────────────────── │ │ Copy Ctrl+C │ │ Select All Ctrl+A │ │ ──────────────────────────── │ │ View Source Ctrl+U │ │ Inspect Element │ └──────────────────────────────┘
2023-05-13 12:07:12 +00:00
m_window->go_back_action().setEnabled(m_history.can_go_back());
m_window->go_forward_action().setEnabled(m_history.can_go_forward());
Ladybird: Do not enable the reload button if history is empty Not much of an issue currently, but will be once tabs are used to render plain HTML.
2023-08-28 19:54:36 +00:00
m_window->reload_action().setEnabled(!m_history.is_empty());
Ladybird: Move ownership of the JS console/inspector to the tab object This is to match Browser, where ownership of all "subwidgets" is placed on the tab as well. This further lets us align the web view callbacks to match Browser's OOPWV as well, which will later let us move them into the base LibWebView class.
2023-05-17 15:54:36 +00:00
if (m_inspector_widget)
Ladybird/Qt: Port the Inspector to the WebView InspectorClient
2023-11-24 01:04:54 +00:00
m_inspector_widget->reset();
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
};
Ladybird: Move ownership of the JS console/inspector to the tab object This is to match Browser, where ownership of all "subwidgets" is placed on the tab as well. This further lets us align the web view callbacks to match Browser's OOPWV as well, which will later let us move them into the base LibWebView class.
2023-05-17 15:54:36 +00:00
view().on_load_finish = [this](auto&) {
Ladybird/Qt: Port the Inspector to the WebView InspectorClient
2023-11-24 01:04:54 +00:00
if (m_inspector_widget != nullptr && m_inspector_widget->isVisible())
m_inspector_widget->inspect();
Ladybird: Move ownership of the JS console/inspector to the tab object This is to match Browser, where ownership of all "subwidgets" is placed on the tab as well. This further lets us align the web view callbacks to match Browser's OOPWV as well, which will later let us move them into the base LibWebView class.
2023-05-17 15:54:36 +00:00
};
Ladybird: Rudimentary tabbed browsing support This patch removes the browser WebView from the window and places it inside a Tab object, all wrapped up in a QT tab control. So far you can create tabs, but can't close them.
2022-07-05 22:18:21 +00:00
QObject::connect(m_location_edit, &QLineEdit::returnPressed, this, &Tab::location_edit_return_pressed);
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
view().on_title_change = [this](auto const& title) {
Ladybird/Qt: Replace the QString-from-AK helpers with a single method There's no need for 2 overloads for String and DeprecatedString, we can just use a StringView. This also avoids some cases of needlessly allocating a DeprecatedString from a StringView when calling this method.
2023-12-04 14:55:47 +00:00
m_title = qstring_from_ak_string(title);
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
m_history.update_title(title);
emit title_changed(tab_index(), m_title);
};
view().on_favicon_change = [this](auto 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(tab_index(), QIcon(qpixmap));
};
Ladybird+LibWebView: Migrate dialog APIs to LibWebView callbacks
2023-05-17 18:23:34 +00:00
view().on_request_alert = [this](auto const& message) {
m_dialog = new QMessageBox(QMessageBox::Icon::Warning, "Ladybird", qstring_from_ak_string(message), QMessageBox::StandardButton::Ok, &view());
m_dialog->exec();
view().alert_closed();
m_dialog = nullptr;
};
view().on_request_confirm = [this](auto const& message) {
m_dialog = new QMessageBox(QMessageBox::Icon::Question, "Ladybird", qstring_from_ak_string(message), QMessageBox::StandardButton::Ok | QMessageBox::StandardButton::Cancel, &view());
auto result = m_dialog->exec();
view().confirm_closed(result == QMessageBox::StandardButton::Ok || result == QDialog::Accepted);
m_dialog = nullptr;
};
view().on_request_prompt = [this](auto const& message, auto const& default_) {
m_dialog = new QInputDialog(&view());
auto& dialog = static_cast<QInputDialog&>(*m_dialog);
dialog.setWindowTitle("Ladybird");
dialog.setLabelText(qstring_from_ak_string(message));
dialog.setTextValue(qstring_from_ak_string(default_));
if (dialog.exec() == QDialog::Accepted)
Ladybird/Qt: Make String allocation infallible
2023-12-04 15:08:16 +00:00
view().prompt_closed(ak_string_from_qstring(dialog.textValue()));
Ladybird+LibWebView: Migrate dialog APIs to LibWebView callbacks
2023-05-17 18:23:34 +00:00
else
view().prompt_closed({});
m_dialog = nullptr;
};
view().on_request_set_prompt_text = [this](auto const& message) {
if (m_dialog && is<QInputDialog>(*m_dialog))
static_cast<QInputDialog&>(*m_dialog).setTextValue(qstring_from_ak_string(message));
};
view().on_request_accept_dialog = [this]() {
if (m_dialog)
m_dialog->accept();
};
view().on_request_dismiss_dialog = [this]() {
if (m_dialog)
m_dialog->reject();
};
Ladybird/Qt: Add support for color pickers
2023-09-04 13:46:20 +00:00
view().on_request_color_picker = [this](Color current_color) {
m_dialog = new QColorDialog(QColor(current_color.red(), current_color.green(), current_color.blue()), &view());
auto& dialog = static_cast<QColorDialog&>(*m_dialog);
dialog.setWindowTitle("Ladybird");
dialog.setOption(QColorDialog::ShowAlphaChannel, false);
LibWeb: Allow input color to give continuous updates
2023-12-11 05:53:10 +00:00
QObject::connect(&dialog, &QColorDialog::currentColorChanged, this, [this](const QColor& color) {
view().color_picker_update(Color(color.red(), color.green(), color.blue()), Web::HTML::ColorPickerUpdateState::Update);
});
Ladybird/Qt: Add support for color pickers
2023-09-04 13:46:20 +00:00
if (dialog.exec() == QDialog::Accepted)
LibWeb: Allow input color to give continuous updates
2023-12-11 05:53:10 +00:00
view().color_picker_update(Color(dialog.selectedColor().red(), dialog.selectedColor().green(), dialog.selectedColor().blue()), Web::HTML::ColorPickerUpdateState::Closed);
Ladybird/Qt: Add support for color pickers
2023-09-04 13:46:20 +00:00
else
LibWeb: Allow input color to give continuous updates
2023-12-11 05:53:10 +00:00
view().color_picker_update({}, Web::HTML::ColorPickerUpdateState::Closed);
Ladybird/Qt: Add support for color pickers
2023-09-04 13:46:20 +00:00
m_dialog = nullptr;
};
Ladybird/Qt: Implement the <input type=file> UI
2024-02-25 18:09:26 +00:00
view().on_request_file_picker = [this](auto allow_multiple_files) {
Vector<Web::HTML::SelectedFile> selected_files;
auto create_selected_file = [&](auto const& qfile_path) {
auto file_path = ak_byte_string_from_qstring(qfile_path);
if (auto file = Web::HTML::SelectedFile::from_file_path(file_path); file.is_error())
warnln("Unable to open file {}: {}", file_path, file.error());
else
selected_files.append(file.release_value());
};
if (allow_multiple_files == Web::HTML::AllowMultipleFiles::Yes) {
auto paths = QFileDialog::getOpenFileNames(this, "Select files", QDir::homePath(), "All Files (*.*)");
selected_files.ensure_capacity(static_cast<size_t>(paths.size()));
for (auto const& path : paths)
create_selected_file(path);
} else {
auto path = QFileDialog::getOpenFileName(this, "Select file", QDir::homePath(), "All Files (*.*)");
create_selected_file(path);
}
view().file_picker_closed(std::move(selected_files));
};
Ladybird+LibWeb: Add basic select element support
2023-12-07 14:53:49 +00:00
m_select_dropdown = new QMenu("Select Dropdown", this);
QObject::connect(m_select_dropdown, &QMenu::aboutToHide, this, [this]() {
if (!m_select_dropdown->activeAction())
view().select_dropdown_closed({});
});
view().on_request_select_dropdown = [this](Gfx::IntPoint content_position, i32 minimum_width, Vector<Web::HTML::SelectItem> items) {
m_select_dropdown->clear();
LibWeb: Fix select dropdown position when scrolled on a page
2023-12-20 17:17:32 +00:00
m_select_dropdown->setMinimumWidth(minimum_width / view().device_pixel_ratio());
Ladybird+LibWeb: Add basic select element support
2023-12-07 14:53:49 +00:00
for (auto const& item : items) {
select_dropdown_add_item(m_select_dropdown, item);
}
LibWeb: Make request_select_dropdown more similar to context menu api
2023-12-12 21:35:37 +00:00
m_select_dropdown->exec(view().mapToGlobal(QPoint(content_position.x(), content_position.y()) / view().device_pixel_ratio()));
Ladybird+LibWeb: Add basic select element support
2023-12-07 14:53:49 +00:00
};
Ladybird: Focus the location editor when creating a new tab This lets you start typing a new URL right after pressing Ctrl+T.
2022-09-12 07:12:04 +00:00
QObject::connect(focus_location_editor_action, &QAction::triggered, this, &Tab::focus_location_editor);
Ladybird: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 13:23:41 +00:00
Ladybird+LibWebView: Rename some "on get" notifications to "on received" The old names sounded like awkward English to me, as they implied the WebContent process is asking for information. In reality, WebContent is *providing* the information.
2023-08-23 15:25:24 +00:00
view().on_received_source = [this](auto const& url, auto const& source) {
Ladybird: Use a web view for the Qt chrome's View Source action Unlike the existing popup window, this will provide syntax highlighting.
2023-08-28 20:36:51 +00:00
auto html = WebView::highlight_source(url, source);
Ladybird/Qt: Rename new_tab(StringView) to new_tab_from_content Having an overload of new_tab with StringView and QString that each do very different things is uncomfortable, to say the least.
2024-01-31 01:52:59 +00:00
m_window->new_tab_from_content(html, Web::HTML::ActivateTab::Yes);
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
};
Ladybird: Load about:blank in new tabs This makes the JS console usable in new tabs, without having to load something first.
2022-10-07 11:35:40 +00:00
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
view().on_navigate_back = [this]() {
back();
};
view().on_navigate_forward = [this]() {
forward();
};
view().on_refresh = [this]() {
reload();
};
view().on_restore_window = [this]() {
Ladybird: Implement WebDriver's navigation and window control endpoints
2022-11-14 16:24:06 +00:00
m_window->showNormal();
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
};
view().on_reposition_window = [this](auto const& position) {
Ladybird: Implement WebDriver's navigation and window control endpoints
2022-11-14 16:24:06 +00:00
m_window->move(position.x(), position.y());
return Gfx::IntPoint { m_window->x(), m_window->y() };
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
};
view().on_resize_window = [this](auto const& size) {
Ladybird: Implement WebDriver's navigation and window control endpoints
2022-11-14 16:24:06 +00:00
m_window->resize(size.width(), size.height());
return Gfx::IntSize { m_window->width(), m_window->height() };
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
};
view().on_maximize_window = [this]() {
Ladybird: Implement WebDriver's navigation and window control endpoints
2022-11-14 16:24:06 +00:00
m_window->showMaximized();
return Gfx::IntRect { m_window->x(), m_window->y(), m_window->width(), m_window->height() };
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
};
view().on_minimize_window = [this]() {
Ladybird: Implement WebDriver's navigation and window control endpoints
2022-11-14 16:24:06 +00:00
m_window->showMinimized();
return Gfx::IntRect { m_window->x(), m_window->y(), m_window->width(), m_window->height() };
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
};
view().on_fullscreen_window = [this]() {
Ladybird: Implement WebDriver's navigation and window control endpoints
2022-11-14 16:24:06 +00:00
m_window->showFullScreen();
return Gfx::IntRect { m_window->x(), m_window->y(), m_window->width(), m_window->height() };
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
};
Ladybird: Move the page context menu from the BrowserWindow to the Tab This will allow us to show different context menus depending on what element is clicked, much like we do for Browser on Serenity.
2023-05-15 15:49:44 +00:00
Ladybird/Qt: Implement pasting Web data to the clipboard
2023-11-10 18:44:12 +00:00
view().on_insert_clipboard_entry = [](auto const& data, auto const&, auto const& mime_type) {
QByteArray qdata { data.bytes_as_string_view().characters_without_null_termination(), static_cast<qsizetype>(data.bytes_as_string_view().length()) };
auto* mime_data = new QMimeData();
mime_data->setData(qstring_from_ak_string(mime_type), qdata);
auto* clipboard = QGuiApplication::clipboard();
clipboard->setMimeData(mime_data);
};
Ladybird/Qt: Add a context menu item to search for the selected text
2023-10-23 16:49:53 +00:00
auto* search_selected_text_action = new QAction("&Search for <query>", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
search_selected_text_action->setIcon(load_icon_from_uri("resource://icons/16x16/find.png"sv));
Ladybird/Qt: Add a context menu item to search for the selected text
2023-10-23 16:49:53 +00:00
QObject::connect(search_selected_text_action, &QAction::triggered, this, [this]() {
auto url = MUST(String::formatted(Settings::the()->search_engine().query_url, URL::percent_encode(*m_page_context_menu_search_text)));
Everywhere: Use unqualified AK::URL Now possible in LibWeb now that there is no longer a Web::URL.
2024-02-11 07:15:39 +00:00
m_window->new_tab_from_url(URL(url), Web::HTML::ActivateTab::Yes);
Ladybird/Qt: Add a context menu item to search for the selected text
2023-10-23 16:49:53 +00:00
});
Ladybird/Qt: Show an informational dialog after taking a screenshot The dialog displays where the screenshot is saved and presents an option to open its containing folder.
2024-01-06 15:00:03 +00:00
auto take_screenshot = [this](auto type) {
auto& view = this->view();
view.take_screenshot(type)
->when_resolved([this](auto const& path) {
auto message = MUST(String::formatted("Screenshot saved to: {}", path));
QMessageBox dialog(this);
dialog.setWindowTitle("Ladybird");
dialog.setIcon(QMessageBox::Information);
dialog.setText(qstring_from_ak_string(message));
dialog.addButton(QMessageBox::Ok);
dialog.addButton(QMessageBox::Open)->setText("Open folder");
if (dialog.exec() == QMessageBox::Open) {
auto path_url = QUrl::fromLocalFile(qstring_from_ak_string(path.dirname()));
QDesktopServices::openUrl(path_url);
}
})
.when_rejected([this](auto const& error) {
auto error_message = MUST(String::formatted("{}", error));
QMessageBox::warning(this, "Ladybird", qstring_from_ak_string(error_message));
});
};
Ladybird: Add screenshot actions to the page context menu Browser on Serenity has these actions already.
2023-05-16 11:56:12 +00:00
auto* take_visible_screenshot_action = new QAction("Take &Visible Screenshot", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
take_visible_screenshot_action->setIcon(load_icon_from_uri("resource://icons/16x16/filetype-image.png"sv));
Ladybird/Qt: Show an informational dialog after taking a screenshot The dialog displays where the screenshot is saved and presents an option to open its containing folder.
2024-01-06 15:00:03 +00:00
QObject::connect(take_visible_screenshot_action, &QAction::triggered, this, [take_screenshot]() {
take_screenshot(WebView::ViewImplementation::ScreenshotType::Visible);
Ladybird: Add screenshot actions to the page context menu Browser on Serenity has these actions already.
2023-05-16 11:56:12 +00:00
});
auto* take_full_screenshot_action = new QAction("Take &Full Screenshot", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
take_full_screenshot_action->setIcon(load_icon_from_uri("resource://icons/16x16/filetype-image.png"sv));
Ladybird/Qt: Show an informational dialog after taking a screenshot The dialog displays where the screenshot is saved and presents an option to open its containing folder.
2024-01-06 15:00:03 +00:00
QObject::connect(take_full_screenshot_action, &QAction::triggered, this, [take_screenshot]() {
take_screenshot(WebView::ViewImplementation::ScreenshotType::Full);
Ladybird: Add screenshot actions to the page context menu Browser on Serenity has these actions already.
2023-05-16 11:56:12 +00:00
});
Ladybird/Qt: Do not "share" ownership of Qt objects When a QObject subclass (widgets, etc.) are provided a parent, then ownership of that object is passed to the parent. Similarly, objects added to a QLayout are owned by the layout. Thus, do not store these objects in an OwnPtr.
2023-12-04 14:39:22 +00:00
m_page_context_menu = new QMenu("Context menu", this);
Ladybird: Move the page context menu from the BrowserWindow to the Tab This will allow us to show different context menus depending on what element is clicked, much like we do for Browser on Serenity.
2023-05-15 15:49:44 +00:00
m_page_context_menu->addAction(&m_window->go_back_action());
m_page_context_menu->addAction(&m_window->go_forward_action());
m_page_context_menu->addAction(&m_window->reload_action());
m_page_context_menu->addSeparator();
m_page_context_menu->addAction(&m_window->copy_selection_action());
m_page_context_menu->addAction(&m_window->select_all_action());
m_page_context_menu->addSeparator();
Ladybird/Qt: Add a context menu item to search for the selected text
2023-10-23 16:49:53 +00:00
m_page_context_menu->addAction(search_selected_text_action);
m_page_context_menu->addSeparator();
Ladybird: Add screenshot actions to the page context menu Browser on Serenity has these actions already.
2023-05-16 11:56:12 +00:00
m_page_context_menu->addAction(take_visible_screenshot_action);
m_page_context_menu->addAction(take_full_screenshot_action);
m_page_context_menu->addSeparator();
Ladybird: Move the page context menu from the BrowserWindow to the Tab This will allow us to show different context menus depending on what element is clicked, much like we do for Browser on Serenity.
2023-05-15 15:49:44 +00:00
m_page_context_menu->addAction(&m_window->view_source_action());
m_page_context_menu->addAction(&m_window->inspect_dom_node_action());
Ladybird/Qt: Open context menus at requested position
2023-12-12 21:33:36 +00:00
view().on_context_menu_request = [this, search_selected_text_action](Gfx::IntPoint content_position) {
Ladybird/Qt: Add a context menu item to search for the selected text
2023-10-23 16:49:53 +00:00
auto selected_text = Settings::the()->enable_search()
? view().selected_text_with_whitespace_collapsed()
: OptionalNone {};
TemporaryChange change_url { m_page_context_menu_search_text, std::move(selected_text) };
if (m_page_context_menu_search_text.has_value()) {
auto action_text = WebView::format_search_query_for_display(Settings::the()->search_engine().query_url, *m_page_context_menu_search_text);
search_selected_text_action->setText(qstring_from_ak_string(action_text));
search_selected_text_action->setVisible(true);
} else {
search_selected_text_action->setVisible(false);
}
Ladybird/Qt: Open context menus at requested position
2023-12-12 21:33:36 +00:00
m_page_context_menu->exec(view().mapToGlobal(QPoint(content_position.x(), content_position.y()) / view().device_pixel_ratio()));
Ladybird: Move the page context menu from the BrowserWindow to the Tab This will allow us to show different context menus depending on what element is clicked, much like we do for Browser on Serenity.
2023-05-15 15:49:44 +00:00
};
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
Ladybird: Add a context menu for link elements
2023-05-15 16:48:46 +00:00
auto* open_link_action = new QAction("&Open", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
open_link_action->setIcon(load_icon_from_uri("resource://icons/16x16/go-forward.png"sv));
Ladybird: Add a context menu for link elements
2023-05-15 16:48:46 +00:00
QObject::connect(open_link_action, &QAction::triggered, this, [this]() {
open_link(m_link_context_menu_url);
});
auto* open_link_in_new_tab_action = new QAction("&Open in New &Tab", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
open_link_in_new_tab_action->setIcon(load_icon_from_uri("resource://icons/16x16/new-tab.png"sv));
Ladybird: Add a context menu for link elements
2023-05-15 16:48:46 +00:00
QObject::connect(open_link_in_new_tab_action, &QAction::triggered, this, [this]() {
open_link_in_new_tab(m_link_context_menu_url);
});
Ladybird/Qt: Implement "Copy Email/Phone" menu item for links
2023-12-05 13:04:15 +00:00
m_link_context_menu_copy_url_action = new QAction("Copy &URL", this);
m_link_context_menu_copy_url_action->setIcon(load_icon_from_uri("resource://icons/16x16/edit-copy.png"sv));
QObject::connect(m_link_context_menu_copy_url_action, &QAction::triggered, this, [this]() {
Ladybird: Add a context menu for link elements
2023-05-15 16:48:46 +00:00
copy_link_url(m_link_context_menu_url);
});
Ladybird/Qt: Do not "share" ownership of Qt objects When a QObject subclass (widgets, etc.) are provided a parent, then ownership of that object is passed to the parent. Similarly, objects added to a QLayout are owned by the layout. Thus, do not store these objects in an OwnPtr.
2023-12-04 14:39:22 +00:00
m_link_context_menu = new QMenu("Link context menu", this);
Ladybird: Add a context menu for link elements
2023-05-15 16:48:46 +00:00
m_link_context_menu->addAction(open_link_action);
m_link_context_menu->addAction(open_link_in_new_tab_action);
m_link_context_menu->addSeparator();
Ladybird/Qt: Implement "Copy Email/Phone" menu item for links
2023-12-05 13:04:15 +00:00
m_link_context_menu->addAction(m_link_context_menu_copy_url_action);
Ladybird: Add a context menu for link elements
2023-05-15 16:48:46 +00:00
m_link_context_menu->addSeparator();
m_link_context_menu->addAction(&m_window->inspect_dom_node_action());
Ladybird/Qt: Open context menus at requested position
2023-12-12 21:33:36 +00:00
view().on_link_context_menu_request = [this](auto const& url, Gfx::IntPoint content_position) {
Ladybird: Add a context menu for link elements
2023-05-15 16:48:46 +00:00
m_link_context_menu_url = url;
Ladybird/Qt: Implement "Copy Email/Phone" menu item for links
2023-12-05 13:04:15 +00:00
switch (WebView::url_type(url)) {
case WebView::URLType::Email:
m_link_context_menu_copy_url_action->setText("Copy &Email Address");
break;
case WebView::URLType::Telephone:
m_link_context_menu_copy_url_action->setText("Copy &Phone Number");
break;
case WebView::URLType::Other:
m_link_context_menu_copy_url_action->setText("Copy &URL");
break;
}
Ladybird/Qt: Open context menus at requested position
2023-12-12 21:33:36 +00:00
m_link_context_menu->exec(view().mapToGlobal(QPoint(content_position.x(), content_position.y()) / view().device_pixel_ratio()));
Ladybird: Add a context menu for link elements
2023-05-15 16:48:46 +00:00
};
Ladybird: Add a context menu for image elements
2023-05-15 17:43:58 +00:00
auto* open_image_action = new QAction("&Open Image", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
open_image_action->setIcon(load_icon_from_uri("resource://icons/16x16/filetype-image.png"sv));
Ladybird: Add a context menu for image elements
2023-05-15 17:43:58 +00:00
QObject::connect(open_image_action, &QAction::triggered, this, [this]() {
open_link(m_image_context_menu_url);
});
auto* open_image_in_new_tab_action = new QAction("&Open Image in New &Tab", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
open_image_in_new_tab_action->setIcon(load_icon_from_uri("resource://icons/16x16/new-tab.png"sv));
Ladybird: Add a context menu for image elements
2023-05-15 17:43:58 +00:00
QObject::connect(open_image_in_new_tab_action, &QAction::triggered, this, [this]() {
open_link_in_new_tab(m_image_context_menu_url);
});
auto* copy_image_action = new QAction("&Copy Image", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
copy_image_action->setIcon(load_icon_from_uri("resource://icons/16x16/edit-copy.png"sv));
Ladybird: Add a context menu for image elements
2023-05-15 17:43:58 +00:00
QObject::connect(copy_image_action, &QAction::triggered, this, [this]() {
auto* bitmap = m_image_context_menu_bitmap.bitmap();
if (bitmap == nullptr)
return;
auto data = Gfx::BMPWriter::encode(*bitmap);
if (data.is_error())
return;
auto image = QImage::fromData(data.value().data(), data.value().size(), "BMP");
if (image.isNull())
return;
auto* clipboard = QGuiApplication::clipboard();
clipboard->setImage(image);
});
auto* copy_image_url_action = new QAction("Copy Image &URL", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
copy_image_url_action->setIcon(load_icon_from_uri("resource://icons/16x16/edit-copy.png"sv));
Ladybird: Add a context menu for image elements
2023-05-15 17:43:58 +00:00
QObject::connect(copy_image_url_action, &QAction::triggered, this, [this]() {
copy_link_url(m_image_context_menu_url);
});
Ladybird/Qt: Do not "share" ownership of Qt objects When a QObject subclass (widgets, etc.) are provided a parent, then ownership of that object is passed to the parent. Similarly, objects added to a QLayout are owned by the layout. Thus, do not store these objects in an OwnPtr.
2023-12-04 14:39:22 +00:00
m_image_context_menu = new QMenu("Image context menu", this);
Ladybird: Add a context menu for image elements
2023-05-15 17:43:58 +00:00
m_image_context_menu->addAction(open_image_action);
m_image_context_menu->addAction(open_image_in_new_tab_action);
m_image_context_menu->addSeparator();
m_image_context_menu->addAction(copy_image_action);
m_image_context_menu->addAction(copy_image_url_action);
m_image_context_menu->addSeparator();
m_image_context_menu->addAction(&m_window->inspect_dom_node_action());
Ladybird/Qt: Open context menus at requested position
2023-12-12 21:33:36 +00:00
view().on_image_context_menu_request = [this](auto& image_url, Gfx::IntPoint content_position, Gfx::ShareableBitmap const& shareable_bitmap) {
Ladybird: Add a context menu for image elements
2023-05-15 17:43:58 +00:00
m_image_context_menu_url = image_url;
m_image_context_menu_bitmap = shareable_bitmap;
Ladybird/Qt: Open context menus at requested position
2023-12-12 21:33:36 +00:00
m_image_context_menu->exec(view().mapToGlobal(QPoint(content_position.x(), content_position.y()) / view().device_pixel_ratio()));
Ladybird: Add a context menu for image elements
2023-05-15 17:43:58 +00:00
};
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
m_media_context_menu_play_icon = load_icon_from_uri("resource://icons/16x16/play.png"sv);
m_media_context_menu_pause_icon = load_icon_from_uri("resource://icons/16x16/pause.png"sv);
m_media_context_menu_mute_icon = load_icon_from_uri("resource://icons/16x16/audio-volume-muted.png"sv);
m_media_context_menu_unmute_icon = load_icon_from_uri("resource://icons/16x16/audio-volume-high.png"sv);
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
Ladybird/Qt: Do not "share" ownership of Qt objects When a QObject subclass (widgets, etc.) are provided a parent, then ownership of that object is passed to the parent. Similarly, objects added to a QLayout are owned by the layout. Thus, do not store these objects in an OwnPtr.
2023-12-04 14:39:22 +00:00
m_media_context_menu_play_pause_action = new QAction("&Play", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
m_media_context_menu_play_pause_action->setIcon(m_media_context_menu_play_icon);
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 14:51:38 +00:00
QObject::connect(m_media_context_menu_play_pause_action, &QAction::triggered, this, [this]() {
view().toggle_media_play_state();
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
});
Ladybird/Qt: Do not "share" ownership of Qt objects When a QObject subclass (widgets, etc.) are provided a parent, then ownership of that object is passed to the parent. Similarly, objects added to a QLayout are owned by the layout. Thus, do not store these objects in an OwnPtr.
2023-12-04 14:39:22 +00:00
m_media_context_menu_mute_unmute_action = new QAction("&Mute", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
m_media_context_menu_mute_unmute_action->setIcon(m_media_context_menu_mute_icon);
Ladybird+LibWeb+WebContent: Add context menu controls for muting audio
2023-06-16 15:29:54 +00:00
QObject::connect(m_media_context_menu_mute_unmute_action, &QAction::triggered, this, [this]() {
view().toggle_media_mute_state();
});
Ladybird/Qt: Do not "share" ownership of Qt objects When a QObject subclass (widgets, etc.) are provided a parent, then ownership of that object is passed to the parent. Similarly, objects added to a QLayout are owned by the layout. Thus, do not store these objects in an OwnPtr.
2023-12-04 14:39:22 +00:00
m_media_context_menu_controls_action = new QAction("Show &Controls", this);
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 14:51:38 +00:00
m_media_context_menu_controls_action->setCheckable(true);
QObject::connect(m_media_context_menu_controls_action, &QAction::triggered, this, [this]() {
view().toggle_media_controls_state();
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
});
Ladybird/Qt: Do not "share" ownership of Qt objects When a QObject subclass (widgets, etc.) are provided a parent, then ownership of that object is passed to the parent. Similarly, objects added to a QLayout are owned by the layout. Thus, do not store these objects in an OwnPtr.
2023-12-04 14:39:22 +00:00
m_media_context_menu_loop_action = new QAction("&Loop", this);
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 14:51:38 +00:00
m_media_context_menu_loop_action->setCheckable(true);
QObject::connect(m_media_context_menu_loop_action, &QAction::triggered, this, [this]() {
view().toggle_media_loop_state();
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
});
Ladybird: Add context menu items to directly open audio files After commit 7ec7015, we can open audio documents directly. This adds content menu items to do so, similar to images and videos.
2023-06-19 11:15:13 +00:00
auto* open_audio_action = new QAction("&Open Audio", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
open_audio_action->setIcon(load_icon_from_uri("resource://icons/16x16/filetype-sound.png"sv));
Ladybird: Add context menu items to directly open audio files After commit 7ec7015, we can open audio documents directly. This adds content menu items to do so, similar to images and videos.
2023-06-19 11:15:13 +00:00
QObject::connect(open_audio_action, &QAction::triggered, this, [this]() {
open_link(m_media_context_menu_url);
});
auto* open_audio_in_new_tab_action = new QAction("Open Audio in New &Tab", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
open_audio_in_new_tab_action->setIcon(load_icon_from_uri("resource://icons/16x16/new-tab.png"sv));
Ladybird: Add context menu items to directly open audio files After commit 7ec7015, we can open audio documents directly. This adds content menu items to do so, similar to images and videos.
2023-06-19 11:15:13 +00:00
QObject::connect(open_audio_in_new_tab_action, &QAction::triggered, this, [this]() {
open_link_in_new_tab(m_media_context_menu_url);
});
Ladybird: Add a context menu for audio elements
2023-06-16 15:05:15 +00:00
auto* copy_audio_url_action = new QAction("Copy Audio &URL", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
copy_audio_url_action->setIcon(load_icon_from_uri("resource://icons/16x16/edit-copy.png"sv));
Ladybird: Add a context menu for audio elements
2023-06-16 15:05:15 +00:00
QObject::connect(copy_audio_url_action, &QAction::triggered, this, [this]() {
copy_link_url(m_media_context_menu_url);
});
Ladybird/Qt: Do not "share" ownership of Qt objects When a QObject subclass (widgets, etc.) are provided a parent, then ownership of that object is passed to the parent. Similarly, objects added to a QLayout are owned by the layout. Thus, do not store these objects in an OwnPtr.
2023-12-04 14:39:22 +00:00
m_audio_context_menu = new QMenu("Audio context menu", this);
Ladybird: Add a context menu for audio elements
2023-06-16 15:05:15 +00:00
m_audio_context_menu->addAction(m_media_context_menu_play_pause_action);
Ladybird+LibWeb+WebContent: Add context menu controls for muting audio
2023-06-16 15:29:54 +00:00
m_audio_context_menu->addAction(m_media_context_menu_mute_unmute_action);
Ladybird: Add a context menu for audio elements
2023-06-16 15:05:15 +00:00
m_audio_context_menu->addAction(m_media_context_menu_controls_action);
m_audio_context_menu->addAction(m_media_context_menu_loop_action);
m_audio_context_menu->addSeparator();
Ladybird: Add context menu items to directly open audio files After commit 7ec7015, we can open audio documents directly. This adds content menu items to do so, similar to images and videos.
2023-06-19 11:15:13 +00:00
m_audio_context_menu->addAction(open_audio_action);
m_audio_context_menu->addAction(open_audio_in_new_tab_action);
m_audio_context_menu->addSeparator();
Ladybird: Add a context menu for audio elements
2023-06-16 15:05:15 +00:00
m_audio_context_menu->addAction(copy_audio_url_action);
m_audio_context_menu->addSeparator();
m_audio_context_menu->addAction(&m_window->inspect_dom_node_action());
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
auto* open_video_action = new QAction("&Open Video", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
open_video_action->setIcon(load_icon_from_uri("resource://icons/16x16/filetype-video.png"sv));
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
QObject::connect(open_video_action, &QAction::triggered, this, [this]() {
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 14:51:38 +00:00
open_link(m_media_context_menu_url);
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
});
auto* open_video_in_new_tab_action = new QAction("Open Video in New &Tab", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
open_video_in_new_tab_action->setIcon(load_icon_from_uri("resource://icons/16x16/new-tab.png"sv));
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
QObject::connect(open_video_in_new_tab_action, &QAction::triggered, this, [this]() {
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 14:51:38 +00:00
open_link_in_new_tab(m_media_context_menu_url);
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
});
auto* copy_video_url_action = new QAction("Copy Video &URL", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
copy_video_url_action->setIcon(load_icon_from_uri("resource://icons/16x16/edit-copy.png"sv));
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
QObject::connect(copy_video_url_action, &QAction::triggered, this, [this]() {
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 14:51:38 +00:00
copy_link_url(m_media_context_menu_url);
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
});
Ladybird/Qt: Do not "share" ownership of Qt objects When a QObject subclass (widgets, etc.) are provided a parent, then ownership of that object is passed to the parent. Similarly, objects added to a QLayout are owned by the layout. Thus, do not store these objects in an OwnPtr.
2023-12-04 14:39:22 +00:00
m_video_context_menu = new QMenu("Video context menu", this);
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 14:51:38 +00:00
m_video_context_menu->addAction(m_media_context_menu_play_pause_action);
Ladybird+LibWeb+WebContent: Add context menu controls for muting audio
2023-06-16 15:29:54 +00:00
m_video_context_menu->addAction(m_media_context_menu_mute_unmute_action);
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 14:51:38 +00:00
m_video_context_menu->addAction(m_media_context_menu_controls_action);
m_video_context_menu->addAction(m_media_context_menu_loop_action);
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
m_video_context_menu->addSeparator();
m_video_context_menu->addAction(open_video_action);
m_video_context_menu->addAction(open_video_in_new_tab_action);
m_video_context_menu->addSeparator();
m_video_context_menu->addAction(copy_video_url_action);
m_video_context_menu->addSeparator();
m_video_context_menu->addAction(&m_window->inspect_dom_node_action());
Ladybird/Qt: Open context menus at requested position
2023-12-12 21:33:36 +00:00
view().on_media_context_menu_request = [this](Gfx::IntPoint content_position, Web::Page::MediaContextMenu const& menu) {
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 14:51:38 +00:00
m_media_context_menu_url = menu.media_url;
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 14:51:38 +00:00
if (menu.is_playing) {
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
m_media_context_menu_play_pause_action->setIcon(m_media_context_menu_pause_icon);
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 14:51:38 +00:00
m_media_context_menu_play_pause_action->setText("&Pause");
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
} else {
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
m_media_context_menu_play_pause_action->setIcon(m_media_context_menu_play_icon);
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 14:51:38 +00:00
m_media_context_menu_play_pause_action->setText("&Play");
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
}
Ladybird+LibWeb+WebContent: Add context menu controls for muting audio
2023-06-16 15:29:54 +00:00
if (menu.is_muted) {
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
m_media_context_menu_mute_unmute_action->setIcon(m_media_context_menu_unmute_icon);
Ladybird+LibWeb+WebContent: Add context menu controls for muting audio
2023-06-16 15:29:54 +00:00
m_media_context_menu_mute_unmute_action->setText("Un&mute");
} else {
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 12:45:43 +00:00
m_media_context_menu_mute_unmute_action->setIcon(m_media_context_menu_mute_icon);
Ladybird+LibWeb+WebContent: Add context menu controls for muting audio
2023-06-16 15:29:54 +00:00
m_media_context_menu_mute_unmute_action->setText("&Mute");
}
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 14:51:38 +00:00
m_media_context_menu_controls_action->setChecked(menu.has_user_agent_controls);
m_media_context_menu_loop_action->setChecked(menu.is_looping);
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
Ladybird/Qt: Open context menus at requested position
2023-12-12 21:33:36 +00:00
auto screen_position = view().mapToGlobal(QPoint(content_position.x(), content_position.y()) / view().device_pixel_ratio());
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 14:51:38 +00:00
if (menu.is_video)
m_video_context_menu->exec(screen_position);
Ladybird: Add a context menu for audio elements
2023-06-16 15:05:15 +00:00
else
m_audio_context_menu->exec(screen_position);
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
};
Ladybird: Focus the location editor when creating a new tab This lets you start typing a new URL right after pressing Ctrl+T.
2022-09-12 07:12:04 +00:00
}
Ladybird: Move ownership of the JS console/inspector to the tab object This is to match Browser, where ownership of all "subwidgets" is placed on the tab as well. This further lets us align the web view callbacks to match Browser's OOPWV as well, which will later let us move them into the base LibWebView class.
2023-05-17 15:54:36 +00:00
Tab::~Tab()
{
close_sub_widgets();
Ladybird/Qt: Ensure the Inspector widget is deleted before the WebView According to Qt documentation, destruction of a QObject's children may happen in any order. In our case, the Tab's WebContentView is deleted before its InspectorWidget. The InspectorWidget performs cleanup on that WebContentView in its destructor; this causes use-after-free since it has already been destroyed. From reading Qt threads, if a particular destruction order is required, it is okay to enforce that order with manual `delete`s. This patch does so with the InspectorWidget to ensure it is deleted before the WebContentView. Qt's object ownership is okay with this - it will remove the InspectorWidget from the Tab's children, preventing any double deletion.
2023-12-29 14:05:05 +00:00
// Delete the InspectorWidget explicitly to ensure it is deleted before the WebContentView. Otherwise, Qt
// can destroy these objects in any order, which may cause use-after-free in InspectorWidget's destructor.
delete m_inspector_widget;
Ladybird: Move ownership of the JS console/inspector to the tab object This is to match Browser, where ownership of all "subwidgets" is placed on the tab as well. This further lets us align the web view callbacks to match Browser's OOPWV as well, which will later let us move them into the base LibWebView class.
2023-05-17 15:54:36 +00:00
}
Ladybird+LibWeb: Add basic select element support
2023-12-07 14:53:49 +00:00
void Tab::select_dropdown_add_item(QMenu* menu, Web::HTML::SelectItem const& item)
{
if (item.type == Web::HTML::SelectItem::Type::OptionGroup) {
QAction* subtitle = new QAction(qstring_from_ak_string(item.label.value_or(""_string)), this);
subtitle->setDisabled(true);
menu->addAction(subtitle);
for (auto const& item : *item.items) {
select_dropdown_add_item(menu, item);
}
}
if (item.type == Web::HTML::SelectItem::Type::Option) {
QAction* action = new QAction(qstring_from_ak_string(item.label.value_or(""_string)), this);
action->setCheckable(true);
action->setChecked(item.selected);
action->setData(QVariant(qstring_from_ak_string(item.value.value_or(""_string))));
QObject::connect(action, &QAction::triggered, this, &Tab::select_dropdown_action);
menu->addAction(action);
}
if (item.type == Web::HTML::SelectItem::Type::Separator) {
menu->addSeparator();
}
}
void Tab::select_dropdown_action()
{
QAction* action = qobject_cast<QAction*>(sender());
auto value = action->data().value<QString>();
view().select_dropdown_closed(ak_string_from_qstring(value));
}
Ladybird: Add reset zoom level button to toolbar This is a port of the Browser feature.
2023-03-28 23:25:42 +00:00
void Tab::update_reset_zoom_button()
{
auto zoom_level = view().zoom_level();
if (zoom_level != 1.0f) {
auto zoom_level_text = MUST(String::formatted("{}%", round_to<int>(zoom_level * 100)));
m_reset_zoom_button->setText(qstring_from_ak_string(zoom_level_text));
m_reset_zoom_button_action->setVisible(true);
} else {
m_reset_zoom_button_action->setVisible(false);
}
}
Ladybird: Focus the location editor when creating a new tab This lets you start typing a new URL right after pressing Ctrl+T.
2022-09-12 07:12:04 +00:00
void Tab::focus_location_editor()
{
m_location_edit->setFocus();
m_location_edit->selectAll();
Ladybird: Expanded toolbar with browser history and home button This patch takes the browser history code from the Serenity browser and wires it up to the QT interface. This is tied in with a few extra toolbar buttons associated with each tab.
2022-07-06 13:38:50 +00:00
}
Everywhere: Use unqualified AK::URL Now possible in LibWeb now that there is no longer a Web::URL.
2024-02-11 07:15:39 +00:00
void Tab::navigate(URL const& url)
Ladybird: Expanded toolbar with browser history and home button This patch takes the browser history code from the Serenity browser and wires it up to the QT interface. This is tied in with a few extra toolbar buttons associated with each tab.
2022-07-06 13:38:50 +00:00
{
Ladybird/Qt: Rename new_tab to new_tab_from_url and make it take AK::URL Instead of having QString be the API for these load() calls, just pipe AK::URL throughout the UI.
2024-01-31 02:15:55 +00:00
view().load(url);
Ladybird: Expanded toolbar with browser history and home button This patch takes the browser history code from the Serenity browser and wires it up to the QT interface. This is tied in with a few extra toolbar buttons associated with each tab.
2022-07-06 13:38:50 +00:00
}
Userland+Ladybird: Always specify url to be about:srcdoc in load_html() After moving to navigables, we started reusing the code that populates session history entries with the srcdoc attribute value from iframes in `Page::load_html()` for loading HTML. This change addresses a crash in `determine_the_origin` which occurred because this method expected the URL to be `about:srcdoc` if we also provided HTML content (previously, it was the URL passed along with the HTML content into `load_html()`).
2023-09-17 15:12:17 +00:00
void Tab::load_html(StringView html)
Ladybird: Allow creating new tabs with plain HTML This will allow us to internally create a new tab with HTML, to be used by the View Source command.
2023-08-28 20:14:34 +00:00
{
Userland+Ladybird: Always specify url to be about:srcdoc in load_html() After moving to navigables, we started reusing the code that populates session history entries with the srcdoc attribute value from iframes in `Page::load_html()` for loading HTML. This change addresses a crash in `determine_the_origin` which occurred because this method expected the URL to be `about:srcdoc` if we also provided HTML content (previously, it was the URL passed along with the HTML content into `load_html()`).
2023-09-17 15:12:17 +00:00
view().load_html(html);
Ladybird: Allow creating new tabs with plain HTML This will allow us to internally create a new tab with HTML, to be used by the View Source command.
2023-08-28 20:14:34 +00:00
}
Ladybird: Expanded toolbar with browser history and home button This patch takes the browser history code from the Serenity browser and wires it up to the QT interface. This is tied in with a few extra toolbar buttons associated with each tab.
2022-07-06 13:38:50 +00:00
void Tab::back()
{
if (!m_history.can_go_back())
return;
Ladybird: Don't push to history when loading through history navigation Previously we were always pushing to history on the on_load_start callback. Now we only do that if we are NOT navigating through the history navigation (loading pages by going back/forward). This is what the SerenityOS browser does:^)
2022-11-08 12:01:20 +00:00
m_is_history_navigation = true;
Ladybird: Expanded toolbar with browser history and home button This patch takes the browser history code from the Serenity browser and wires it up to the QT interface. This is tied in with a few extra toolbar buttons associated with each tab.
2022-07-06 13:38:50 +00:00
m_history.go_back();
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 14:19:34 +00:00
view().load(m_history.current().url.to_byte_string());
Ladybird: Expanded toolbar with browser history and home button This patch takes the browser history code from the Serenity browser and wires it up to the QT interface. This is tied in with a few extra toolbar buttons associated with each tab.
2022-07-06 13:38:50 +00:00
}
void Tab::forward()
{
if (!m_history.can_go_forward())
return;
Ladybird: Don't push to history when loading through history navigation Previously we were always pushing to history on the on_load_start callback. Now we only do that if we are NOT navigating through the history navigation (loading pages by going back/forward). This is what the SerenityOS browser does:^)
2022-11-08 12:01:20 +00:00
m_is_history_navigation = true;
Ladybird: Expanded toolbar with browser history and home button This patch takes the browser history code from the Serenity browser and wires it up to the QT interface. This is tied in with a few extra toolbar buttons associated with each tab.
2022-07-06 13:38:50 +00:00
m_history.go_forward();
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 14:19:34 +00:00
view().load(m_history.current().url.to_byte_string());
Ladybird: Expanded toolbar with browser history and home button This patch takes the browser history code from the Serenity browser and wires it up to the QT interface. This is tied in with a few extra toolbar buttons associated with each tab.
2022-07-06 13:38:50 +00:00
}
Ladybird: Rudimentary tabbed browsing support This patch removes the browser WebView from the window and places it inside a Tab object, all wrapped up in a QT tab control. So far you can create tabs, but can't close them.
2022-07-05 22:18:21 +00:00
void Tab::reload()
{
Ladybird: Do not enable the reload button if history is empty Not much of an issue currently, but will be once tabs are used to render plain HTML.
2023-08-28 19:54:36 +00:00
if (m_history.is_empty())
return;
Ladybird: Fix reloading functionality Previously, reloading went back to the first page loaded by WebView::load() or WebView::load_html(), as they are the only methods that modify m_url, which is what the reload loaded. Now we handle reloads in Tab.cpp by simply loading the last entry in the m_history.
2022-11-08 23:35:55 +00:00
m_is_history_navigation = true;
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 14:19:34 +00:00
view().load(m_history.current().url.to_byte_string());
Ladybird: Rudimentary tabbed browsing support This patch removes the browser WebView from the window and places it inside a Tab object, all wrapped up in a QT tab control. So far you can create tabs, but can't close them.
2022-07-05 22:18:21 +00:00
}
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
void Tab::open_link(URL const& url)
{
view().on_link_click(url, "", 0);
}
void Tab::open_link_in_new_tab(URL const& url)
{
view().on_link_click(url, "_blank", 0);
}
void Tab::copy_link_url(URL const& url)
{
auto* clipboard = QGuiApplication::clipboard();
Ladybird/Qt: Implement "Copy Email/Phone" menu item for links
2023-12-05 13:04:15 +00:00
clipboard->setText(qstring_from_ak_string(WebView::url_text_to_copy(url)));
Ladybird: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
}
Ladybird: Rudimentary tabbed browsing support This patch removes the browser WebView from the window and places it inside a Tab object, all wrapped up in a QT tab control. So far you can create tabs, but can't close them.
2022-07-05 22:18:21 +00:00
void Tab::location_edit_return_pressed()
{
Ladybird/QT: Avoid incorrect round trip via QUrl QUrl::toString reverses the Unicode->ASCII conversion that already occurred here. The text of m_location_edit is already in the format we expect, so let's just convert QString->AK::URL directly, instead of taking the detour QString->QUrl->AK::URL
2024-02-19 18:39:43 +00:00
navigate(ak_url_from_qstring(m_location_edit->text()));
Ladybird: Rudimentary tabbed browsing support This patch removes the browser WebView from the window and places it inside a Tab object, all wrapped up in a QT tab control. So far you can create tabs, but can't close them.
2022-07-05 22:18:21 +00:00
}
Ladybird: Add "Open File..." to menu
2023-05-25 21:47:12 +00:00
void Tab::open_file()
{
Ladybird: Open files from the open files dialog as a QURL This prevents us from needing to properly prepend file:// to the returned filename.
2024-01-31 02:29:00 +00:00
auto filename = QFileDialog::getOpenFileUrl(this, "Open file", QDir::homePath(), "All Files (*.*)");
if (filename.isValid()) {
navigate(ak_url_from_qurl(filename));
}
Ladybird: Add "Open File..." to menu
2023-05-25 21:47:12 +00:00
}
Ladybird: Rudimentary tabbed browsing support This patch removes the browser WebView from the window and places it inside a Tab object, all wrapped up in a QT tab control. So far you can create tabs, but can't close them.
2022-07-05 22:18:21 +00:00
int Tab::tab_index()
{
Ladybird: Make Tab.cpp directly take a BrowserWindows as m_window
2022-09-21 19:17:13 +00:00
return m_window->tab_index(this);
Ladybird: Rudimentary tabbed browsing support This patch removes the browser WebView from the window and places it inside a Tab object, all wrapped up in a QT tab control. So far you can create tabs, but can't close them.
2022-07-05 22:18:21 +00:00
}
Ladybird: Port over part of the "Debug" menu from the SerenityOS browser This is pretty messy, but we have to start somewhere. Eventually we should find a way to share this code with SerenityOS.
2022-07-08 12:14:40 +00:00
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 14:19:34 +00:00
void Tab::debug_request(ByteString const& request, ByteString const& argument)
Ladybird: Port over part of the "Debug" menu from the SerenityOS browser This is pretty messy, but we have to start somewhere. Eventually we should find a way to share this code with SerenityOS.
2022-07-08 12:14:40 +00:00
{
Ladybird/Tab: Handle "Dump History" action
2022-10-03 21:53:04 +00:00
if (request == "dump-history")
m_history.dump();
else
m_view->debug_request(request, argument);
Ladybird: Port over part of the "Debug" menu from the SerenityOS browser This is pretty messy, but we have to start somewhere. Eventually we should find a way to share this code with SerenityOS.
2022-07-08 12:14:40 +00:00
}
Ladybird: Show hovered link URLs in a conditional UI label The tooltips for hovered links were super awkward when in a tooltip
2022-09-09 12:23:36 +00:00
void Tab::resizeEvent(QResizeEvent* event)
{
QWidget::resizeEvent(event);
if (m_hover_label->isVisible())
update_hover_label();
}
void Tab::update_hover_label()
{
m_hover_label->resize(QFontMetrics(m_hover_label->font()).boundingRect(m_hover_label->text()).adjusted(-4, -2, 4, 2).size());
m_hover_label->move(6, height() - m_hover_label->height() - 8);
m_hover_label->raise();
}
Ladybird: Use vector icons in the browser toolbar We now load SVG icons (via the Qt resource system) and render them into a QIcon (with normal and disabled variants) using system colors. We also re-render them if the system color theme changes. This instantly makes Ladybird look less foreign on my Linux box. I drew the icons myself, and they could definitely be more optimized, but this was my first time using Inkscape. :^)
2023-05-05 13:38:46 +00:00
bool Tab::event(QEvent* event)
{
if (event->type() == QEvent::PaletteChange) {
Ladybird: Use custom QIconEngine to render scalable/vector icons Rather than render the icons to a 16x16 bitmap, keep them as vector graphics and render them on request. This keeps the icons crisp on high DPI displays.
2023-07-29 18:46:47 +00:00
recreate_toolbar_icons();
Ladybird: Use vector icons in the browser toolbar We now load SVG icons (via the Qt resource system) and render them into a QIcon (with normal and disabled variants) using system colors. We also re-render them if the system color theme changes. This instantly makes Ladybird look less foreign on my Linux box. I drew the icons myself, and they could definitely be more optimized, but this was my first time using Inkscape. :^)
2023-05-05 13:38:46 +00:00
return QWidget::event(event);
}
return QWidget::event(event);
}
Ladybird: Use custom QIconEngine to render scalable/vector icons Rather than render the icons to a 16x16 bitmap, keep them as vector graphics and render them on request. This keeps the icons crisp on high DPI displays.
2023-07-29 18:46:47 +00:00
void Tab::recreate_toolbar_icons()
Ladybird: Use vector icons in the browser toolbar We now load SVG icons (via the Qt resource system) and render them into a QIcon (with normal and disabled variants) using system colors. We also re-render them if the system color theme changes. This instantly makes Ladybird look less foreign on my Linux box. I drew the icons myself, and they could definitely be more optimized, but this was my first time using Inkscape. :^)
2023-05-05 13:38:46 +00:00
{
Ladybird: Use custom QIconEngine to render scalable/vector icons Rather than render the icons to a 16x16 bitmap, keep them as vector graphics and render them on request. This keeps the icons crisp on high DPI displays.
2023-07-29 18:46:47 +00:00
m_window->go_back_action().setIcon(create_tvg_icon_with_theme_colors("back", palette()));
m_window->go_forward_action().setIcon(create_tvg_icon_with_theme_colors("forward", palette()));
m_window->reload_action().setIcon(create_tvg_icon_with_theme_colors("reload", palette()));
Ladybird: Use vector icons in the browser toolbar We now load SVG icons (via the Qt resource system) and render them into a QIcon (with normal and disabled variants) using system colors. We also re-render them if the system color theme changes. This instantly makes Ladybird look less foreign on my Linux box. I drew the icons myself, and they could definitely be more optimized, but this was my first time using Inkscape. :^)
2023-05-05 13:38:46 +00:00
}
Ladybird: Move ownership of the JS console/inspector to the tab object This is to match Browser, where ownership of all "subwidgets" is placed on the tab as well. This further lets us align the web view callbacks to match Browser's OOPWV as well, which will later let us move them into the base LibWebView class.
2023-05-17 15:54:36 +00:00
void Tab::show_inspector_window(InspectorTarget inspector_target)
{
Ladybird/Qt: Port the Inspector to the WebView InspectorClient
2023-11-24 01:04:54 +00:00
if (!m_inspector_widget)
Ladybird/Qt: Make the Inspector widget owned by its parent tab This ensures the Inspector is closed when the BrowserWindow which owns the tab is closed.
2023-12-04 16:03:40 +00:00
m_inspector_widget = new InspectorWidget(this, view());
Ladybird+LibWebView: Ensure existing Inspector widgets inspect the page If the Inspector widget already exists, be sure to inspect the page when it is re-opened. However, this should be a no-op if the page was already inspected (as any existing Inspector will be reset if a new page load began). Note this is not an issue in the AppKit chrome.
2023-12-10 15:09:40 +00:00
else
m_inspector_widget->inspect();
Ladybird: Move ownership of the JS console/inspector to the tab object This is to match Browser, where ownership of all "subwidgets" is placed on the tab as well. This further lets us align the web view callbacks to match Browser's OOPWV as well, which will later let us move them into the base LibWebView class.
2023-05-17 15:54:36 +00:00
m_inspector_widget->show();
Ladybird/Qt: Port the Inspector to the WebView InspectorClient
2023-11-24 01:04:54 +00:00
m_inspector_widget->activateWindow();
m_inspector_widget->raise();
Ladybird: Move ownership of the JS console/inspector to the tab object This is to match Browser, where ownership of all "subwidgets" is placed on the tab as well. This further lets us align the web view callbacks to match Browser's OOPWV as well, which will later let us move them into the base LibWebView class.
2023-05-17 15:54:36 +00:00
Ladybird/Qt: Port the Inspector to the WebView InspectorClient
2023-11-24 01:04:54 +00:00
if (inspector_target == InspectorTarget::HoveredElement)
m_inspector_widget->select_hovered_node();
else
Ladybird: Move ownership of the JS console/inspector to the tab object This is to match Browser, where ownership of all "subwidgets" is placed on the tab as well. This further lets us align the web view callbacks to match Browser's OOPWV as well, which will later let us move them into the base LibWebView class.
2023-05-17 15:54:36 +00:00
m_inspector_widget->select_default_node();
}
void Tab::close_sub_widgets()
{
auto close_widget_window = [](auto* widget) {
if (widget)
widget->close();
};
close_widget_window(m_inspector_widget);
}
Ladybird: Move classes and types into the Ladybird namespace We were super inconsistent about this, with most "new" classes living in the Ladybird namespace, while "old" ones were in the global namespace, or even sitting in the Browser namespace.
2023-08-02 17:52:59 +00:00
}
Reference in a new issue Copy permalink