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

750 lines
29 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: 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 "ConsoleWidget.h"
#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: Use Browser's History.{cpp,h} There are no custom changes for Ladybird in the current copies of those files, so we just need to ensure to keep Ladybird up to date for any changes made upstream.
2022-10-22 21:42:00 +00:00
#include <Browser/History.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: Add a context menu for video elements
2023-05-15 16:27:10 +00:00
#include <QClipboard>
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: 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: 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: Render web content in a separate process :^) This patch brings over the WebContent process over from SerenityOS to Ladybird, along with a new WebContentView widget that renders web content in a separate process. There's a lot of jank and FIXME material here, notably I had to re-add manually pumped Core::EventLoop instances on both sides, in order to get the IPC protocol running. This introduces a lot of latency and we should work towards replacing those loops with improved abstractions. The WebContent process is built separately here (not part of Lagom) and we provide our own main.cpp for it. Like everything, this can be better architected, it's just a starting point. :^)
2022-10-05 13:23:41 +00:00
#include <QPlainTextEdit>
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: 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: Update for AK::{String => DeprecatedString} rename
2022-12-04 18:43:54 +00:00
extern DeprecatedString s_serenity_resource_root;
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+LibWebView+Browser: Remove ability to run with AST interpreter
2023-08-07 14:44:20 +00:00
Tab::Tab(BrowserWindow* window, StringView webdriver_content_ipc_path, WebView::EnableCallgrindProfiling enable_callgrind_profiling, UseLagomNetworking use_lagom_networking)
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+LibWebView+Browser: Remove ability to run with AST interpreter
2023-08-07 14:44:20 +00:00
m_view = new WebContentView(webdriver_content_ipc_path, enable_callgrind_profiling, use_lagom_networking);
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) {
m_hover_label->setText(qstring_from_ak_deprecated_string(url.to_deprecated_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());
}
Ladybird: Update for AK::{String => DeprecatedString} rename
2022-12-04 18:43:54 +00:00
m_location_edit->setText(url.to_deprecated_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)
m_inspector_widget->clear_dom_json();
if (m_console_widget)
m_console_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&) {
if (m_inspector_widget != nullptr && m_inspector_widget->isVisible()) {
view().inspect_dom_tree();
view().inspect_accessibility_tree();
}
};
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) {
m_title = qstring_from_ak_deprecated_string(title);
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)
view().prompt_closed(ak_string_from_qstring(dialog.textValue()).release_value_but_fixme_should_propagate_errors());
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: 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: 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
auto* text_edit = new QPlainTextEdit(this);
text_edit->setWindowFlags(Qt::Window);
text_edit->setFont(QFontDatabase::systemFont(QFontDatabase::SystemFont::FixedFont));
text_edit->resize(800, 600);
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
text_edit->setWindowTitle(qstring_from_ak_deprecated_string(url.to_deprecated_string()));
text_edit->setPlainText(qstring_from_ak_deprecated_string(source));
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
text_edit->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
};
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+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_dom_tree = [this](auto& dom_tree) {
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)
m_inspector_widget->set_dom_json(dom_tree);
};
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_accessibility_tree = [this](auto& accessibility_tree) {
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)
m_inspector_widget->set_accessibility_json(accessibility_tree);
};
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_console_message = [this](auto message_index) {
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_console_widget)
m_console_widget->notify_about_new_console_message(message_index);
};
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_console_messages = [this](auto start_index, auto& message_types, auto& messages) {
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_console_widget)
m_console_widget->handle_console_messages(start_index, message_types, messages);
};
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);
take_visible_screenshot_action->setIcon(QIcon(QString("%1/res/icons/16x16/filetype-image.png").arg(s_serenity_resource_root.characters())));
QObject::connect(take_visible_screenshot_action, &QAction::triggered, this, [this]() {
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 13:53:13 +00:00
if (auto result = view().take_screenshot(WebView::ViewImplementation::ScreenshotType::Visible); result.is_error()) {
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 error = String::formatted("{}", result.error()).release_value_but_fixme_should_propagate_errors();
QMessageBox::warning(this, "Ladybird", qstring_from_ak_string(error));
}
});
auto* take_full_screenshot_action = new QAction("Take &Full Screenshot", this);
take_full_screenshot_action->setIcon(QIcon(QString("%1/res/icons/16x16/filetype-image.png").arg(s_serenity_resource_root.characters())));
QObject::connect(take_full_screenshot_action, &QAction::triggered, this, [this]() {
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 13:53:13 +00:00
if (auto result = view().take_screenshot(WebView::ViewImplementation::ScreenshotType::Full); result.is_error()) {
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 error = String::formatted("{}", result.error()).release_value_but_fixme_should_propagate_errors();
QMessageBox::warning(this, "Ladybird", qstring_from_ak_string(error));
}
});
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 = make<QMenu>("Context menu", this);
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: 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: Use cursor position for context menu
2023-05-21 04:53:38 +00:00
view().on_context_menu_request = [this](Gfx::IntPoint) {
auto screen_position = QCursor::pos();
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->exec(screen_position);
};
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);
open_link_action->setIcon(QIcon(QString("%1/res/icons/16x16/go-forward.png").arg(s_serenity_resource_root.characters())));
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);
open_link_in_new_tab_action->setIcon(QIcon(QString("%1/res/icons/16x16/new-tab.png").arg(s_serenity_resource_root.characters())));
QObject::connect(open_link_in_new_tab_action, &QAction::triggered, this, [this]() {
open_link_in_new_tab(m_link_context_menu_url);
});
auto* copy_url_action = new QAction("Copy &URL", this);
copy_url_action->setIcon(QIcon(QString("%1/res/icons/16x16/edit-copy.png").arg(s_serenity_resource_root.characters())));
QObject::connect(copy_url_action, &QAction::triggered, this, [this]() {
copy_link_url(m_link_context_menu_url);
});
m_link_context_menu = make<QMenu>("Link context menu", this);
m_link_context_menu->addAction(open_link_action);
m_link_context_menu->addAction(open_link_in_new_tab_action);
m_link_context_menu->addSeparator();
m_link_context_menu->addAction(copy_url_action);
m_link_context_menu->addSeparator();
m_link_context_menu->addAction(&m_window->inspect_dom_node_action());
Ladybird: Use cursor position for context menu
2023-05-21 04:53:38 +00:00
view().on_link_context_menu_request = [this](auto const& url, Gfx::IntPoint) {
Ladybird: Add a context menu for link elements
2023-05-15 16:48:46 +00:00
m_link_context_menu_url = url;
Ladybird: Use cursor position for context menu
2023-05-21 04:53:38 +00:00
auto screen_position = QCursor::pos();
Ladybird: Add a context menu for link elements
2023-05-15 16:48:46 +00:00
m_link_context_menu->exec(screen_position);
};
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);
open_image_action->setIcon(QIcon(QString("%1/res/icons/16x16/filetype-image.png").arg(s_serenity_resource_root.characters())));
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);
open_image_in_new_tab_action->setIcon(QIcon(QString("%1/res/icons/16x16/new-tab.png").arg(s_serenity_resource_root.characters())));
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);
copy_image_action->setIcon(QIcon(QString("%1/res/icons/16x16/edit-copy.png").arg(s_serenity_resource_root.characters())));
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);
copy_image_url_action->setIcon(QIcon(QString("%1/res/icons/16x16/edit-copy.png").arg(s_serenity_resource_root.characters())));
QObject::connect(copy_image_url_action, &QAction::triggered, this, [this]() {
copy_link_url(m_image_context_menu_url);
});
m_image_context_menu = make<QMenu>("Image context menu", this);
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: Use cursor position for context menu
2023-05-21 04:53:38 +00:00
view().on_image_context_menu_request = [this](auto& image_url, Gfx::IntPoint, 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: Use cursor position for context menu
2023-05-21 04:53:38 +00:00
auto screen_position = QCursor::pos();
Ladybird: Add a context menu for image elements
2023-05-15 17:43:58 +00:00
m_image_context_menu->exec(screen_position);
};
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_icon = make<QIcon>(QString("%1/res/icons/16x16/play.png").arg(s_serenity_resource_root.characters()));
m_media_context_menu_pause_icon = make<QIcon>(QString("%1/res/icons/16x16/pause.png").arg(s_serenity_resource_root.characters()));
Ladybird+LibWeb+WebContent: Add context menu controls for muting audio
2023-06-16 15:29:54 +00:00
m_media_context_menu_mute_icon = make<QIcon>(QString("%1/res/icons/16x16/audio-volume-muted.png").arg(s_serenity_resource_root.characters()));
m_media_context_menu_unmute_icon = make<QIcon>(QString("%1/res/icons/16x16/audio-volume-high.png").arg(s_serenity_resource_root.characters()));
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
m_media_context_menu_play_pause_action = make<QAction>("&Play", this);
m_media_context_menu_play_pause_action->setIcon(*m_media_context_menu_play_icon);
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+LibWeb+WebContent: Add context menu controls for muting audio
2023-06-16 15:29:54 +00:00
m_media_context_menu_mute_unmute_action = make<QAction>("&Mute", this);
m_media_context_menu_mute_unmute_action->setIcon(*m_media_context_menu_mute_icon);
QObject::connect(m_media_context_menu_mute_unmute_action, &QAction::triggered, this, [this]() {
view().toggle_media_mute_state();
});
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 = make<QAction>("Show &Controls", this);
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+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 = make<QAction>("&Loop", this);
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);
open_audio_action->setIcon(QIcon(QString("%1/res/icons/16x16/filetype-sound.png").arg(s_serenity_resource_root.characters())));
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);
open_audio_in_new_tab_action->setIcon(QIcon(QString("%1/res/icons/16x16/new-tab.png").arg(s_serenity_resource_root.characters())));
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);
copy_audio_url_action->setIcon(QIcon(QString("%1/res/icons/16x16/edit-copy.png").arg(s_serenity_resource_root.characters())));
QObject::connect(copy_audio_url_action, &QAction::triggered, this, [this]() {
copy_link_url(m_media_context_menu_url);
});
m_audio_context_menu = make<QMenu>("Audio context menu", this);
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);
open_video_action->setIcon(QIcon(QString("%1/res/icons/16x16/filetype-video.png").arg(s_serenity_resource_root.characters())));
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);
open_video_in_new_tab_action->setIcon(QIcon(QString("%1/res/icons/16x16/new-tab.png").arg(s_serenity_resource_root.characters())));
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);
copy_video_url_action->setIcon(QIcon(QString("%1/res/icons/16x16/edit-copy.png").arg(s_serenity_resource_root.characters())));
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
});
m_video_context_menu = make<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+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
view().on_media_context_menu_request = [this](Gfx::IntPoint, Web::Page::MediaContextMenu const& menu) {
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) {
m_media_context_menu_play_pause_action->setIcon(*m_media_context_menu_pause_icon);
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+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->setIcon(*m_media_context_menu_play_icon);
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) {
m_media_context_menu_mute_unmute_action->setIcon(*m_media_context_menu_unmute_icon);
m_media_context_menu_mute_unmute_action->setText("Un&mute");
} else {
m_media_context_menu_mute_unmute_action->setIcon(*m_media_context_menu_mute_icon);
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: Use cursor position for context menu
2023-05-21 04:53:38 +00:00
auto screen_position = QCursor::pos();
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: 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
}
Ladybird: Remove unused LoadType parameter from Tab::navigate The only non-default use of this parameter was removed in 980e7164fe.
2023-08-13 18:35:49 +00:00
void Tab::navigate(QString url_qstring)
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: Use AK::Url rather than prefix list to check if URL is valid If a URL is not valid we try navigating to https:// + the url. It's better to ask AK::Url if it thinks the url is valid than put a big list of prefixes here, with this obscure protocols like Gemini are now recognised and with `--enable-lagom-networking` can be viewed in Ladybird (thanks to #2218).
2023-08-02 21:19:54 +00:00
auto url_string = ak_deprecated_string_from_qstring(url_qstring);
if (url_string.starts_with('/'))
url_string = DeprecatedString::formatted("file://{}", url_string);
else if (URL url = url_string; !url.is_valid())
url_string = DeprecatedString::formatted("https://{}", url_string);
view().load(url_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: 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
void Tab::load_html(StringView html, URL const& url)
{
view().load_html(html, 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
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();
Ladybird: Update for AK::{String => DeprecatedString} rename
2022-12-04 18:43:54 +00:00
view().load(m_history.current().url.to_deprecated_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();
Ladybird: Update for AK::{String => DeprecatedString} rename
2022-12-04 18:43:54 +00:00
view().load(m_history.current().url.to_deprecated_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;
Ladybird: Update for AK::{String => DeprecatedString} rename
2022-12-04 18:43:54 +00:00
view().load(m_history.current().url.to_deprecated_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();
clipboard->setText(qstring_from_ak_deprecated_string(url.to_deprecated_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
void Tab::location_edit_return_pressed()
{
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
navigate(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()
{
auto filename = QFileDialog::getOpenFileName(this, "Open file", QDir::homePath(), "All Files (*.*)");
if (!filename.isNull())
navigate("file://" + filename);
}
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
Ladybird: Update for AK::{String => DeprecatedString} rename
2022-12-04 18:43:54 +00:00
void Tab::debug_request(DeprecatedString const& request, DeprecatedString 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)
{
bool inspector_previously_loaded = m_inspector_widget != nullptr;
if (!m_inspector_widget) {
m_inspector_widget = new Ladybird::InspectorWidget;
m_inspector_widget->setWindowTitle("Inspector");
m_inspector_widget->resize(640, 480);
m_inspector_widget->on_close = [this] {
view().clear_inspected_dom_node();
};
m_inspector_widget->on_dom_node_inspected = [&](auto id, auto pseudo_element) {
return view().inspect_dom_node(id, pseudo_element);
};
}
if (!inspector_previously_loaded || !m_inspector_widget->dom_loaded()) {
view().inspect_dom_tree();
view().inspect_accessibility_tree();
}
m_inspector_widget->show();
if (inspector_target == InspectorTarget::HoveredElement) {
auto hovered_node = view().get_hovered_node_id();
m_inspector_widget->set_selection({ hovered_node });
} else {
m_inspector_widget->select_default_node();
}
}
void Tab::show_console_window()
{
if (!m_console_widget) {
m_console_widget = new Ladybird::ConsoleWidget;
m_console_widget->setWindowTitle("JS Console");
m_console_widget->resize(640, 480);
Ladybird: Allow copying text in the js console
2023-07-19 13:26:29 +00:00
Ladybird: Add the select-all action to the JS console Also clarify a comment, because it wasn't immediately clear to me what wouldn't work without the code below it.
2023-08-08 22:23:01 +00:00
// Make these actions available on the window itself. Adding them to the context menu alone
// does not enable activattion via keyboard shortcuts.
Ladybird: Allow copying text in the js console
2023-07-19 13:26:29 +00:00
m_console_widget->addAction(&m_window->copy_selection_action());
Ladybird: Add the select-all action to the JS console Also clarify a comment, because it wasn't immediately clear to me what wouldn't work without the code below it.
2023-08-08 22:23:01 +00:00
m_console_widget->addAction(&m_window->select_all_action());
Ladybird: Allow copying text in the js console
2023-07-19 13:26:29 +00:00
m_console_context_menu = make<QMenu>("Context menu", m_console_widget);
m_console_context_menu->addAction(&m_window->copy_selection_action());
Ladybird: Add the select-all action to the JS console Also clarify a comment, because it wasn't immediately clear to me what wouldn't work without the code below it.
2023-08-08 22:23:01 +00:00
m_console_context_menu->addAction(&m_window->select_all_action());
Ladybird: Allow copying text in the js console
2023-07-19 13:26:29 +00:00
m_console_widget->view().on_context_menu_request = [this](Gfx::IntPoint) {
auto screen_position = QCursor::pos();
m_console_context_menu->exec(screen_position);
};
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_console_widget->on_js_input = [this](auto js_source) {
view().js_console_input(js_source);
};
m_console_widget->on_request_messages = [this](i32 start_index) {
view().js_console_request_messages(start_index);
};
}
m_console_widget->show();
}
void Tab::close_sub_widgets()
{
auto close_widget_window = [](auto* widget) {
if (widget)
widget->close();
};
close_widget_window(m_console_widget);
close_widget_window(m_inspector_widget);
}
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