Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-20 08:03:21 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/UI/Qt/BrowserWindow.cpp

793 lines
28 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 23:18:21 +01:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 13:19:50 +02:00
* Copyright (c) 2022-2023, Andreas Kling <andreas@ladybird.org>
Ladybird: 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 23:18:21 +01:00
* Copyright (c) 2022, Matthew Costa <ucosty@gmail.com>
Ladybird: Add SettingsDialog stub
2022-07-14 06:08:30 +02:00
* Copyright (c) 2022, Filiph Sandström <filiph.sandstrom@filfatstudios.com>
Ladybird: Implement zoom :^)
2023-01-12 14:39:53 +00:00
* Copyright (c) 2023, Linus Groh <linusg@serenityos.org>
UI/Qt: Add "Dump CSS Errors" menu item Dumps out any CSS errors that have appeared since launch.
2025-07-23 11:29:45 +01:00
* Copyright (c) 2024-2025, Sam Atkins <sam@ladybird.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 23:18:21 +01:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
Ladybird: Update pointer to current tab when the selected tab changes This allows requests like dumping the DOM tree to be forwarded to the correct tab. Otherwise, the event would be forwarded to the most recently created tab.
2022-09-13 12:18:32 -04:00
#include <AK/TypeCasts.h>
LibWebView+UI: Migrate Ladybird's command line flags to LibWebView Currently, if we want to add a new e.g. WebContent command line option, we have to add it to all of Qt, AppKit, and headless-browser. (Or worse, we only add it to one of these, and we have feature disparity). To prevent this, this moves command line flags to WebView::Application. The flags are assigned to ChromeOptions and WebContentOptions structs. Each chrome can still add its platform-specific options; for example, the Qt chrome has a flag to enable Qt networking. There should be no behavior change here, other than that AppKit will now support command line flags that were previously only supported by Qt.
2024-07-30 14:01:05 -04:00
#include <LibWebView/Application.h>
Everywhere: Move the Ladybird folder to UI
2024-11-09 12:50:33 -05:00
#include <UI/Qt/Application.h>
#include <UI/Qt/BrowserWindow.h>
#include <UI/Qt/Icon.h>
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 08:20:14 -04:00
#include <UI/Qt/Menu.h>
Everywhere: Move the Ladybird folder to UI
2024-11-09 12:50:33 -05:00
#include <UI/Qt/Settings.h>
#include <UI/Qt/StringUtils.h>
#include <UI/Qt/TabBar.h>
#include <UI/Qt/WebContentView.h>
Ladybird: Add a "Reload" action to reload the current URL
2022-07-05 21:10:50 +02:00
#include <QAction>
Ladybird/BrowserWindow: Add UI for switching preferred CSS color scheme
2022-09-19 10:48:02 +02:00
#include <QActionGroup>
Ladybird: Add "Copy" and "Select All" actions to the Edit menu
2023-01-11 20:09:52 +01:00
#include <QGuiApplication>
Ladybird/BrowserWindow: Port user agent spoofing from Browser
2022-09-26 17:57:44 +03:00
#include <QInputDialog>
UI/Qt: Add UI components to enable DevTools at runtime
2025-03-15 10:10:25 -04:00
#include <QMessageBox>
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 08:20:14 -04:00
#include <QMouseEvent>
#include <QScreen>
Ladybird: Add keyboard shortcuts for jumping to a specific tab It's now possible to open a specific tab by using Ctrl/Command plus the number key corresponding to its position in the tab row.
2023-09-20 11:32:37 +02:00
#include <QShortcut>
UI/Qt: Add UI components to enable DevTools at runtime
2025-03-15 10:10:25 -04:00
#include <QStatusBar>
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 08:20:14 -04:00
#include <QWheelEvent>
Ladybird/Qt: Listen to DPI changes and update WebContentView accordingly
2023-12-13 19:10:05 +01:00
#include <QWindow>
Ladybird: Add a location bar and allow navigating to new pages :^)
2022-07-03 21:26:51 +02: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 11:52:59 -06:00
namespace Ladybird {
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 14:14:40 +02:00
Ladybird: Use the DALL-E ladybird globe as the application icon This looks a lot more "at home" than usual pixel art logo on non-SerenityOS systems. :^) Also, stop using site favicons as the app icon as that made it annoyingly hard to find Ladybird in task switchers sometimes.
2023-05-27 16:25:22 +02:00
static QIcon const& app_icon()
{
static QIcon icon;
if (icon.isNull()) {
QPixmap pixmap;
pixmap.load(":/Icons/ladybird.png");
icon = QIcon(pixmap);
}
return icon;
}
Ladybird: Ensure hamburger menu is placed within the browser window
2024-05-07 23:39:25 +01:00
class HamburgerMenu : public QMenu {
public:
using QMenu::QMenu;
virtual ~HamburgerMenu() override = default;
virtual void showEvent(QShowEvent*) override
{
if (!isVisible())
return;
AK+Everywhere: Rename `verify_cast` to `as` Follow-up to fc20e61e7249006247b43f84a3189d5a37fa103e.
2025-01-21 09:12:05 -05:00
auto* browser_window = as<BrowserWindow>(parentWidget());
Ladybird: Ensure hamburger menu is placed within the browser window
2024-05-07 23:39:25 +01:00
if (!browser_window)
return;
auto* current_tab = browser_window->current_tab();
if (!current_tab)
return;
// Ensure the hamburger menu placed within the browser window.
auto* hamburger_button = current_tab->hamburger_button();
auto button_top_right = hamburger_button->mapToGlobal(hamburger_button->rect().bottomRight());
move(button_top_right - QPoint(rect().width(), 0));
}
};
LibWebView+UI: Move the database and cookie jar to WebView::Application The main motivator here was noticing that --disable-sql-database did not work with AppKit. Rather than re-implementing this there, move ownership of these classes to WebView::Application, so that each UI does not need to individually worry about it.
2024-09-05 18:19:51 -04:00
BrowserWindow::BrowserWindow(Vector<URL::URL> const& initial_urls, IsPopupWindow is_popup_window, Tab* parent_tab, Optional<u64> page_index)
Ladybird/Qt: Specify a minimum and maxium tab width By default, Qt will grow the width of a tab button to fit the title text of the tab. For long titles or file:// URLs, this looks rather bad. This sets a min/max tab width to prevent such infinite growth. To do this, we have to subclass both QTabWidget and QTabBar, because the functions to be called/overridden are protected.
2024-04-02 21:38:01 -04:00
: m_tabs_container(new TabWidget(this))
UI/Qt: Move New Tab button in tab bar
2024-07-14 16:24:48 -04:00
, m_new_tab_button_toolbar(new QToolBar("New Tab", m_tabs_container))
UI/Qt: Don't save size and location of popup windows on exit
2024-07-27 11:38:39 +01:00
, m_is_popup_window(is_popup_window)
Ladybird: Add a location bar and allow navigating to new pages :^)
2022-07-03 21:26:51 +02:00
{
LibWebView+UI: Launch the DevTools server if --devtools is specified This replaces the --devtools-port flag with a --devtools flag, which optionally accepts a port. If the --devtools flag is set, we will now automatically launch the DevTools server.
2025-07-02 12:42:53 -04:00
auto const& browser_options = WebView::Application::browser_options();
Ladybird: Use the DALL-E ladybird globe as the application icon This looks a lot more "at home" than usual pixel art logo on non-SerenityOS systems. :^) Also, stop using site favicons as the app icon as that made it annoyingly hard to find Ladybird in task switchers sometimes.
2023-05-27 16:25:22 +02:00
setWindowIcon(app_icon());
Ladybird: Hide TabBar if count <= 1
2022-07-12 11:41:11 +02:00
Ladybird/Qt: Listen to DPI changes and update WebContentView accordingly
2023-12-13 19:10:05 +01:00
// Listen for DPI changes
m_device_pixel_ratio = devicePixelRatio();
m_current_screen = screen();
UI/Qt: Set WC's max FPS to the refresh rate of the current screen
2025-07-25 16:43:27 +01:00
m_refresh_rate = m_current_screen->refreshRate();
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-26 23:14:41 -05:00
if (QT_VERSION < QT_VERSION_CHECK(6, 6, 0) || QGuiApplication::platformName() != "wayland") {
setAttribute(Qt::WA_NativeWindow);
setAttribute(Qt::WA_DontCreateNativeAncestors);
Ladybird/Qt: Listen to DPI changes and update WebContentView accordingly
2023-12-13 19:10:05 +01:00
QObject::connect(m_current_screen, &QScreen::logicalDotsPerInchChanged, this, &BrowserWindow::device_pixel_ratio_changed);
UI/Qt: Set WC's max FPS to the refresh rate of the current screen
2025-07-25 16:43:27 +01:00
QObject::connect(m_current_screen, &QScreen::refreshRateChanged, this, &BrowserWindow::refresh_rate_changed);
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-26 23:14:41 -05:00
QObject::connect(windowHandle(), &QWindow::screenChanged, this, [this](QScreen* screen) {
if (m_device_pixel_ratio != devicePixelRatio())
device_pixel_ratio_changed(devicePixelRatio());
UI/Qt: Set WC's max FPS to the refresh rate of the current screen
2025-07-25 16:43:27 +01:00
if (m_refresh_rate != screen->refreshRate())
refresh_rate_changed(screen->refreshRate());
// Listen for logicalDotsPerInchChanged and refreshRateChanged signals on new screen
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-26 23:14:41 -05:00
QObject::disconnect(m_current_screen, &QScreen::logicalDotsPerInchChanged, nullptr, nullptr);
UI/Qt: Set WC's max FPS to the refresh rate of the current screen
2025-07-25 16:43:27 +01:00
QObject::disconnect(m_current_screen, &QScreen::refreshRateChanged, nullptr, nullptr);
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-26 23:14:41 -05:00
m_current_screen = screen;
QObject::connect(m_current_screen, &QScreen::logicalDotsPerInchChanged, this, &BrowserWindow::device_pixel_ratio_changed);
UI/Qt: Set WC's max FPS to the refresh rate of the current screen
2025-07-25 16:43:27 +01:00
QObject::connect(m_current_screen, &QScreen::refreshRateChanged, this, &BrowserWindow::refresh_rate_changed);
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-26 23:14:41 -05:00
});
}
Ladybird/Qt: Listen to DPI changes and update WebContentView accordingly
2023-12-13 19:10:05 +01:00
Ladybird: Ensure hamburger menu is placed within the browser window
2024-05-07 23:39:25 +01:00
m_hamburger_menu = new HamburgerMenu(this);
Ladybird/Qt: Introduce a hamburger menu and use by default There is an option to show the menubar, if desired (similar to KDE software).
2024-05-05 16:11:51 +01:00
if (!Settings::the()->show_menubar())
menuBar()->hide();
QObject::connect(Settings::the(), &Settings::show_menubar_changed, this, [this](bool show_menubar) {
menuBar()->setVisible(show_menubar);
});
auto* file_menu = menuBar()->addMenu("&File");
Ladybird: Fix build with Qt 6.2.4
2022-07-07 02:55:21 +02:00
Ladybird/Qt: Add a "new tab" button to the Qt chrome This adds a button on the right side of the location bar to create a new tab. Ideally, we would actually use QTabWidget::setCornerWidget to put this button in the tab bar. But it is surprisingly difficult to make that look nice on all platforms. Even if we ignore macOS, the CSS to make the button look right on KDE Plasma may not work well on Gnome. So for now, this location next to the location bar is horizontally the same that it would be in the tab bar at least.
2024-04-05 07:21:48 -04:00
m_new_tab_action = new QAction("New &Tab", this);
m_new_tab_action->setShortcuts(QKeySequence::keyBindings(QKeySequence::StandardKey::AddTab));
Ladybird/Qt: Introduce a hamburger menu and use by default There is an option to show the menubar, if desired (similar to KDE software).
2024-05-05 16:11:51 +01:00
m_hamburger_menu->addAction(m_new_tab_action);
file_menu->addAction(m_new_tab_action);
Ladybird: Fix build with Qt 6.2.4
2022-07-07 02:55:21 +02:00
Ladybird: Support multiple browser windows in Qt chrome This also moves the ownership of the TaskManger to the Application.
2024-04-26 18:53:55 -06:00
m_new_window_action = new QAction("New &Window", this);
m_new_window_action->setShortcuts(QKeySequence::keyBindings(QKeySequence::StandardKey::New));
Ladybird/Qt: Introduce a hamburger menu and use by default There is an option to show the menubar, if desired (similar to KDE software).
2024-05-05 16:11:51 +01:00
m_hamburger_menu->addAction(m_new_window_action);
file_menu->addAction(m_new_window_action);
Ladybird: Support multiple browser windows in Qt chrome This also moves the ownership of the TaskManger to the Application.
2024-04-26 18:53:55 -06:00
Ladybird: Add shortcut to "Close Current Tab"
2023-05-25 03:26:42 +02:00
auto* close_current_tab_action = new QAction("&Close Current Tab", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 07:45:43 -05:00
close_current_tab_action->setIcon(load_icon_from_uri("resource://icons/16x16/close-tab.png"sv));
Ladybird: Use QKeySequence::StandardKey as much as possible Let Qt pick the most appropriate native shortcut when it knows one.
2023-01-12 19:39:07 +01:00
close_current_tab_action->setShortcuts(QKeySequence::keyBindings(QKeySequence::StandardKey::Close));
Ladybird/Qt: Introduce a hamburger menu and use by default There is an option to show the menubar, if desired (similar to KDE software).
2024-05-05 16:11:51 +01:00
m_hamburger_menu->addAction(close_current_tab_action);
file_menu->addAction(close_current_tab_action);
Ladybird: Add Ctrl-W action to close current tab (#28)
2022-07-19 06:16:46 -04:00
Ladybird: Add "Open File..." to menu
2023-05-25 23:47:12 +02:00
auto* open_file_action = new QAction("&Open File...", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 07:45:43 -05:00
open_file_action->setIcon(load_icon_from_uri("resource://icons/16x16/filetype-folder-open.png"sv));
Ladybird: Add "Open File..." to menu
2023-05-25 23:47:12 +02:00
open_file_action->setShortcut(QKeySequence(QKeySequence::StandardKey::Open));
Ladybird/Qt: Introduce a hamburger menu and use by default There is an option to show the menubar, if desired (similar to KDE software).
2024-05-05 16:11:51 +01:00
m_hamburger_menu->addAction(open_file_action);
file_menu->addAction(open_file_action);
Ladybird: Add "Open File..." to menu
2023-05-25 23:47:12 +02:00
Ladybird/Qt: Introduce a hamburger menu and use by default There is an option to show the menubar, if desired (similar to KDE software).
2024-05-05 16:11:51 +01:00
m_hamburger_menu->addSeparator();
Ladybird: Add two separators to menus
2023-05-25 22:35:27 +02:00
Ladybird/Qt: Introduce a hamburger menu and use by default There is an option to show the menubar, if desired (similar to KDE software).
2024-05-05 16:11:51 +01:00
auto* edit_menu = m_hamburger_menu->addMenu("&Edit");
menuBar()->addMenu(edit_menu);
Ladybird: Add "Copy" and "Select All" actions to the Edit menu
2023-01-11 20:09:52 +01:00
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 08:20:14 -04:00
edit_menu->addAction(create_application_action(*this, Application::the().copy_selection_action()));
edit_menu->addAction(create_application_action(*this, Application::the().paste_action()));
edit_menu->addAction(create_application_action(*this, Application::the().select_all_action()));
Ladybird: Add two separators to menus
2023-05-25 22:35:27 +02:00
edit_menu->addSeparator();
Ladybird/Qt: Add a find in page widget
2024-05-29 20:12:21 +01:00
m_find_in_page_action = new QAction("&Find in Page...", this);
m_find_in_page_action->setIcon(load_icon_from_uri("resource://icons/16x16/find.png"sv));
m_find_in_page_action->setShortcuts(QKeySequence::keyBindings(QKeySequence::StandardKey::Find));
UI/Qt: Add standard shortcuts for find in page actions This commit adds the standard shortcuts for the Find Next and Find Previous buttons on the find in page panel. These shortcuts are usually F3 and Shift+F3 respectively, although Qt standard shortcuts may vary across platforms.
2024-06-13 21:09:49 +01:00
auto find_previous_shortcuts = QKeySequence::keyBindings(QKeySequence::StandardKey::FindPrevious);
for (auto const& shortcut : find_previous_shortcuts)
new QShortcut(shortcut, this, [this] {
if (m_current_tab)
m_current_tab->find_previous();
});
auto find_next_shortcuts = QKeySequence::keyBindings(QKeySequence::StandardKey::FindNext);
for (auto const& shortcut : find_next_shortcuts)
new QShortcut(shortcut, this, [this] {
if (m_current_tab)
m_current_tab->find_next();
});
Ladybird/Qt: Add a find in page widget
2024-05-29 20:12:21 +01:00
edit_menu->addAction(m_find_in_page_action);
QObject::connect(m_find_in_page_action, &QAction::triggered, this, &BrowserWindow::show_find_in_page);
edit_menu->addSeparator();
Ladybird: Move "Settings" from "File" to "Edit"
2023-05-25 03:23:33 +02:00
auto* settings_action = new QAction("&Settings", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 07:45:43 -05:00
settings_action->setIcon(load_icon_from_uri("resource://icons/16x16/settings.png"sv));
Ladybird: Move "Settings" from "File" to "Edit"
2023-05-25 03:23:33 +02:00
settings_action->setShortcuts(QKeySequence::keyBindings(QKeySequence::StandardKey::Preferences));
edit_menu->addAction(settings_action);
UI/Qt: Add a menu item to open about:settings This replaces the existing menu item that would open the Qt settings dialog. That menu item still exists, but is no longer the default settings action.
2025-03-21 09:51:00 -04:00
QObject::connect(settings_action, &QAction::triggered, this, [this] {
new_tab_from_url(URL::URL::about("settings"_string), Web::HTML::ActivateTab::Yes);
});
Ladybird/Qt: Introduce a hamburger menu and use by default There is an option to show the menubar, if desired (similar to KDE software).
2024-05-05 16:11:51 +01:00
auto* view_menu = m_hamburger_menu->addMenu("&View");
menuBar()->addMenu(view_menu);
Ladybird: Switch to next/previous tab with Ctrl+PageDown/PageUp
2022-09-12 09:22:43 +02:00
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 12:46:24 -06:00
auto* open_next_tab_action = new QAction("Open &Next Tab", this);
Ladybird: Switch to next/previous tab with Ctrl+PageDown/PageUp
2022-09-12 09:22:43 +02:00
open_next_tab_action->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_PageDown));
view_menu->addAction(open_next_tab_action);
QObject::connect(open_next_tab_action, &QAction::triggered, this, &BrowserWindow::open_next_tab);
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 12:46:24 -06:00
auto* open_previous_tab_action = new QAction("Open &Previous Tab", this);
Ladybird: Switch to next/previous tab with Ctrl+PageDown/PageUp
2022-09-12 09:22:43 +02:00
open_previous_tab_action->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_PageUp));
view_menu->addAction(open_previous_tab_action);
QObject::connect(open_previous_tab_action, &QAction::triggered, this, &BrowserWindow::open_previous_tab);
Ladybird/BrowserWindow: Add UI for switching preferred CSS color scheme
2022-09-19 10:48:02 +02:00
view_menu->addSeparator();
Ladybird: Show current zoom level in view menu
2023-03-26 18:56:17 +01:00
m_zoom_menu = view_menu->addMenu("&Zoom");
Ladybird: Implement zoom :^)
2023-01-12 14:39:53 +00:00
auto* zoom_in_action = new QAction("Zoom &In", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 07:45:43 -05:00
zoom_in_action->setIcon(load_icon_from_uri("resource://icons/16x16/zoom-in.png"sv));
Ladybird: Add Ctrl+= as an alternate "zoom in" shortcut On many keyboards, Ctrl++ is actually Ctrl+Shift+=, and Ctrl+= makes more sense as it's symmetric with Ctrl+-. Both Firefox and Chrome already support this alternate shortcut, so let's be nice and support it in Ladybird as well. :^)
2023-01-12 19:52:24 +01:00
auto zoom_in_shortcuts = QKeySequence::keyBindings(QKeySequence::StandardKey::ZoomIn);
UI/Qt: Ensure we don't add the same zoom shortcut key more than once On my system `QKeySequence::StandardKey::ZoomIn` includes both `Ctrl++` and `Ctrl+=`, so explicitly adding the secondary `Ctrl+=` shortcut ourselves results in an ambiguous shortcut error message being shown. According to the Qt documentation the key bindings returned by `QKeySequence::StandardKey::*` are platform specific, so we may still need to add the secondary shortcut on some systems. Therefore, we now check whether our secondary shortcut is already in the shortcut list before adding it.
2024-06-09 22:52:19 +01:00
auto secondary_zoom_shortcut = QKeySequence(Qt::CTRL | Qt::Key_Equal);
if (!zoom_in_shortcuts.contains(secondary_zoom_shortcut))
zoom_in_shortcuts.append(AK::move(secondary_zoom_shortcut));
Ladybird: Add Ctrl+= as an alternate "zoom in" shortcut On many keyboards, Ctrl++ is actually Ctrl+Shift+=, and Ctrl+= makes more sense as it's symmetric with Ctrl+-. Both Firefox and Chrome already support this alternate shortcut, so let's be nice and support it in Ladybird as well. :^)
2023-01-12 19:52:24 +01:00
zoom_in_action->setShortcuts(zoom_in_shortcuts);
Ladybird: Show current zoom level in view menu
2023-03-26 18:56:17 +01:00
m_zoom_menu->addAction(zoom_in_action);
Ladybird: Implement zoom :^)
2023-01-12 14:39:53 +00:00
QObject::connect(zoom_in_action, &QAction::triggered, this, &BrowserWindow::zoom_in);
auto* zoom_out_action = new QAction("Zoom &Out", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 07:45:43 -05:00
zoom_out_action->setIcon(load_icon_from_uri("resource://icons/16x16/zoom-out.png"sv));
Ladybird: Use QKeySequence::StandardKey as much as possible Let Qt pick the most appropriate native shortcut when it knows one.
2023-01-12 19:39:07 +01:00
zoom_out_action->setShortcuts(QKeySequence::keyBindings(QKeySequence::StandardKey::ZoomOut));
Ladybird: Show current zoom level in view menu
2023-03-26 18:56:17 +01:00
m_zoom_menu->addAction(zoom_out_action);
Ladybird: Implement zoom :^)
2023-01-12 14:39:53 +00:00
QObject::connect(zoom_out_action, &QAction::triggered, this, &BrowserWindow::zoom_out);
auto* reset_zoom_action = new QAction("&Reset Zoom", this);
Ladybird: Load all icons uses Core::Resource URIs
2023-11-05 07:45:43 -05:00
reset_zoom_action->setIcon(load_icon_from_uri("resource://icons/16x16/zoom-reset.png"sv));
Ladybird: Implement zoom :^)
2023-01-12 14:39:53 +00:00
reset_zoom_action->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_0));
Ladybird: Show current zoom level in view menu
2023-03-26 18:56:17 +01:00
m_zoom_menu->addAction(reset_zoom_action);
Ladybird: Implement zoom :^)
2023-01-12 14:39:53 +00:00
QObject::connect(reset_zoom_action, &QAction::triggered, this, &BrowserWindow::reset_zoom);
view_menu->addSeparator();
LibWebView+UI: Generate the preferred color, contrast, and motion menus
2025-09-03 11:23:09 -04:00
view_menu->addMenu(create_application_menu(*view_menu, Application::the().color_scheme_menu()));
view_menu->addMenu(create_application_menu(*view_menu, Application::the().contrast_menu()));
view_menu->addMenu(create_application_menu(*view_menu, Application::the().motion_menu()));
view_menu->addSeparator();
LibWeb: Add motion preference This adds a motion preference to the browser UI similar to the existing ones for color scheme and contrast. Both AppKit UI and Qt UI has this new preference. The auto value is currently the same as NoPreference, follow-ups can address wiring that up to the actual preference for the OS.
2024-06-13 16:15:59 +02:00
Ladybird/Qt: Introduce a hamburger menu and use by default There is an option to show the menubar, if desired (similar to KDE software).
2024-05-05 16:11:51 +01:00
auto* show_menubar = new QAction("Show &Menubar", this);
show_menubar->setCheckable(true);
show_menubar->setChecked(Settings::the()->show_menubar());
view_menu->addAction(show_menubar);
QObject::connect(show_menubar, &QAction::triggered, this, [](bool checked) {
Settings::the()->set_show_menubar(checked);
});
auto* inspect_menu = m_hamburger_menu->addMenu("&Inspect");
menuBar()->addMenu(inspect_menu);
Ladybird: Add "View Source" menu action (Ctrl+U)
2022-07-09 17:46:11 +02:00
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 08:20:14 -04:00
edit_menu->addAction(create_application_action(*this, Application::the().view_source_action()));
Ladybird: Add "View Source" menu action (Ctrl+U)
2022-07-09 17:46:11 +02:00
UI/Qt: Add UI components to enable DevTools at runtime
2025-03-15 10:10:25 -04:00
m_enable_devtools_action = new QAction("Enable &DevTools", this);
m_enable_devtools_action->setIcon(load_icon_from_uri("resource://icons/browser/dom-tree.png"sv));
m_enable_devtools_action->setShortcuts({
QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_I),
QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_C),
QKeySequence(Qt::Key_F12),
});
inspect_menu->addAction(m_enable_devtools_action);
QObject::connect(m_enable_devtools_action, &QAction::triggered, this, [this] {
if (auto result = WebView::Application::the().toggle_devtools_enabled(); result.is_error()) {
auto error_message = MUST(String::formatted("Unable to start DevTools: {}", result.error()));
QMessageBox::warning(this, "Ladybird", qstring_from_ak_string(error_message));
} else {
switch (result.value()) {
case WebView::Application::DevtoolsState::Disabled:
devtools_disabled();
break;
case WebView::Application::DevtoolsState::Enabled:
devtools_enabled();
break;
}
}
});
Ladybird: Add a simple TaskManager window for tracking child processes This implementation uses a really basic WebView to update stats once a second. In the future it might make more sense to both move the details into LibWebView, and to create a native widget for each platform to remove the overhead of having an extra WebView.
2024-03-26 11:38:12 -06:00
auto* task_manager_action = new QAction("Open Task &Manager", this);
task_manager_action->setIcon(load_icon_from_uri("resource://icons/16x16/app-system-monitor.png"sv));
task_manager_action->setShortcuts({ QKeySequence("Ctrl+Shift+M") });
inspect_menu->addAction(task_manager_action);
UI/Qt: Replace the Task Manager window with about:processes
2025-03-16 11:16:58 -04:00
QObject::connect(task_manager_action, &QAction::triggered, this, [this]() {
new_tab_from_url(URL::URL::about("processes"_string), Web::HTML::ActivateTab::Yes);
Ladybird: Add a simple TaskManager window for tracking child processes This implementation uses a really basic WebView to update stats once a second. In the future it might make more sense to both move the details into LibWebView, and to create a native widget for each platform to remove the overhead of having an extra WebView.
2024-03-26 11:38:12 -06:00
});
LibWebView+UI: Generate the application debug menu By migrating the debug menu to LibWebView, the AppKit and Qt UIs are now in sync - the AppKit UI was previously missing some actions. Further, this inadvertently fixes bugs around applying debug settings to new web views, especially across site-isolated processes. We were previously not applying settings appropriately; this now "just works" in the LibWebView infra.
2025-09-03 09:00:52 -04:00
auto* debug_menu = create_application_menu(*m_hamburger_menu, Application::the().debug_menu());
m_hamburger_menu->addMenu(debug_menu);
Ladybird: Add the "Debug" category back to the menubar This was accidentally removed in 5da9af4.
2024-05-06 18:13:54 +01:00
menuBar()->addMenu(debug_menu);
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 14:14:40 +02:00
Ladybird/Qt: Introduce a hamburger menu and use by default There is an option to show the menubar, if desired (similar to KDE software).
2024-05-05 16:11:51 +01:00
auto* help_menu = m_hamburger_menu->addMenu("&Help");
menuBar()->addMenu(help_menu);
Ladybird/Qt: Move "About Ladybird" action to Help menu
2024-05-05 15:40:36 +01:00
auto* about_action = new QAction("&About Ladybird", this);
help_menu->addAction(about_action);
Ladybird+LibWeb: Add initial about:version internal page
2024-01-12 19:41:26 +01:00
QObject::connect(about_action, &QAction::triggered, this, [this] {
UI/Qt: Do not rely on the URL implicit constructors
2025-02-22 21:51:15 +13:00
new_tab_from_url(URL::about_version(), Web::HTML::ActivateTab::Yes);
Ladybird+LibWeb: Add initial about:version internal page
2024-01-12 19:41:26 +01:00
});
Ladybird/Qt: Move "About Ladybird" action to Help menu
2024-05-05 15:40:36 +01:00
Ladybird/Qt: Introduce a hamburger menu and use by default There is an option to show the menubar, if desired (similar to KDE software).
2024-05-05 16:11:51 +01:00
m_hamburger_menu->addSeparator();
file_menu->addSeparator();
auto* quit_action = new QAction("&Quit", this);
quit_action->setShortcuts(QKeySequence::keyBindings(QKeySequence::StandardKey::Quit));
m_hamburger_menu->addAction(quit_action);
file_menu->addAction(quit_action);
QObject::connect(quit_action, &QAction::triggered, this, &QMainWindow::close);
Ladybird/Qt: Add a "new tab" button to the Qt chrome This adds a button on the right side of the location bar to create a new tab. Ideally, we would actually use QTabWidget::setCornerWidget to put this button in the tab bar. But it is surprisingly difficult to make that look nice on all platforms. Even if we ignore macOS, the CSS to make the button look right on KDE Plasma may not work well on Gnome. So for now, this location next to the location bar is horizontally the same that it would be in the tab bar at least.
2024-04-05 07:21:48 -04:00
QObject::connect(m_new_tab_action, &QAction::triggered, this, [this] {
LibWebView+UI: Introduce a persistent settings object This adds a WebView::Settings class to own persistent browser settings. In this first pass, it now owns the new tab page URL and search engine settings. For simplicitly, we currently use a JSON format for these settings. They are stored alongside the cookie database. As of this commit, the saved JSON will have the form: { "newTabPageURL": "about:blank", "searchEngine": { "name": "Google" } } (The search engine is an object to allow room for a future patch to implement custom search engine URLs.) For Qt, this replaces the management of these particular settings in the Qt settings UI. We will have an internal browser page to control these settings instead. In the future, we will want to port all settings to this new class. We will also want to allow UI-specific settings (such as whether the hamburger menu is displayed in Qt).
2025-03-20 12:59:44 -04:00
auto& tab = new_tab_from_url(WebView::Application::settings().new_tab_page_url(), Web::HTML::ActivateTab::Yes);
UI/Qt: Don't hide the location bar URL when creating a tab from a URL The location bar URL is no longer hidden when creating a new tab or opening a new window that has an associated URL. Conversely, the location bar is now always focused and the URL hidden when creating a window or tab without an associated URL. The location bar is focused when: * Opening the browser from the command line with no URL arguments * Opening a new tab (Ctrl+T) * Opening a new window (Ctrl+N) The location bar is not focused when: * Opening the browser from the command line with one or more URLs * Opening hyperlinks in a new tab * Clicking a hyperlink with `target="_blank"` This matches the behavior of other major browsers.
2024-06-20 19:11:19 +01:00
tab.set_url_is_hidden(true);
tab.focus_location_editor();
Ladybird: Add URL and 'open in background' parameters to new_tab() This will avoid loading starting about:blank page in places when we know exactly what we want to load. The opening in background part might be useful for future things like file drops and right-click open in new tab.
2023-01-08 11:21:55 +01:00
});
LibWebView+UI: Move the database and cookie jar to WebView::Application The main motivator here was noticing that --disable-sql-database did not work with AppKit. Rather than re-implementing this there, move ownership of these classes to WebView::Application, so that each UI does not need to individually worry about it.
2024-09-05 18:19:51 -04:00
QObject::connect(m_new_window_action, &QAction::triggered, this, [] {
LibWebView+UI: Define concrete `Application::the` accessor automatically This avoids assuming that the Qt Application is a QApplication, which will not be the case in an upcoming commit.
2025-06-10 14:50:23 -04:00
(void)Application::the().new_window({});
Ladybird: Support multiple browser windows in Qt chrome This also moves the ownership of the TaskManger to the Application.
2024-04-26 18:53:55 -06:00
});
Ladybird: Add "Open File..." to menu
2023-05-25 23:47:12 +02:00
QObject::connect(open_file_action, &QAction::triggered, this, &BrowserWindow::open_file);
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 23:18:21 +01:00
QObject::connect(m_tabs_container, &QTabWidget::currentChanged, [this](int index) {
AK+Everywhere: Rename `verify_cast` to `as` Follow-up to fc20e61e7249006247b43f84a3189d5a37fa103e.
2025-01-21 09:12:05 -05:00
auto* tab = as<Tab>(m_tabs_container->widget(index));
Ladybird: Retreive the tab title from the underlying Tab Rather than getting the tab name from the tab container. This resolves an issue where ampersands were being introduced to the window title when changing tabs.
2024-04-27 14:33:09 +01:00
if (tab)
setWindowTitle(QString("%1 - Ladybird").arg(tab->title()));
set_current_tab(tab);
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 23:18:21 +01:00
});
Ladybird: Allow browser tabs to be closed This is a small patch which wires up the tab close button.
2022-07-06 14:36:49 +01:00
QObject::connect(m_tabs_container, &QTabWidget::tabCloseRequested, this, &BrowserWindow::close_tab);
Ladybird: Add Ctrl-W action to close current tab (#28)
2022-07-19 06:16:46 -04:00
QObject::connect(close_current_tab_action, &QAction::triggered, this, &BrowserWindow::close_current_tab);
Ladybird: Add a location bar and allow navigating to new pages :^)
2022-07-03 21:26:51 +02:00
Ladybird: Add keyboard shortcuts for jumping to a specific tab It's now possible to open a specific tab by using Ctrl/Command plus the number key corresponding to its position in the tab row.
2023-09-20 11:32:37 +02:00
for (int i = 0; i <= 7; ++i) {
new QShortcut(QKeySequence(Qt::CTRL | static_cast<Qt::Key>(Qt::Key_1 + i)), this, [this, i] {
if (m_tabs_container->count() <= 1)
return;
m_tabs_container->setCurrentIndex(min(i, m_tabs_container->count() - 1));
});
}
new QShortcut(QKeySequence(Qt::CTRL | Qt::Key_9), this, [this] {
if (m_tabs_container->count() <= 1)
return;
m_tabs_container->setCurrentIndex(m_tabs_container->count() - 1);
});
Ladybird: Respect window.open() features in Qt chrome
2024-05-28 13:27:57 -06:00
if (parent_tab) {
new_child_tab(Web::HTML::ActivateTab::Yes, *parent_tab, AK::move(page_index));
} else {
LibWebView+UI: Migrate Ladybird's command line flags to LibWebView Currently, if we want to add a new e.g. WebContent command line option, we have to add it to all of Qt, AppKit, and headless-browser. (Or worse, we only add it to one of these, and we have feature disparity). To prevent this, this moves command line flags to WebView::Application. The flags are assigned to ChromeOptions and WebContentOptions structs. Each chrome can still add its platform-specific options; for example, the Qt chrome has a flag to enable Qt networking. There should be no behavior change here, other than that AppKit will now support command line flags that were previously only supported by Qt.
2024-07-30 14:01:05 -04:00
for (size_t i = 0; i < initial_urls.size(); ++i) {
new_tab_from_url(initial_urls[i], (i == 0) ? Web::HTML::ActivateTab::Yes : Web::HTML::ActivateTab::No);
Ladybird: Respect window.open() features in Qt chrome
2024-05-28 13:27:57 -06:00
}
Ladybird: Only load a single URL at launch When we launch Ladybird, we currently: 1. Create a BrowserWindow, whose constructor navigates to the configured new tab page URL. 2. Then navigate to either "about:blank" or whatever URL is provided via the command line. This patch removes step 2 and forwards the URL from the command line (if any) to BrowserWindow. BrowserWindow's constructor then either navigates to that URL or the new tab page URL.
2023-08-08 15:59:55 -04: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 23:18:21 +01:00
UI/Qt: Move New Tab button in tab bar
2024-07-14 16:24:48 -04:00
m_new_tab_button_toolbar->addAction(m_new_tab_action);
m_new_tab_button_toolbar->setMovable(false);
m_new_tab_button_toolbar->setStyleSheet("QToolBar { background: transparent; }");
m_new_tab_button_toolbar->setIconSize(QSize(16, 16));
UI/Qt: Make TabWidget responsible for new-tab button positioning Makes use of the fact that QTabWidget automatically reserves space for "corner widgets", and gives us the ability to override their location with a custom style. Also, determine the height of the new-tab button using the height of the tab bar, instead of a hard-coded 32px which was too tall on MacOS.
2024-07-26 11:38:26 +01:00
m_tabs_container->setCornerWidget(m_new_tab_button_toolbar, Qt::TopRightCorner);
UI/Qt: Move New Tab button in tab bar
2024-07-14 16:24:48 -04: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 23:18:21 +01:00
setCentralWidget(m_tabs_container);
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 11:49:44 -04:00
setContextMenuPolicy(Qt::PreventContextMenu);
LibWebView+UI: Launch the DevTools server if --devtools is specified This replaces the --devtools-port flag with a --devtools flag, which optionally accepts a port. If the --devtools flag is set, we will now automatically launch the DevTools server.
2025-07-02 12:42:53 -04:00
if (browser_options.devtools_port.has_value())
devtools_enabled();
Ladybird: Allow right clicking and inspecting elements This adds "Inspect Element" (currently the only entry) to the context menu for the page, which will do what you expect (most of the time), and bring up the Inspector with hovered element selected.
2023-05-08 21:15:35 +01:00
}
UI/Qt: Add UI components to enable DevTools at runtime
2025-03-15 10:10:25 -04:00
void BrowserWindow::devtools_disabled()
{
m_enable_devtools_action->setText("Enable &DevTools");
setStatusBar(nullptr);
}
void BrowserWindow::devtools_enabled()
{
UI: Show "Disable" title in DevTools disable button The "disable DevTools" button looked like a "close this notification" button to me, and although a tooltip was set, it only showed up immediately on the AppKit UI and not the Qt version. This makes the behavior of clicking the disable button a lot clearer by showing a button with "Disable" as its title.
2025-03-20 12:30:27 +01:00
auto* disable_button = new QPushButton("Disable", this);
UI/Qt: Add UI components to enable DevTools at runtime
2025-03-15 10:10:25 -04:00
connect(disable_button, &QPushButton::clicked, this, [this]() {
MUST(WebView::Application::the().toggle_devtools_enabled());
devtools_disabled();
});
m_enable_devtools_action->setText("Disable &DevTools");
statusBar()->addPermanentWidget(disable_button);
LibWebView+UI: Rename ChromeOptions to BrowserOptions
2025-03-15 16:56:52 -04:00
auto message = MUST(String::formatted("DevTools is enabled on port {}", WebView::Application::browser_options().devtools_port));
UI/Qt: Add UI components to enable DevTools at runtime
2025-03-15 10:10:25 -04:00
statusBar()->showMessage(qstring_from_ak_string(message));
}
Ladybird: Show current zoom level in view menu
2023-03-26 18:56:17 +01:00
void BrowserWindow::set_current_tab(Tab* tab)
{
m_current_tab = tab;
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 08:20:14 -04:00
if (tab)
Ladybird: Add reset zoom level button to toolbar This is a port of the Browser feature.
2023-03-29 00:25:42 +01:00
update_displayed_zoom_level();
Ladybird: Show current zoom level in view menu
2023-03-26 18:56:17 +01:00
}
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 16:22:27 +13:00
Tab& BrowserWindow::new_tab_from_url(URL::URL const& url, Web::HTML::ActivateTab activate_tab)
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 16:14:34 -04:00
{
auto& tab = create_new_tab(activate_tab);
tab.navigate(url);
return tab;
}
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-30 18:52:59 -07:00
Tab& BrowserWindow::new_tab_from_content(StringView html, Web::HTML::ActivateTab activate_tab)
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 16:14:34 -04:00
{
auto& tab = create_new_tab(activate_tab);
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 17:12:17 +02:00
tab.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 16:14:34 -04:00
return tab;
}
Ladybird: Respect window.open() features in Qt chrome
2024-05-28 13:27:57 -06:00
Tab& BrowserWindow::new_child_tab(Web::HTML::ActivateTab activate_tab, Tab& parent, Optional<u64> page_index)
Ladybird: Add IPC call for creating a new child tab This will be used for choosing a navigable that requires opening a new tab or new window. Such as calls to window.open(), or specific WebDriver calls.
2024-01-30 20:05:00 -07:00
{
Ladybird: Respect window.open() features in Qt chrome
2024-05-28 13:27:57 -06:00
return create_new_tab(activate_tab, parent, page_index);
Ladybird: Add IPC call for creating a new child tab This will be used for choosing a navigable that requires opening a new tab or new window. Such as calls to window.open(), or specific WebDriver calls.
2024-01-30 20:05:00 -07:00
}
Ladybird: Respect window.open() features in Qt chrome
2024-05-28 13:27:57 -06:00
Tab& BrowserWindow::create_new_tab(Web::HTML::ActivateTab activate_tab, Tab& parent, Optional<u64> page_index)
Ladybird: Add IPC call for creating a new child tab This will be used for choosing a navigable that requires opening a new tab or new window. Such as calls to window.open(), or specific WebDriver calls.
2024-01-30 20:05:00 -07:00
{
if (!page_index.has_value())
return create_new_tab(activate_tab);
LibWebView+UI: Migrate Ladybird's command line flags to LibWebView Currently, if we want to add a new e.g. WebContent command line option, we have to add it to all of Qt, AppKit, and headless-browser. (Or worse, we only add it to one of these, and we have feature disparity). To prevent this, this moves command line flags to WebView::Application. The flags are assigned to ChromeOptions and WebContentOptions structs. Each chrome can still add its platform-specific options; for example, the Qt chrome has a flag to enable Qt networking. There should be no behavior change here, other than that AppKit will now support command line flags that were previously only supported by Qt.
2024-07-30 14:01:05 -04:00
auto* tab = new Tab(this, parent.view().client(), page_index.value());
Ladybird: Add IPC call for creating a new child tab This will be used for choosing a navigable that requires opening a new tab or new window. Such as calls to window.open(), or specific WebDriver calls.
2024-01-30 20:05:00 -07:00
Ladybird: Respect window.open() features in Qt chrome
2024-05-28 13:27:57 -06:00
// FIXME: Merge with other overload
if (m_current_tab == nullptr) {
set_current_tab(tab);
}
Ladybird: Add IPC call for creating a new child tab This will be used for choosing a navigable that requires opening a new tab or new window. Such as calls to window.open(), or specific WebDriver calls.
2024-01-30 20:05:00 -07:00
m_tabs_container->addTab(tab, "New Tab");
UI/Qt: Don't hide the location bar URL when creating a tab from a URL The location bar URL is no longer hidden when creating a new tab or opening a new window that has an associated URL. Conversely, the location bar is now always focused and the URL hidden when creating a window or tab without an associated URL. The location bar is focused when: * Opening the browser from the command line with no URL arguments * Opening a new tab (Ctrl+T) * Opening a new window (Ctrl+N) The location bar is not focused when: * Opening the browser from the command line with one or more URLs * Opening hyperlinks in a new tab * Clicking a hyperlink with `target="_blank"` This matches the behavior of other major browsers.
2024-06-20 19:11:19 +01:00
if (activate_tab == Web::HTML::ActivateTab::Yes)
Ladybird: Add IPC call for creating a new child tab This will be used for choosing a navigable that requires opening a new tab or new window. Such as calls to window.open(), or specific WebDriver calls.
2024-01-30 20:05:00 -07:00
m_tabs_container->setCurrentWidget(tab);
UI/Qt: Don't hide the location bar URL when creating a tab from a URL The location bar URL is no longer hidden when creating a new tab or opening a new window that has an associated URL. Conversely, the location bar is now always focused and the URL hidden when creating a window or tab without an associated URL. The location bar is focused when: * Opening the browser from the command line with no URL arguments * Opening a new tab (Ctrl+T) * Opening a new window (Ctrl+N) The location bar is not focused when: * Opening the browser from the command line with one or more URLs * Opening hyperlinks in a new tab * Clicking a hyperlink with `target="_blank"` This matches the behavior of other major browsers.
2024-06-20 19:11:19 +01:00
Ladybird: Add IPC call for creating a new child tab This will be used for choosing a navigable that requires opening a new tab or new window. Such as calls to window.open(), or specific WebDriver calls.
2024-01-30 20:05:00 -07:00
initialize_tab(tab);
return *tab;
}
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 16:14:34 -04:00
Tab& BrowserWindow::create_new_tab(Web::HTML::ActivateTab activate_tab)
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 23:18:21 +01:00
{
LibWebView+UI: Migrate Ladybird's command line flags to LibWebView Currently, if we want to add a new e.g. WebContent command line option, we have to add it to all of Qt, AppKit, and headless-browser. (Or worse, we only add it to one of these, and we have feature disparity). To prevent this, this moves command line flags to WebView::Application. The flags are assigned to ChromeOptions and WebContentOptions structs. Each chrome can still add its platform-specific options; for example, the Qt chrome has a flag to enable Qt networking. There should be no behavior change here, other than that AppKit will now support command line flags that were previously only supported by Qt.
2024-07-30 14:01:05 -04:00
auto* tab = new Tab(this);
Ladybird: Add a location bar and allow navigating to new pages :^)
2022-07-03 21:26:51 +02: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 23:18:21 +01:00
if (m_current_tab == nullptr) {
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 09:39:22 -05:00
set_current_tab(tab);
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 23:18:21 +01:00
}
Ladybird: Add a location bar and allow navigating to new pages :^)
2022-07-03 21:26:51 +02: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 09:39:22 -05:00
m_tabs_container->addTab(tab, "New Tab");
UI/Qt: Don't hide the location bar URL when creating a tab from a URL The location bar URL is no longer hidden when creating a new tab or opening a new window that has an associated URL. Conversely, the location bar is now always focused and the URL hidden when creating a window or tab without an associated URL. The location bar is focused when: * Opening the browser from the command line with no URL arguments * Opening a new tab (Ctrl+T) * Opening a new window (Ctrl+N) The location bar is not focused when: * Opening the browser from the command line with one or more URLs * Opening hyperlinks in a new tab * Clicking a hyperlink with `target="_blank"` This matches the behavior of other major browsers.
2024-06-20 19:11:19 +01:00
if (activate_tab == Web::HTML::ActivateTab::Yes)
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 09:39:22 -05:00
m_tabs_container->setCurrentWidget(tab);
UI/Qt: Don't hide the location bar URL when creating a tab from a URL The location bar URL is no longer hidden when creating a new tab or opening a new window that has an associated URL. Conversely, the location bar is now always focused and the URL hidden when creating a window or tab without an associated URL. The location bar is focused when: * Opening the browser from the command line with no URL arguments * Opening a new tab (Ctrl+T) * Opening a new window (Ctrl+N) The location bar is not focused when: * Opening the browser from the command line with one or more URLs * Opening hyperlinks in a new tab * Clicking a hyperlink with `target="_blank"` This matches the behavior of other major browsers.
2024-06-20 19:11:19 +01:00
Ladybird: Add IPC call for creating a new child tab This will be used for choosing a navigable that requires opening a new tab or new window. Such as calls to window.open(), or specific WebDriver calls.
2024-01-30 20:05:00 -07:00
initialize_tab(tab);
return *tab;
}
void BrowserWindow::initialize_tab(Tab* tab)
{
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 09:39:22 -05:00
QObject::connect(tab, &Tab::title_changed, this, &BrowserWindow::tab_title_changed);
QObject::connect(tab, &Tab::favicon_changed, this, &BrowserWindow::tab_favicon_changed);
Ladybird/Qt: Display an audio button on tabs that are playing audio When audio begins playing, add a button to the left of the favicon with a speaker icon to indicate which tab is playing audio. This button is currently disabled, but in the future may be used to mute the tab.
2024-03-28 11:16:10 -04:00
QObject::connect(tab, &Tab::audio_play_state_changed, this, &BrowserWindow::tab_audio_play_state_changed);
Ladybird: Hide TabBar if count <= 1
2022-07-12 11:41:11 +02: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 09:39:22 -05:00
QObject::connect(&tab->view(), &WebContentView::urls_dropped, this, [this](auto& urls) {
Ladybird: Accept file drops
2023-01-07 17:40:04 +01:00
VERIFY(urls.size());
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-30 19:15:55 -07:00
m_current_tab->navigate(ak_url_from_qurl(urls[0]));
Ladybird: Accept file drops
2023-01-07 17:40:04 +01:00
for (qsizetype i = 1; i < urls.size(); ++i)
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-30 19:15:55 -07:00
new_tab_from_url(ak_url_from_qurl(urls[i]), Web::HTML::ActivateTab::No);
Ladybird: Accept file drops
2023-01-07 17:40:04 +01:00
});
Ladybird: Add IPC call for creating a new child tab This will be used for choosing a navigable that requires opening a new tab or new window. Such as calls to window.open(), or specific WebDriver calls.
2024-01-30 20:05:00 -07:00
tab->view().on_new_web_view = [this, tab](auto activate_tab, Web::HTML::WebViewHints hints, Optional<u64> page_index) {
Ladybird: Respect window.open() features in Qt chrome
2024-05-28 13:27:57 -06:00
if (hints.popup) {
LibWebView+UI: Define concrete `Application::the` accessor automatically This avoids assuming that the Qt Application is a QApplication, which will not be the case in an upcoming commit.
2025-06-10 14:50:23 -04:00
auto& window = Application::the().new_window({}, IsPopupWindow::Yes, tab, AK::move(page_index));
Ladybird: Respect window.open() features in Qt chrome
2024-05-28 13:27:57 -06:00
window.set_window_rect(hints.screen_x, hints.screen_y, hints.width, hints.height);
return window.current_tab()->view().handle();
}
auto& new_tab = new_child_tab(activate_tab, *tab, page_index);
Ladybird: Add IPC call for creating a new child tab This will be used for choosing a navigable that requires opening a new tab or new window. Such as calls to window.open(), or specific WebDriver calls.
2024-01-30 20:05:00 -07:00
return new_tab.view().handle();
Ladybird: Implement `notify_request_open_new_tab`
2023-03-14 17:19:28 +03: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 09:39:22 -05:00
tab->view().on_tab_open_request = [this](auto url, auto activate_tab) {
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-30 19:15:55 -07:00
auto& tab = new_tab_from_url(url, activate_tab);
Ladybird: Open target _blank links in new tab
2023-03-22 21:24:15 -03:00
return tab.view().handle();
};
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 09:39:22 -05:00
tab->view().on_link_click = [this](auto url, auto target, unsigned modifiers) {
Ladybird: Open target _blank links in new tab
2023-03-22 21:24:15 -03:00
// TODO: maybe activate tabs according to some configuration, this is just normal current browser behavior
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 13:29:08 -06:00
if (modifiers == Web::UIEvents::Mod_Ctrl) {
Ladybird: Open target _blank links in new tab
2023-03-22 21:24:15 -03:00
m_current_tab->view().on_tab_open_request(url, Web::HTML::ActivateTab::No);
} else if (target == "_blank") {
m_current_tab->view().on_tab_open_request(url, Web::HTML::ActivateTab::Yes);
Ladybird: Add a context menu for video elements
2023-05-15 12:27:10 -04:00
} else {
m_current_tab->view().load(url);
Ladybird: Open target _blank links in new tab
2023-03-22 21:24:15 -03: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 09:39:22 -05:00
tab->view().on_link_middle_click = [this](auto url, auto target, unsigned modifiers) {
LibWeb: Add Web::UIEvents::KeyCode and KeyModifier enums, drop Kernel This was the last Kernel header we had. Move the definitions we need into a UIEvents header similar to MouseButton.
2024-06-06 13:29:08 -06:00
m_current_tab->view().on_link_click(url, target, Web::UIEvents::Mod_Ctrl);
Ladybird: Open target _blank links in new tab
2023-03-22 21:24:15 -03:00
(void)modifiers;
};
Ladybird/Qt: Display a default favicon and title This ensures we consistently show a favicon and that we update the title to at least display the page URL when there isn't a <title> tag. We would otherwise continue displaying the previous page's title.
2024-03-28 11:11:02 -04:00
m_tabs_container->setTabIcon(m_tabs_container->indexOf(tab), tab->favicon());
Ladybird/Qt: Replace the default tab close icon with a vector icon The default icon used by Qt is a bit jarring. Replace it with an icon that resembles our other homemade icons.
2024-04-02 21:35:52 -04:00
create_close_button_for_tab(tab);
Ladybird: Add a location bar and allow navigating to new pages :^)
2022-07-03 21:26:51 +02:00
}
WebContent+Everywhere: Add a WebContent IPC to activate a tab
2023-03-20 19:52:00 -04:00
void BrowserWindow::activate_tab(int index)
{
m_tabs_container->setCurrentIndex(index);
}
Ladybird: Allow browser tabs to be closed This is a small patch which wires up the tab close button.
2022-07-06 14:36:49 +01:00
void BrowserWindow::close_tab(int index)
{
auto* tab = m_tabs_container->widget(index);
m_tabs_container->removeTab(index);
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 09:39:22 -05:00
tab->deleteLater();
Ladybird/Qt: Close the browser when the last tab's close button is used We currently do this already when the last tab is closed via the ctrl-W shortcut. Move the logic for this to BrowserWindow::close_tab so that we also close the window when the tab is closed via its close button.
2024-04-05 07:36:12 -04:00
if (m_tabs_container->count() == 0)
close();
Ladybird: Allow browser tabs to be closed This is a small patch which wires up the tab close button.
2022-07-06 14:36:49 +01:00
}
Ladybird: Add a context menu to the tab bar This shows the following actions: * Reload Tab * Duplicate Tab * Move Tab * Move to Start * Move to End * Close Tab * Close Other Tabs * Close Tabs to Left * Close Tabs to Right * Close Other Tabs
2024-04-28 15:07:23 +01:00
void BrowserWindow::move_tab(int old_index, int new_index)
{
m_tabs_container->tabBar()->moveTab(old_index, new_index);
}
Ladybird: Add "Open File..." to menu
2023-05-25 23:47:12 +02:00
void BrowserWindow::open_file()
{
m_current_tab->open_file();
}
Ladybird: Add Ctrl-W action to close current tab (#28)
2022-07-19 06:16:46 -04:00
void BrowserWindow::close_current_tab()
{
Ladybird: Close the current tab even if we're closing the window Currently, if the JS console is open and tied to the last opened tab in the browser window, it will prevent the main process from exiting when the last tab is closed. This change explicitly closes that tab before closing the window (if it's the last tab), allowing Qt to delete the Tab object.
2023-08-08 18:42:18 -04:00
close_tab(m_tabs_container->currentIndex());
Ladybird: Add Ctrl-W action to close current tab (#28)
2022-07-19 06:16:46 -04: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 23:18:21 +01:00
int BrowserWindow::tab_index(Tab* tab)
Ladybird: Add a location bar and allow navigating to new pages :^)
2022-07-03 21:26:51 +02: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 23:18:21 +01:00
return m_tabs_container->indexOf(tab);
Ladybird: Add a location bar and allow navigating to new pages :^)
2022-07-03 21:26:51 +02:00
}
Ladybird: Show the web page title in the window titlebar :^)
2022-07-04 02:11:58 +02:00
Ladybird/Qt: Listen to DPI changes and update WebContentView accordingly
2023-12-13 19:10:05 +01:00
void BrowserWindow::device_pixel_ratio_changed(qreal dpi)
{
m_device_pixel_ratio = dpi;
for_each_tab([this](auto& tab) {
tab.view().set_device_pixel_ratio(m_device_pixel_ratio);
});
}
UI/Qt: Set WC's max FPS to the refresh rate of the current screen
2025-07-25 16:43:27 +01:00
void BrowserWindow::refresh_rate_changed(qreal refresh_rate)
{
m_refresh_rate = refresh_rate;
for_each_tab([this](auto& tab) {
tab.view().set_maximum_frames_per_second(m_refresh_rate);
});
}
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 23:18:21 +01:00
void BrowserWindow::tab_title_changed(int index, QString const& title)
Ladybird: Show the web page title in the window titlebar :^)
2022-07-04 02:11:58 +02:00
{
Ladybird/Qt: Display ampersands in tab titles Qt reads ampersands as shortcut keys, so this escapes them (with &&) so they display correctly :^)
2024-08-12 13:37:11 +01:00
// NOTE: Qt uses ampersands for shortcut keys in tab titles, so we need to escape them.
QString title_escaped = title;
title_escaped.replace("&", "&&");
m_tabs_container->setTabText(index, title_escaped);
Ladybird/Qt: Set the tab tooltip to its full title If a tab's title is cut off due to its size, setting a tool tip will allow for viewing the full title.
2024-04-02 21:45:09 -04:00
m_tabs_container->setTabToolTip(index, title);
Browser+Ladybird+LibWebView: Consolidate title handling in LibWebView Namely, let's have empty titles behave the same in both Browser and Ladybird (display the URL).
2023-06-07 16:37:30 -04:00
if (m_tabs_container->currentIndex() == index)
setWindowTitle(QString("%1 - Ladybird").arg(title));
Ladybird: Show the web page title in the window titlebar :^)
2022-07-04 02:11:58 +02:00
}
Ladybird: Add Favicon to the window
2022-07-05 05:53:11 +01:00
Ladybird: Pass QIcon by reference in `tab_favicon_changed`
2023-05-29 19:05:40 +10:00
void BrowserWindow::tab_favicon_changed(int index, QIcon const& icon)
Ladybird: Add Favicon to the window
2022-07-05 05:53:11 +01: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 23:18:21 +01:00
m_tabs_container->setTabIcon(index, icon);
Ladybird: Add Favicon to the window
2022-07-05 05:53:11 +01:00
}
Ladybird: Switch to next/previous tab with Ctrl+PageDown/PageUp
2022-09-12 09:22:43 +02:00
Ladybird/Qt: Replace the default tab close icon with a vector icon The default icon used by Qt is a bit jarring. Replace it with an icon that resembles our other homemade icons.
2024-04-02 21:35:52 -04:00
void BrowserWindow::create_close_button_for_tab(Tab* tab)
{
auto index = m_tabs_container->indexOf(tab);
m_tabs_container->setTabIcon(index, tab->favicon());
auto* button = new TabBarButton(create_tvg_icon_with_theme_colors("close", palette()));
auto position = audio_button_position_for_tab(index) == QTabBar::LeftSide ? QTabBar::RightSide : QTabBar::LeftSide;
connect(button, &QPushButton::clicked, this, [this, tab]() {
auto index = m_tabs_container->indexOf(tab);
close_tab(index);
});
m_tabs_container->tabBar()->setTabButton(index, position, button);
}
Ladybird/Qt: Display an audio button on tabs that are playing audio When audio begins playing, add a button to the left of the favicon with a speaker icon to indicate which tab is playing audio. This button is currently disabled, but in the future may be used to mute the tab.
2024-03-28 11:16:10 -04:00
void BrowserWindow::tab_audio_play_state_changed(int index, Web::HTML::AudioPlayState play_state)
{
AK+Everywhere: Rename `verify_cast` to `as` Follow-up to fc20e61e7249006247b43f84a3189d5a37fa103e.
2025-01-21 09:12:05 -05:00
auto* tab = as<Tab>(m_tabs_container->widget(index));
Ladybird/Qt: Place the tab audio state button on the right on macOS On macOS, the "close tab" button is on the left, so we should place the audio state button on the right to avoid conflict. Rather than an OS ifdef, we do this by detecting if the left side is occupied.
2024-03-30 18:47:50 -04:00
auto position = audio_button_position_for_tab(index);
Ladybird/Qt: Reference the correct tab when handling the audio icon We were errantly always referring to the active tab when the audio play state changed, and when clicking a tab's audio state button, by way of BrowserWindow::view(). It turns out we also can't copy / rely on the tab index provided to the signal in any asynchronous context. If the tabs are rearranged, so are their indices. Instead, capture a pointer to the tab of interest - this should be safe as we wouldn't be able to click a tab's audio button if that tab no longer exists. With this change, we can click the audio button from any tab in the Qt chrome, and re-arrange tabs at will. The AppKit and Serenity chromes do not have this issue.
2024-03-30 18:36:26 -04:00
Ladybird/Qt: Display an audio button on tabs that are playing audio When audio begins playing, add a button to the left of the favicon with a speaker icon to indicate which tab is playing audio. This button is currently disabled, but in the future may be used to mute the tab.
2024-03-28 11:16:10 -04:00
switch (play_state) {
case Web::HTML::AudioPlayState::Paused:
Ladybird/Qt: Reference the correct tab when handling the audio icon We were errantly always referring to the active tab when the audio play state changed, and when clicking a tab's audio state button, by way of BrowserWindow::view(). It turns out we also can't copy / rely on the tab index provided to the signal in any asynchronous context. If the tabs are rearranged, so are their indices. Instead, capture a pointer to the tab of interest - this should be safe as we wouldn't be able to click a tab's audio button if that tab no longer exists. With this change, we can click the audio button from any tab in the Qt chrome, and re-arrange tabs at will. The AppKit and Serenity chromes do not have this issue.
2024-03-30 18:36:26 -04:00
if (tab->view().page_mute_state() == Web::HTML::MuteState::Unmuted)
Ladybird/Qt: Place the tab audio state button on the right on macOS On macOS, the "close tab" button is on the left, so we should place the audio state button on the right to avoid conflict. Rather than an OS ifdef, we do this by detecting if the left side is occupied.
2024-03-30 18:47:50 -04:00
m_tabs_container->tabBar()->setTabButton(index, position, nullptr);
Ladybird/Qt: Display an audio button on tabs that are playing audio When audio begins playing, add a button to the left of the favicon with a speaker icon to indicate which tab is playing audio. This button is currently disabled, but in the future may be used to mute the tab.
2024-03-28 11:16:10 -04:00
break;
case Web::HTML::AudioPlayState::Playing:
Ladybird/Qt: Add a hover effect to the audio play state button By default, a flat QPushButton does not have a hover effect. Add a small subclass to provide such an effect to make it clearer it is a button.
2024-04-02 21:24:17 -04:00
auto* button = new TabBarButton(icon_for_page_mute_state(*tab));
Ladybird/Qt: Reference the correct tab when handling the audio icon We were errantly always referring to the active tab when the audio play state changed, and when clicking a tab's audio state button, by way of BrowserWindow::view(). It turns out we also can't copy / rely on the tab index provided to the signal in any asynchronous context. If the tabs are rearranged, so are their indices. Instead, capture a pointer to the tab of interest - this should be safe as we wouldn't be able to click a tab's audio button if that tab no longer exists. With this change, we can click the audio button from any tab in the Qt chrome, and re-arrange tabs at will. The AppKit and Serenity chromes do not have this issue.
2024-03-30 18:36:26 -04:00
button->setToolTip(tool_tip_for_page_mute_state(*tab));
Ladybird/Qt: Prevent adding multiple audio state buttons If the left-hand side of the tab is already occupied with an audio state button, we would add a second button to the right-hand side. Prevent that by checking if the occupant is our audio state button.
2024-04-02 12:52:03 -04:00
button->setObjectName("LadybirdAudioState");
Ladybird/Qt: Display an audio button on tabs that are playing audio When audio begins playing, add a button to the left of the favicon with a speaker icon to indicate which tab is playing audio. This button is currently disabled, but in the future may be used to mute the tab.
2024-03-28 11:16:10 -04:00
Ladybird/Qt: Place the tab audio state button on the right on macOS On macOS, the "close tab" button is on the left, so we should place the audio state button on the right to avoid conflict. Rather than an OS ifdef, we do this by detecting if the left side is occupied.
2024-03-30 18:47:50 -04:00
connect(button, &QPushButton::clicked, this, [this, tab, position]() {
Ladybird/Qt: Reference the correct tab when handling the audio icon We were errantly always referring to the active tab when the audio play state changed, and when clicking a tab's audio state button, by way of BrowserWindow::view(). It turns out we also can't copy / rely on the tab index provided to the signal in any asynchronous context. If the tabs are rearranged, so are their indices. Instead, capture a pointer to the tab of interest - this should be safe as we wouldn't be able to click a tab's audio button if that tab no longer exists. With this change, we can click the audio button from any tab in the Qt chrome, and re-arrange tabs at will. The AppKit and Serenity chromes do not have this issue.
2024-03-30 18:36:26 -04:00
tab->view().toggle_page_mute_state();
auto index = tab_index(tab);
Ladybird/Qt: Support muting an entire page We already display a speaker icon on tabs which are playing audio. This allows the user to click that icon to mute the tab, at which point the icon is replaced with a muted speaker icon. We would previously hide the icon when audio stopped playing. We now do this only if the tab isn't muted. If it is muted, the muted speaker icon remains on the tab so that the page isn't stuck in a muted state.
2024-03-30 09:48:33 -04:00
Ladybird/Qt: Reference the correct tab when handling the audio icon We were errantly always referring to the active tab when the audio play state changed, and when clicking a tab's audio state button, by way of BrowserWindow::view(). It turns out we also can't copy / rely on the tab index provided to the signal in any asynchronous context. If the tabs are rearranged, so are their indices. Instead, capture a pointer to the tab of interest - this should be safe as we wouldn't be able to click a tab's audio button if that tab no longer exists. With this change, we can click the audio button from any tab in the Qt chrome, and re-arrange tabs at will. The AppKit and Serenity chromes do not have this issue.
2024-03-30 18:36:26 -04:00
switch (tab->view().audio_play_state()) {
Ladybird/Qt: Support muting an entire page We already display a speaker icon on tabs which are playing audio. This allows the user to click that icon to mute the tab, at which point the icon is replaced with a muted speaker icon. We would previously hide the icon when audio stopped playing. We now do this only if the tab isn't muted. If it is muted, the muted speaker icon remains on the tab so that the page isn't stuck in a muted state.
2024-03-30 09:48:33 -04:00
case Web::HTML::AudioPlayState::Paused:
Ladybird/Qt: Place the tab audio state button on the right on macOS On macOS, the "close tab" button is on the left, so we should place the audio state button on the right to avoid conflict. Rather than an OS ifdef, we do this by detecting if the left side is occupied.
2024-03-30 18:47:50 -04:00
m_tabs_container->tabBar()->setTabButton(index, position, nullptr);
Ladybird/Qt: Support muting an entire page We already display a speaker icon on tabs which are playing audio. This allows the user to click that icon to mute the tab, at which point the icon is replaced with a muted speaker icon. We would previously hide the icon when audio stopped playing. We now do this only if the tab isn't muted. If it is muted, the muted speaker icon remains on the tab so that the page isn't stuck in a muted state.
2024-03-30 09:48:33 -04:00
break;
case Web::HTML::AudioPlayState::Playing:
Ladybird/Qt: Place the tab audio state button on the right on macOS On macOS, the "close tab" button is on the left, so we should place the audio state button on the right to avoid conflict. Rather than an OS ifdef, we do this by detecting if the left side is occupied.
2024-03-30 18:47:50 -04:00
auto* button = m_tabs_container->tabBar()->tabButton(index, position);
AK+Everywhere: Rename `verify_cast` to `as` Follow-up to fc20e61e7249006247b43f84a3189d5a37fa103e.
2025-01-21 09:12:05 -05:00
as<TabBarButton>(button)->setIcon(icon_for_page_mute_state(*tab));
Ladybird/Qt: Reference the correct tab when handling the audio icon We were errantly always referring to the active tab when the audio play state changed, and when clicking a tab's audio state button, by way of BrowserWindow::view(). It turns out we also can't copy / rely on the tab index provided to the signal in any asynchronous context. If the tabs are rearranged, so are their indices. Instead, capture a pointer to the tab of interest - this should be safe as we wouldn't be able to click a tab's audio button if that tab no longer exists. With this change, we can click the audio button from any tab in the Qt chrome, and re-arrange tabs at will. The AppKit and Serenity chromes do not have this issue.
2024-03-30 18:36:26 -04:00
button->setToolTip(tool_tip_for_page_mute_state(*tab));
Ladybird/Qt: Support muting an entire page We already display a speaker icon on tabs which are playing audio. This allows the user to click that icon to mute the tab, at which point the icon is replaced with a muted speaker icon. We would previously hide the icon when audio stopped playing. We now do this only if the tab isn't muted. If it is muted, the muted speaker icon remains on the tab so that the page isn't stuck in a muted state.
2024-03-30 09:48:33 -04:00
break;
}
});
Ladybird/Qt: Display an audio button on tabs that are playing audio When audio begins playing, add a button to the left of the favicon with a speaker icon to indicate which tab is playing audio. This button is currently disabled, but in the future may be used to mute the tab.
2024-03-28 11:16:10 -04:00
Ladybird/Qt: Place the tab audio state button on the right on macOS On macOS, the "close tab" button is on the left, so we should place the audio state button on the right to avoid conflict. Rather than an OS ifdef, we do this by detecting if the left side is occupied.
2024-03-30 18:47:50 -04:00
m_tabs_container->tabBar()->setTabButton(index, position, button);
Ladybird/Qt: Display an audio button on tabs that are playing audio When audio begins playing, add a button to the left of the favicon with a speaker icon to indicate which tab is playing audio. This button is currently disabled, but in the future may be used to mute the tab.
2024-03-28 11:16:10 -04:00
break;
}
}
Ladybird/Qt: Reference the correct tab when handling the audio icon We were errantly always referring to the active tab when the audio play state changed, and when clicking a tab's audio state button, by way of BrowserWindow::view(). It turns out we also can't copy / rely on the tab index provided to the signal in any asynchronous context. If the tabs are rearranged, so are their indices. Instead, capture a pointer to the tab of interest - this should be safe as we wouldn't be able to click a tab's audio button if that tab no longer exists. With this change, we can click the audio button from any tab in the Qt chrome, and re-arrange tabs at will. The AppKit and Serenity chromes do not have this issue.
2024-03-30 18:36:26 -04:00
QIcon BrowserWindow::icon_for_page_mute_state(Tab& tab) const
Ladybird/Qt: Support muting an entire page We already display a speaker icon on tabs which are playing audio. This allows the user to click that icon to mute the tab, at which point the icon is replaced with a muted speaker icon. We would previously hide the icon when audio stopped playing. We now do this only if the tab isn't muted. If it is muted, the muted speaker icon remains on the tab so that the page isn't stuck in a muted state.
2024-03-30 09:48:33 -04:00
{
Ladybird/Qt: Reference the correct tab when handling the audio icon We were errantly always referring to the active tab when the audio play state changed, and when clicking a tab's audio state button, by way of BrowserWindow::view(). It turns out we also can't copy / rely on the tab index provided to the signal in any asynchronous context. If the tabs are rearranged, so are their indices. Instead, capture a pointer to the tab of interest - this should be safe as we wouldn't be able to click a tab's audio button if that tab no longer exists. With this change, we can click the audio button from any tab in the Qt chrome, and re-arrange tabs at will. The AppKit and Serenity chromes do not have this issue.
2024-03-30 18:36:26 -04:00
switch (tab.view().page_mute_state()) {
Ladybird/Qt: Support muting an entire page We already display a speaker icon on tabs which are playing audio. This allows the user to click that icon to mute the tab, at which point the icon is replaced with a muted speaker icon. We would previously hide the icon when audio stopped playing. We now do this only if the tab isn't muted. If it is muted, the muted speaker icon remains on the tab so that the page isn't stuck in a muted state.
2024-03-30 09:48:33 -04:00
case Web::HTML::MuteState::Muted:
return style()->standardIcon(QStyle::SP_MediaVolumeMuted);
case Web::HTML::MuteState::Unmuted:
return style()->standardIcon(QStyle::SP_MediaVolume);
}
VERIFY_NOT_REACHED();
}
Ladybird/Qt: Reference the correct tab when handling the audio icon We were errantly always referring to the active tab when the audio play state changed, and when clicking a tab's audio state button, by way of BrowserWindow::view(). It turns out we also can't copy / rely on the tab index provided to the signal in any asynchronous context. If the tabs are rearranged, so are their indices. Instead, capture a pointer to the tab of interest - this should be safe as we wouldn't be able to click a tab's audio button if that tab no longer exists. With this change, we can click the audio button from any tab in the Qt chrome, and re-arrange tabs at will. The AppKit and Serenity chromes do not have this issue.
2024-03-30 18:36:26 -04:00
QString BrowserWindow::tool_tip_for_page_mute_state(Tab& tab) const
Ladybird/Qt: Display a tool tip on the tab mute button
2024-03-30 11:10:11 -04:00
{
Ladybird/Qt: Reference the correct tab when handling the audio icon We were errantly always referring to the active tab when the audio play state changed, and when clicking a tab's audio state button, by way of BrowserWindow::view(). It turns out we also can't copy / rely on the tab index provided to the signal in any asynchronous context. If the tabs are rearranged, so are their indices. Instead, capture a pointer to the tab of interest - this should be safe as we wouldn't be able to click a tab's audio button if that tab no longer exists. With this change, we can click the audio button from any tab in the Qt chrome, and re-arrange tabs at will. The AppKit and Serenity chromes do not have this issue.
2024-03-30 18:36:26 -04:00
switch (tab.view().page_mute_state()) {
Ladybird/Qt: Display a tool tip on the tab mute button
2024-03-30 11:10:11 -04:00
case Web::HTML::MuteState::Muted:
return "Unmute tab";
case Web::HTML::MuteState::Unmuted:
return "Mute tab";
}
VERIFY_NOT_REACHED();
}
Ladybird/Qt: Place the tab audio state button on the right on macOS On macOS, the "close tab" button is on the left, so we should place the audio state button on the right to avoid conflict. Rather than an OS ifdef, we do this by detecting if the left side is occupied.
2024-03-30 18:47:50 -04:00
QTabBar::ButtonPosition BrowserWindow::audio_button_position_for_tab(int tab_index) const
{
Ladybird/Qt: Prevent adding multiple audio state buttons If the left-hand side of the tab is already occupied with an audio state button, we would add a second button to the right-hand side. Prevent that by checking if the occupant is our audio state button.
2024-04-02 12:52:03 -04:00
if (auto* button = m_tabs_container->tabBar()->tabButton(tab_index, QTabBar::LeftSide)) {
if (button->objectName() != "LadybirdAudioState")
return QTabBar::RightSide;
}
Ladybird/Qt: Place the tab audio state button on the right on macOS On macOS, the "close tab" button is on the left, so we should place the audio state button on the right to avoid conflict. Rather than an OS ifdef, we do this by detecting if the left side is occupied.
2024-03-30 18:47:50 -04:00
return QTabBar::LeftSide;
}
Ladybird: Switch to next/previous tab with Ctrl+PageDown/PageUp
2022-09-12 09:22:43 +02:00
void BrowserWindow::open_next_tab()
{
if (m_tabs_container->count() <= 1)
return;
auto next_index = m_tabs_container->currentIndex() + 1;
if (next_index >= m_tabs_container->count())
next_index = 0;
m_tabs_container->setCurrentIndex(next_index);
}
void BrowserWindow::open_previous_tab()
{
if (m_tabs_container->count() <= 1)
return;
auto next_index = m_tabs_container->currentIndex() - 1;
if (next_index < 0)
next_index = m_tabs_container->count() - 1;
m_tabs_container->setCurrentIndex(next_index);
}
Ladybird/BrowserWindow: Add UI for switching preferred CSS color scheme
2022-09-19 10:48:02 +02:00
Ladybird: Implement zoom :^)
2023-01-12 14:39:53 +00:00
void BrowserWindow::zoom_in()
{
Ladybird: Show current zoom level in view menu
2023-03-26 18:56:17 +01:00
if (!m_current_tab)
return;
m_current_tab->view().zoom_in();
Ladybird: Add reset zoom level button to toolbar This is a port of the Browser feature.
2023-03-29 00:25:42 +01:00
update_displayed_zoom_level();
Ladybird: Implement zoom :^)
2023-01-12 14:39:53 +00:00
}
void BrowserWindow::zoom_out()
{
Ladybird: Show current zoom level in view menu
2023-03-26 18:56:17 +01:00
if (!m_current_tab)
return;
m_current_tab->view().zoom_out();
Ladybird: Add reset zoom level button to toolbar This is a port of the Browser feature.
2023-03-29 00:25:42 +01:00
update_displayed_zoom_level();
Ladybird: Implement zoom :^)
2023-01-12 14:39:53 +00:00
}
void BrowserWindow::reset_zoom()
{
Ladybird: Show current zoom level in view menu
2023-03-26 18:56:17 +01:00
if (!m_current_tab)
return;
m_current_tab->view().reset_zoom();
Ladybird: Add reset zoom level button to toolbar This is a port of the Browser feature.
2023-03-29 00:25:42 +01:00
update_displayed_zoom_level();
Ladybird: Implement zoom :^)
2023-01-12 14:39:53 +00:00
}
Ladybird: Add "Copy" and "Select All" actions to the Edit menu
2023-01-11 20:09:52 +01:00
Ladybird+Browser: Update zoom text on menu after clicking zoom button
2023-08-04 13:37:52 +02:00
void BrowserWindow::update_zoom_menu()
{
VERIFY(m_zoom_menu);
auto zoom_level_text = MUST(String::formatted("&Zoom ({}%)", round_to<int>(m_current_tab->view().zoom_level() * 100)));
m_zoom_menu->setTitle(qstring_from_ak_string(zoom_level_text));
}
Ladybird/Qt: Add a find in page widget
2024-05-29 20:12:21 +01:00
void BrowserWindow::show_find_in_page()
{
if (!m_current_tab)
return;
m_current_tab->show_find_in_page();
}
Ladybird: Add reset zoom level button to toolbar This is a port of the Browser feature.
2023-03-29 00:25:42 +01:00
void BrowserWindow::update_displayed_zoom_level()
Ladybird: Show current zoom level in view menu
2023-03-26 18:56:17 +01:00
{
Ladybird+Browser: Update zoom text on menu after clicking zoom button
2023-08-04 13:37:52 +02:00
VERIFY(m_current_tab);
update_zoom_menu();
Ladybird: Add reset zoom level button to toolbar This is a port of the Browser feature.
2023-03-29 00:25:42 +01:00
m_current_tab->update_reset_zoom_button();
Ladybird: Show current zoom level in view menu
2023-03-26 18:56:17 +01:00
}
Ladybird: Respect window.open() features in Qt chrome
2024-05-28 13:27:57 -06:00
void BrowserWindow::set_window_rect(Optional<Web::DevicePixels> x, Optional<Web::DevicePixels> y, Optional<Web::DevicePixels> width, Optional<Web::DevicePixels> height)
{
x = x.value_or(0);
y = y.value_or(0);
if (!width.has_value() || width.value() == 0)
width = 800;
if (!height.has_value() || height.value() == 0)
height = 600;
setGeometry(x.value().value(), y.value().value(), width.value().value(), height.value().value());
}
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-26 23:14:41 -05:00
bool BrowserWindow::event(QEvent* event)
{
#if QT_VERSION >= QT_VERSION_CHECK(6, 6, 0)
if (event->type() == QEvent::DevicePixelRatioChange) {
if (m_device_pixel_ratio != devicePixelRatio())
device_pixel_ratio_changed(devicePixelRatio());
}
#endif
Ladybird: Support multiple browser windows in Qt chrome This also moves the ownership of the TaskManger to the Application.
2024-04-26 18:53:55 -06:00
if (event->type() == QEvent::WindowActivate)
LibWebView+UI: Define concrete `Application::the` accessor automatically This avoids assuming that the Qt Application is a QApplication, which will not be the case in an upcoming commit.
2025-06-10 14:50:23 -04:00
Application::the().set_active_window(*this);
Ladybird: Support multiple browser windows in Qt chrome This also moves the ownership of the TaskManger to the Application.
2024-04-26 18:53:55 -06:00
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-26 23:14:41 -05:00
return QMainWindow::event(event);
}
Ladybird: Send window size and position to WebContent process
2023-03-08 23:57:24 +03:00
void BrowserWindow::resizeEvent(QResizeEvent* event)
{
QWidget::resizeEvent(event);
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 09:39:22 -05:00
for_each_tab([&](auto& tab) {
UI/Qt: Send the rect of the window itself to WebContent This ensures that the live values we return to WPT match the requested values.
2024-10-28 15:13:57 -04:00
tab.view().set_window_size({ width(), height() });
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 09:39:22 -05:00
});
Ladybird: Send window size and position to WebContent process
2023-03-08 23:57:24 +03:00
}
void BrowserWindow::moveEvent(QMoveEvent* event)
{
QWidget::moveEvent(event);
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 09:39:22 -05:00
for_each_tab([&](auto& tab) {
UI/Qt: Send the rect of the window itself to WebContent This ensures that the live values we return to WPT match the requested values.
2024-10-28 15:13:57 -04:00
tab.view().set_window_position({ x(), y() });
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 09:39:22 -05:00
});
Ladybird: Send window size and position to WebContent process
2023-03-08 23:57:24 +03:00
}
Ladybird: Add initial support for Ctrl+Scroll to zoom in/out This commit adds basic functionality to zoom in/out using the Ctrl+Scroll shortcut.
2023-06-30 17:33:04 -05:00
void BrowserWindow::wheelEvent(QWheelEvent* event)
{
if ((event->modifiers() & Qt::ControlModifier) != 0) {
if (event->angleDelta().y() > 0)
zoom_in();
else if (event->angleDelta().y() < 0)
zoom_out();
}
}
Ladybird: Close tab clicking wheel of the mouse
2023-02-05 03:26:20 +01:00
bool BrowserWindow::eventFilter(QObject* obj, QEvent* event)
{
if (event->type() == QEvent::MouseButtonRelease) {
auto const* const mouse_event = static_cast<QMouseEvent*>(event);
if (mouse_event->button() == Qt::MouseButton::MiddleButton) {
if (obj == m_tabs_container) {
auto const tab_index = m_tabs_container->tabBar()->tabAt(mouse_event->pos());
UI/Qt: Ignore tab bar middle clicks if the user didn't click on a tab This avoids a segfault that would previously occur when middle clicking to close a tab if only 1 tab was open.
2024-06-28 23:06:58 +01:00
if (tab_index != -1) {
close_tab(tab_index);
return true;
}
Ladybird: Close tab clicking wheel of the mouse
2023-02-05 03:26:20 +01:00
}
}
}
return QMainWindow::eventFilter(obj, event);
}
Ladybird: Move classes and types into the Ladybird namespace We were super inconsistent about this, with most "new" classes living in the Ladybird namespace, while "old" ones were in the global namespace, or even sitting in the Browser namespace.
2023-08-02 11:52:59 -06:00
Ladybird: Remember window position and size on close
2023-08-09 12:23:32 +02:00
void BrowserWindow::closeEvent(QCloseEvent* event)
{
UI/Qt: Don't save size and location of popup windows on exit
2024-07-27 11:38:39 +01:00
if (m_is_popup_window == IsPopupWindow::No) {
Settings::the()->set_last_position(pos());
Settings::the()->set_last_size(size());
Settings::the()->set_is_maximized(isMaximized());
}
Ladybird: Remember window position and size on close
2023-08-09 12:23:32 +02:00
Ladybird: Support multiple browser windows in Qt chrome This also moves the ownership of the TaskManger to the Application.
2024-04-26 18:53:55 -06:00
QObject::deleteLater();
Ladybird: Remember window position and size on close
2023-08-09 12:23:32 +02:00
Ladybird: Support multiple browser windows in Qt chrome This also moves the ownership of the TaskManger to the Application.
2024-04-26 18:53:55 -06:00
QMainWindow::closeEvent(event);
Ladybird: Add a simple TaskManager window for tracking child processes This implementation uses a really basic WebView to update stats once a second. In the future it might make more sense to both move the details into LibWebView, and to create a native widget for each platform to remove the overhead of having an extra WebView.
2024-03-26 11:38:12 -06: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 11:52:59 -06:00
}
Reference in a new issue Copy permalink