dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ladybird/UI/Qt/BrowserWindow.cpp
Timothy Flynn 2773e45db5 UI/Qt: Consistently place the tab close button across platforms 
Before the recent Qt overhaul, we had no control over the position of
the tab close button (without drawing/maintaining it ourselves, which we
now do). Qt automatically placed the tab close button on the left side
of the tab bar on macOS, and as such, we had to go out of our way to
place the audio state button on the right side. See:
dd54780d5e

We now consistently place the audio state button on the left and the tab
close button on the right. Qt still attempts to draw its own tab close
button on the left, so we also explicitly set that to null initially.
2026-05-28 10:33:05 +02:00

1191 lines
41 KiB
C++
Raw Blame History

/*
* Copyright (c) 2022-2023, Andreas Kling <andreas@ladybird.org>
* Copyright (c) 2022, Matthew Costa <ucosty@gmail.com>
* Copyright (c) 2022, Filiph Sandström <filiph.sandstrom@filfatstudios.com>
* Copyright (c) 2023, Linus Groh <linusg@serenityos.org>
* Copyright (c) 2024-2026, Sam Atkins <sam@ladybird.org>
* Copyright (c) 2025, Simon Farre <simon.farre.cx@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/RefPtr.h>
#include <AK/StdLibExtras.h>
#include <AK/TypeCasts.h>
#include <LibWebView/Application.h>
#include <LibWebView/HistoryStore.h>
#include <UI/Qt/Application.h>
#include <UI/Qt/BrowserWindow.h>
#include <UI/Qt/ChromeStyle.h>
#include <UI/Qt/Icon.h>
#include <UI/Qt/Menu.h>
#include <UI/Qt/Settings.h>
#include <UI/Qt/StringUtils.h>
#include <UI/Qt/TabBar.h>
#include <UI/Qt/WebContentView.h>
#include <UI/Qt/WindowControlButton.h>
#include <QAbstractButton>
#include <QAction>
#include <QActionGroup>
#include <QApplication>
#include <QCursor>
#include <QGuiApplication>
#include <QHBoxLayout>
#include <QInputDialog>
#include <QMenuBar>
#include <QMessageBox>
#include <QMouseEvent>
#include <QPropertyAnimation>
#include <QPushButton>
#include <QScreen>
#include <QShortcut>
#include <QStatusBar>
#include <QStyle>
#include <QTabBar>
#include <QTimer>
#include <QWheelEvent>
#include <QWidget>
#include <QWindow>
namespace Ladybird {
static constexpr auto AUDIO_STATE_BUTTON_POSITION = QTabBar::LeftSide;
static constexpr auto TAB_CLOSE_BUTTON_POSITION = QTabBar::RightSide;
static QString reopen_recently_closed_action_text(Optional<WebView::RecentlyClosedEntry const&> entry)
{
if (entry.has_value() && entry->was_window)
return "&Reopen Recently Closed Window";
return "&Reopen Recently Closed Tab";
}
static Vector<URL::URL> recently_closed_urls_for_window(TabWidget const& tabs_container)
{
Vector<URL::URL> urls;
urls.ensure_capacity(tabs_container.count());
for (int index = 0; index < tabs_container.count(); ++index)
urls.append(tabs_container.tab(index)->view().url());
return urls;
}
FullscreenMode::FullscreenMode(BrowserWindow* window, ExitFullscreenButton* exit_button)
: QObject(window)
, m_window(window)
, m_exit_button(exit_button)
{
connect(m_exit_button, &QPushButton::clicked, this, [this]() {
exit(ExitInitiatedBy::UI);
});
}
void FullscreenMode::exit(ExitInitiatedBy initiated_by)
{
if (is_api_fullscreen()) {
qApp->removeEventFilter(this);
if (initiated_by == ExitInitiatedBy::UI && m_window->tab_index(m_fullscreen_tab) != -1) {
m_fullscreen_tab->view().exit_fullscreen();
}
emit on_exit_fullscreen();
}
m_fullscreen_tab = nullptr;
}
void FullscreenMode::enter(Tab* tab)
{
qApp->installEventFilter(this);
m_fullscreen_tab = tab;
m_window->enter_fullscreen();
}
void FullscreenMode::entered_fullscreen()
{
m_debounce = true;
m_exit_button->animate_show();
// Let button float in place 3 * time it takes to animate it in place
QTimer::singleShot(button_animation_time() * 3, [this]() { m_debounce = false; });
}
bool FullscreenMode::is_api_fullscreen() const
{
return m_fullscreen_tab;
}
bool FullscreenMode::debounce() const
{
return m_debounce;
}
void FullscreenMode::maybe_animate_show_exit_button(QPointF pos)
{
u64 const mouse_y = static_cast<u64>(pos.y());
u64 const threshold = static_cast<u64>(m_window->height() * 0.01);
if (debounce()) {
return;
}
// Display the button if the mouse is 1% from the top
if (mouse_y <= threshold) {
if (!m_exit_button->isVisible()) {
m_debounce = true;
m_exit_button->animate_show();
QTimer::singleShot(button_animation_time() * 3, [this]() { m_debounce = false; });
}
} else if (mouse_y > (threshold * 10) && m_exit_button->isVisible()) {
// if the button has floated in, we want to hide it when leaving the top 10%
m_exit_button->hide();
}
}
bool FullscreenMode::eventFilter(QObject* obj, QEvent* event)
{
ASSERT(is_api_fullscreen());
if (event->type() == QEvent::MouseMove) {
QMouseEvent* mouse_event = static_cast<QMouseEvent*>(event);
maybe_animate_show_exit_button(mouse_event->pos());
}
return QObject::eventFilter(obj, event);
}
ExitFullscreenButton::ExitFullscreenButton(QWidget* parent)
: QPushButton("Exit fullscreen", parent)
{
setStyleSheet("background-color:rgb(55, 99, 129); color: white; padding: 10px; border-radius: 5px;");
adjustSize();
hide();
m_widget_animation = new QPropertyAnimation(this, "pos");
}
void ExitFullscreenButton::animate_show()
{
if (isVisible())
return;
show();
QScreen* current_screen = screen();
QRect screen_geometry = current_screen->geometry();
int const destination_x = (screen_geometry.width() - width()) / 2;
int const destination_y = static_cast<int>(static_cast<float>(screen_geometry.height()) * 0.05);
m_widget_animation->setDuration(FullscreenMode::button_animation_time());
m_widget_animation->setStartValue(QPoint(destination_x, -height()));
m_widget_animation->setEndValue(QPoint(destination_x, destination_y));
m_widget_animation->setEasingCurve(QEasingCurve::OutBounce);
m_widget_animation->start();
}
static QIcon const& app_icon()
{
static QIcon icon;
if (icon.isNull()) {
QPixmap pixmap;
pixmap.load(":/Icons/ladybird.png");
icon = QIcon(pixmap);
}
return icon;
}
BrowserWindow::BrowserWindow(Vector<URL::URL> const& initial_urls, IsPopupWindow is_popup_window, Tab* parent_tab, Optional<u64> page_index)
: m_tabs_container(new TabWidget(this))
, m_is_popup_window(is_popup_window)
{
auto const& browser_options = WebView::Application::browser_options();
setWindowFlag(Qt::FramelessWindowHint);
setAttribute(Qt::WA_OpaquePaintEvent);
setWindowIcon(app_icon());
qApp->installEventFilter(this);
// Listen for DPI changes
m_device_pixel_ratio = devicePixelRatio();
m_current_screen = screen();
m_refresh_rate = m_current_screen->refreshRate();
if (QT_VERSION < QT_VERSION_CHECK(6, 6, 0) || QGuiApplication::platformName() != "wayland") {
setAttribute(Qt::WA_NativeWindow);
setAttribute(Qt::WA_DontCreateNativeAncestors);
QObject::connect(m_current_screen, &QScreen::logicalDotsPerInchChanged, this, &BrowserWindow::device_pixel_ratio_changed);
QObject::connect(m_current_screen, &QScreen::refreshRateChanged, this, &BrowserWindow::refresh_rate_changed);
QObject::connect(windowHandle(), &QWindow::screenChanged, this, [this](QScreen* screen) {
if (m_device_pixel_ratio != devicePixelRatio())
device_pixel_ratio_changed(devicePixelRatio());
if (m_refresh_rate != screen->refreshRate())
refresh_rate_changed(screen->refreshRate());
// Listen for logicalDotsPerInchChanged and refreshRateChanged signals on new screen
QObject::disconnect(m_current_screen, &QScreen::logicalDotsPerInchChanged, nullptr, nullptr);
QObject::disconnect(m_current_screen, &QScreen::refreshRateChanged, nullptr, nullptr);
m_current_screen = screen;
QObject::connect(m_current_screen, &QScreen::logicalDotsPerInchChanged, this, &BrowserWindow::device_pixel_ratio_changed);
QObject::connect(m_current_screen, &QScreen::refreshRateChanged, this, &BrowserWindow::refresh_rate_changed);
});
}
m_hamburger_menu = new QMenu(this);
menuBar()->setObjectName("LadybirdMenuBar");
create_menu_bar_window_controls();
update_menu_bar_style();
update_menu_bar_visibility(Settings::the()->show_menubar());
QObject::connect(Settings::the(), &Settings::show_menubar_changed, this, [this](bool show_menubar) {
update_menu_bar_visibility(show_menubar);
});
auto* file_menu = menuBar()->addMenu("&File");
m_new_tab_action = new QAction("New &Tab", this);
m_new_tab_action->setShortcuts(QKeySequence::keyBindings(QKeySequence::StandardKey::AddTab));
m_hamburger_menu->addAction(m_new_tab_action);
file_menu->addAction(m_new_tab_action);
m_new_window_action = new QAction("New &Window", this);
m_new_window_action->setShortcuts(QKeySequence::keyBindings(QKeySequence::StandardKey::New));
m_hamburger_menu->addAction(m_new_window_action);
file_menu->addAction(m_new_window_action);
m_reopen_recently_closed_tab_action = new QAction("&Reopen Recently Closed Tab", this);
m_reopen_recently_closed_tab_action->setShortcut(QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_T));
m_hamburger_menu->addAction(m_reopen_recently_closed_tab_action);
file_menu->addAction(m_reopen_recently_closed_tab_action);
update_reopen_recently_closed_action();
auto* close_current_tab_action = new QAction("&Close Current Tab", this);
close_current_tab_action->setShortcuts(QKeySequence::keyBindings(QKeySequence::StandardKey::Close));
m_hamburger_menu->addAction(close_current_tab_action);
file_menu->addAction(close_current_tab_action);
auto* open_file_action = new QAction("&Open File...", this);
open_file_action->setShortcut(QKeySequence(QKeySequence::StandardKey::Open));
m_hamburger_menu->addAction(open_file_action);
file_menu->addAction(open_file_action);
m_hamburger_menu->addSeparator();
auto* edit_menu = m_hamburger_menu->addMenu("&Edit");
menuBar()->addMenu(edit_menu);
edit_menu->addAction(create_application_action(*this, Application::the().cut_selection_action(), IncludeActionIcon::No));
edit_menu->addAction(create_application_action(*this, Application::the().copy_selection_action(), IncludeActionIcon::No));
edit_menu->addAction(create_application_action(*this, Application::the().paste_action(), IncludeActionIcon::No));
edit_menu->addAction(create_application_action(*this, Application::the().select_all_action(), IncludeActionIcon::No));
edit_menu->addSeparator();
m_find_in_page_action = new QAction("&Find in Page...", this);
m_find_in_page_action->setShortcuts(QKeySequence::keyBindings(QKeySequence::StandardKey::Find));
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();
});
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();
edit_menu->addAction(create_application_action(*edit_menu, Application::the().open_settings_page_action(), IncludeActionIcon::No));
auto* view_menu = m_hamburger_menu->addMenu("&View");
menuBar()->addMenu(view_menu);
auto* open_next_tab_action = new QAction("Open &Next Tab", this);
open_next_tab_action->setShortcuts({ QKeySequence(Qt::CTRL | Qt::Key_PageDown), QKeySequence(Qt::CTRL | Qt::Key_Tab) });
view_menu->addAction(open_next_tab_action);
QObject::connect(open_next_tab_action, &QAction::triggered, this, &BrowserWindow::open_next_tab);
auto* open_previous_tab_action = new QAction("Open &Previous Tab", this);
open_previous_tab_action->setShortcuts({ QKeySequence(Qt::CTRL | Qt::Key_PageUp), QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_Tab) });
view_menu->addAction(open_previous_tab_action);
QObject::connect(open_previous_tab_action, &QAction::triggered, this, &BrowserWindow::open_previous_tab);
view_menu->addSeparator();
view_menu->addMenu(create_application_menu(*view_menu, Application::the().zoom_menu()));
view_menu->addSeparator();
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();
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);
});
m_bookmarks_menu = create_application_menu(*this, Application::the().bookmarks_menu());
m_hamburger_menu->addMenu(m_bookmarks_menu);
menuBar()->addMenu(m_bookmarks_menu);
auto* inspect_menu = create_application_menu(*m_hamburger_menu, Application::the().inspect_menu());
m_hamburger_menu->addMenu(inspect_menu);
menuBar()->addMenu(inspect_menu);
auto* debug_menu = create_application_menu(*m_hamburger_menu, Application::the().debug_menu());
m_hamburger_menu->addMenu(debug_menu);
menuBar()->addMenu(debug_menu);
auto* help_menu = m_hamburger_menu->addMenu("&Help");
menuBar()->addMenu(help_menu);
help_menu->addAction(create_application_action(*help_menu, Application::the().open_about_page_action(), IncludeActionIcon::No));
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);
QObject::connect(m_new_tab_action, &QAction::triggered, this, [this] {
auto& tab = new_tab_from_url(WebView::Application::settings().new_tab_page_url(), Web::HTML::ActivateTab::Yes);
tab.set_url_is_hidden(true);
tab.focus_location_editor();
});
QObject::connect(m_new_window_action, &QAction::triggered, this, [] {
auto const& previous_active_window = Application::the().active_window();
WindowConfiguration configuration {
.width = previous_active_window.width(),
.height = previous_active_window.height(),
.maximized = previous_active_window.isMaximized(),
};
Application::the().new_window({ WebView::Application::settings().new_tab_page_url() }, configuration);
});
QObject::connect(m_reopen_recently_closed_tab_action, &QAction::triggered, this, [this] {
auto recently_closed_entry = Application::history_store().pop_most_recently_closed_entry();
if (recently_closed_entry.has_value()) {
if (recently_closed_entry->was_window) {
auto& window = Application::the().new_window(recently_closed_entry->urls);
window.activate_tab(static_cast<int>(recently_closed_entry->active_tab_index));
} else if (!recently_closed_entry->urls.is_empty()) {
new_tab_from_url(recently_closed_entry->urls[0], Web::HTML::ActivateTab::Yes);
}
}
Application::the().update_reopen_recently_closed_actions();
});
QObject::connect(open_file_action, &QAction::triggered, this, &BrowserWindow::open_file);
m_exit_button = new ExitFullscreenButton { this };
m_fullscreen_mode = new FullscreenMode { this, m_exit_button };
connect(m_fullscreen_mode, &FullscreenMode::on_exit_fullscreen, this, &BrowserWindow::exit_fullscreen);
connect(m_fullscreen_mode, &FullscreenMode::on_exit_fullscreen, m_exit_button, &ExitFullscreenButton::hide);
QObject::connect(m_tabs_container, &TabWidget::current_tab_changed, this, [this](int index) {
auto* tab = m_tabs_container->tab(index);
if (tab)
setWindowTitle(QString("%1 - Ladybird").arg(tab->title()));
set_current_tab(tab);
if (tab) {
if (auto* focus_widget = tab->focusWidget(); focus_widget && tab->isAncestorOf(focus_widget))
focus_widget->setFocus();
else
tab->view().setFocus();
}
fullscreen_mode().exit(FullscreenMode::ExitInitiatedBy::UI);
});
QObject::connect(m_tabs_container, &TabWidget::tab_close_requested, this, &BrowserWindow::request_to_close_tab);
QObject::connect(close_current_tab_action, &QAction::triggered, this, &BrowserWindow::request_to_close_current_tab);
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->set_current_index(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->set_current_index(m_tabs_container->count() - 1);
});
if (parent_tab) {
new_child_tab(Web::HTML::ActivateTab::Yes, *parent_tab, AK::move(page_index));
} else {
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);
}
}
m_tabs_container->set_new_tab_action(m_new_tab_action);
setCentralWidget(m_tabs_container);
setContextMenuPolicy(Qt::PreventContextMenu);
if (browser_options.devtools_port.has_value())
on_devtools_enabled();
}
BrowserWindow::~BrowserWindow()
{
qApp->removeEventFilter(this);
}
void BrowserWindow::rebuild_bookmarks_menu()
{
repopulate_application_menu(*m_bookmarks_menu, *this, Application::the().bookmarks_menu());
for_each_tab([](Tab& tab) {
tab.bookmarks_bar().rebuild();
});
}
void BrowserWindow::update_bookmarks_bar_display(bool show_bookmarks_bar)
{
for_each_tab([&](Tab& tab) {
if (tab.view().is_fullscreen() == Web::ViewportIsFullscreen::No)
tab.bookmarks_bar().setVisible(show_bookmarks_bar);
});
}
void BrowserWindow::on_devtools_enabled()
{
statusBar()->setObjectName("LadybirdStatusBar");
statusBar()->setStyleSheet(ChromeStyle::status_bar_style_sheet(current_tab()->palette()));
auto* disable_button = new QPushButton("Disable", this);
connect(disable_button, &QPushButton::clicked, this, []() {
MUST(WebView::Application::the().toggle_devtools_enabled());
});
statusBar()->addPermanentWidget(disable_button);
statusBar()->showMessage(qformatted("DevTools is enabled on port {}", WebView::Application::browser_options().devtools_port));
}
void BrowserWindow::on_devtools_disabled()
{
setStatusBar(nullptr);
}
Tab& BrowserWindow::new_tab_from_url(URL::URL const& url, Web::HTML::ActivateTab activate_tab)
{
auto& tab = create_new_tab(activate_tab);
tab.navigate(url);
return tab;
}
Tab& BrowserWindow::new_child_tab(Web::HTML::ActivateTab activate_tab, Tab& parent, Optional<u64> page_index)
{
return create_new_tab(activate_tab, parent, page_index);
}
Tab& BrowserWindow::create_new_tab(Web::HTML::ActivateTab activate_tab, Tab& parent, Optional<u64> page_index)
{
if (!page_index.has_value())
return create_new_tab(activate_tab);
auto* tab = new Tab(this, parent.view().client(), page_index.value());
// FIXME: Merge with other overload
if (m_current_tab == nullptr) {
set_current_tab(tab);
}
m_tabs_container->add_tab(tab, "New Tab");
if (activate_tab == Web::HTML::ActivateTab::Yes)
m_tabs_container->set_current_tab(tab);
initialize_tab(tab);
return *tab;
}
FullscreenMode& BrowserWindow::fullscreen_mode()
{
return *m_fullscreen_mode;
}
Tab& BrowserWindow::create_new_tab(Web::HTML::ActivateTab activate_tab)
{
auto* tab = new Tab(this);
if (m_current_tab == nullptr) {
set_current_tab(tab);
}
m_tabs_container->add_tab(tab, "New Tab");
if (activate_tab == Web::HTML::ActivateTab::Yes)
m_tabs_container->set_current_tab(tab);
initialize_tab(tab);
return *tab;
}
void BrowserWindow::initialize_tab(Tab* tab)
{
QObject::connect(tab, &Tab::title_changed, this, &BrowserWindow::tab_title_changed);
QObject::connect(tab, &Tab::favicon_changed, this, &BrowserWindow::tab_favicon_changed);
QObject::connect(tab, &Tab::audio_play_state_changed, this, &BrowserWindow::tab_audio_play_state_changed);
QObject::connect(&tab->view(), &WebContentView::urls_dropped, this, [this](auto& urls) {
VERIFY(urls.size());
m_current_tab->navigate(ak_url_from_qurl(urls[0]));
for (qsizetype i = 1; i < urls.size(); ++i)
new_tab_from_url(ak_url_from_qurl(urls[i]), Web::HTML::ActivateTab::No);
});
tab->view().on_new_web_view = [this, tab](auto activate_tab, Web::HTML::WebViewHints hints, Optional<u64> page_index) {
if (hints.popup) {
WindowConfiguration configuration {
.x = hints.screen_x,
.y = hints.screen_y,
.width = hints.width,
.height = hints.height,
};
auto& window = Application::the().new_window({}, configuration, IsPopupWindow::Yes, tab, AK::move(page_index));
return window.current_tab()->view().handle();
}
auto& new_tab = new_child_tab(activate_tab, *tab, page_index);
return new_tab.view().handle();
};
initialize_tab_buttons(tab);
}
void BrowserWindow::uninitialize_tab(Tab* tab)
{
QObject::disconnect(tab, nullptr, this, nullptr);
QObject::disconnect(&tab->view(), nullptr, this, nullptr);
}
void BrowserWindow::adopt_tab(Tab& tab, int index)
{
index = clamp(index, 0, m_tabs_container->count());
tab.set_window(*this);
m_tabs_container->insert_tab(index, &tab, "New Tab");
initialize_tab(&tab);
tab_title_changed(index, tab.title());
tab.view().set_device_pixel_ratio(m_device_pixel_ratio);
tab.view().set_maximum_frames_per_second(m_refresh_rate);
m_tabs_container->set_current_tab(&tab);
}
void BrowserWindow::move_tab_to_window(int index, BrowserWindow& target_window, int target_index)
{
if (index < 0 || index >= m_tabs_container->count())
return;
if (&target_window == this) {
if (target_index > index)
--target_index;
target_index = clamp(target_index, 0, m_tabs_container->count() - 1);
move_tab(index, target_index);
return;
}
auto* tab = m_tabs_container->tab(index);
uninitialize_tab(tab);
m_tabs_container->take_tab(index);
if (m_current_tab == tab)
set_current_tab(m_tabs_container->count() > 0 ? m_tabs_container->tab(m_tabs_container->current_index()) : nullptr);
target_window.adopt_tab(*tab, target_index);
if (m_tabs_container->count() == 0) {
m_should_record_closed_window_on_close = false;
close();
}
}
void BrowserWindow::detach_tab_to_new_window(int index, QPoint global_position)
{
if (index < 0 || index >= m_tabs_container->count())
return;
WindowConfiguration configuration {
.x = Web::DevicePixels { global_position.x() - 160 },
.y = Web::DevicePixels { global_position.y() - 18 },
.width = Web::DevicePixels { width() },
.height = Web::DevicePixels { height() },
.maximized = isMaximized(),
};
auto& window = Application::the().new_window({}, configuration);
move_tab_to_window(index, window, 0);
}
void BrowserWindow::set_current_tab(Tab* tab)
{
if (tab == m_current_tab)
return;
if (m_current_tab)
m_current_tab->view().set_system_visibility_state(Web::HTML::VisibilityState::Hidden);
m_current_tab = tab;
if (m_current_tab)
m_current_tab->view().set_system_visibility_state(Web::HTML::VisibilityState::Visible);
WebView::Application::the().update_bookmark_action_for_current_web_view();
}
void BrowserWindow::activate_tab(int index)
{
m_tabs_container->set_current_index(index);
}
void BrowserWindow::definitely_close_tab(int index)
{
auto* tab = m_tabs_container->tab(index);
auto url = tab->view().url();
m_tabs_container->remove_tab(index);
Application::history_store().record_closed_tab(url);
Application::the().update_reopen_recently_closed_actions();
tab->deleteLater();
if (m_tabs_container->count() == 0) {
m_should_record_closed_window_on_close = false;
close();
}
}
void BrowserWindow::update_reopen_recently_closed_action()
{
if (!m_reopen_recently_closed_tab_action)
return;
auto recently_closed_entry = Application::history_store().most_recently_closed_entry();
m_reopen_recently_closed_tab_action->setText(reopen_recently_closed_action_text(recently_closed_entry));
m_reopen_recently_closed_tab_action->setEnabled(recently_closed_entry.has_value());
}
void BrowserWindow::move_tab(int old_index, int new_index)
{
m_tabs_container->tab_bar()->moveTab(old_index, new_index);
}
void BrowserWindow::open_file()
{
m_current_tab->open_file();
}
void BrowserWindow::request_to_close_tab(int index)
{
auto* tab = m_tabs_container->tab(index);
tab->request_close();
}
void BrowserWindow::request_to_close_current_tab()
{
request_to_close_tab(m_tabs_container->current_index());
}
int BrowserWindow::tab_index(Tab* tab)
{
return m_tabs_container->index_of(tab);
}
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);
});
}
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);
});
}
void BrowserWindow::tab_title_changed(int index, QString const& title)
{
// 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->set_tab_text(index, title_escaped);
m_tabs_container->set_tab_tooltip(index, title);
if (m_tabs_container->current_index() == index)
setWindowTitle(QString("%1 - Ladybird").arg(title));
}
void BrowserWindow::tab_favicon_changed(int index, QIcon const& icon)
{
if (index < 0)
return;
m_tabs_container->set_tab_icon(index, icon);
}
void BrowserWindow::initialize_tab_buttons(Tab* tab)
{
auto index = m_tabs_container->index_of(tab);
m_tabs_container->set_tab_icon(index, tab->tab_icon());
auto* close_button = new TabBarButton(create_chrome_icon(ChromeIcon::Close, palette()));
close_button->setToolTip("Close Tab");
connect(close_button, &QPushButton::clicked, this, [this, tab]() {
auto index = m_tabs_container->index_of(tab);
request_to_close_tab(index);
});
m_tabs_container->tab_bar()->setTabButton(index, AUDIO_STATE_BUTTON_POSITION, nullptr);
m_tabs_container->tab_bar()->setTabButton(index, TAB_CLOSE_BUTTON_POSITION, close_button);
}
void BrowserWindow::update_tab_close_button_icons()
{
for (int index = 0; index < m_tabs_container->count(); ++index) {
auto* button = m_tabs_container->tab_bar()->tabButton(index, TAB_CLOSE_BUTTON_POSITION);
if (!button || button->objectName() != "LadybirdTabButton")
return;
if (auto* tab_bar_button = qobject_cast<TabBarButton*>(button))
tab_bar_button->setIcon(create_chrome_icon(ChromeIcon::Close, palette()));
}
}
void BrowserWindow::create_menu_bar_window_controls()
{
m_menu_bar_window_controls = new QWidget(menuBar());
m_menu_bar_window_controls->setObjectName("LadybirdMenuBarWindowControls");
auto* layout = new QHBoxLayout(m_menu_bar_window_controls);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
m_menu_bar_minimize_window_button = new WindowControlButton("LadybirdWindowButton", "Minimize", { 16, 16 }, { 40, 30 }, m_menu_bar_window_controls);
m_menu_bar_maximize_window_button = new WindowControlButton("LadybirdWindowButton", "Maximize", { 16, 16 }, { 40, 30 }, m_menu_bar_window_controls);
m_menu_bar_close_window_button = new WindowControlButton("LadybirdCloseWindowButton", "Close", { 16, 16 }, { 40, 30 }, m_menu_bar_window_controls);
layout->addWidget(m_menu_bar_minimize_window_button);
layout->addWidget(m_menu_bar_maximize_window_button);
layout->addWidget(m_menu_bar_close_window_button);
menuBar()->setCornerWidget(m_menu_bar_window_controls, Qt::TopRightCorner);
connect(m_menu_bar_minimize_window_button, &QToolButton::clicked, this, [this] {
showMinimized();
});
connect(m_menu_bar_maximize_window_button, &QToolButton::clicked, this, [this] {
toggle_window_maximized();
});
connect(m_menu_bar_close_window_button, &QToolButton::clicked, this, [this] {
close();
});
update_menu_bar_window_control_icons();
}
void BrowserWindow::update_menu_bar_style()
{
menuBar()->setStyleSheet(ChromeStyle::menu_bar_style_sheet(palette()));
}
void BrowserWindow::update_menu_bar_visibility(bool show_menubar)
{
menuBar()->setVisible(show_menubar);
if (m_menu_bar_window_controls)
m_menu_bar_window_controls->setVisible(show_menubar);
m_tabs_container->set_window_controls_visible(!show_menubar);
}
void BrowserWindow::update_menu_bar_window_control_icons()
{
if (!m_menu_bar_minimize_window_button || !m_menu_bar_maximize_window_button || !m_menu_bar_close_window_button)
return;
auto is_maximized = this->isMaximized();
m_menu_bar_minimize_window_button->setIcon(create_chrome_icon(ChromeIcon::WindowMinimize, palette()));
m_menu_bar_maximize_window_button->setIcon(create_chrome_icon(is_maximized ? ChromeIcon::WindowRestore : ChromeIcon::WindowMaximize, palette()));
m_menu_bar_maximize_window_button->setToolTip(is_maximized ? "Restore" : "Maximize");
m_menu_bar_close_window_button->setIcon(create_chrome_icon(ChromeIcon::WindowClose, palette()));
}
void BrowserWindow::toggle_window_maximized()
{
if (isMaximized())
showNormal();
else
showMaximized();
update_menu_bar_window_control_icons();
}
bool BrowserWindow::start_window_move()
{
auto* handle = windowHandle();
if (!handle)
return false;
return handle->startSystemMove();
}
void BrowserWindow::tab_audio_play_state_changed(int index, Web::HTML::AudioPlayState play_state)
{
auto* tab = m_tabs_container->tab(index);
switch (play_state) {
case Web::HTML::AudioPlayState::Paused:
if (tab->view().page_mute_state() == Web::HTML::MuteState::Unmuted)
m_tabs_container->tab_bar()->setTabButton(index, AUDIO_STATE_BUTTON_POSITION, nullptr);
break;
case Web::HTML::AudioPlayState::Playing:
auto* button = new TabBarButton(icon_for_page_mute_state(*tab));
button->setToolTip(tool_tip_for_page_mute_state(*tab));
button->setObjectName("LadybirdAudioState");
connect(button, &QPushButton::clicked, this, [this, tab]() {
tab->view().toggle_page_mute_state();
auto index = tab_index(tab);
switch (tab->view().audio_play_state()) {
case Web::HTML::AudioPlayState::Paused:
m_tabs_container->tab_bar()->setTabButton(index, AUDIO_STATE_BUTTON_POSITION, nullptr);
break;
case Web::HTML::AudioPlayState::Playing:
auto* button = m_tabs_container->tab_bar()->tabButton(index, AUDIO_STATE_BUTTON_POSITION);
as<TabBarButton>(button)->setIcon(icon_for_page_mute_state(*tab));
button->setToolTip(tool_tip_for_page_mute_state(*tab));
break;
}
});
m_tabs_container->tab_bar()->setTabButton(index, AUDIO_STATE_BUTTON_POSITION, button);
break;
}
}
QIcon BrowserWindow::icon_for_page_mute_state(Tab& tab) const
{
switch (tab.view().page_mute_state()) {
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();
}
QString BrowserWindow::tool_tip_for_page_mute_state(Tab& tab) const
{
switch (tab.view().page_mute_state()) {
case Web::HTML::MuteState::Muted:
return "Unmute tab";
case Web::HTML::MuteState::Unmuted:
return "Mute tab";
}
VERIFY_NOT_REACHED();
}
void BrowserWindow::open_next_tab()
{
if (m_tabs_container->count() <= 1)
return;
auto next_index = m_tabs_container->current_index() + 1;
if (next_index >= m_tabs_container->count())
next_index = 0;
m_tabs_container->set_current_index(next_index);
}
void BrowserWindow::open_previous_tab()
{
if (m_tabs_container->count() <= 1)
return;
auto next_index = m_tabs_container->current_index() - 1;
if (next_index < 0)
next_index = m_tabs_container->count() - 1;
m_tabs_container->set_current_index(next_index);
}
void BrowserWindow::show_find_in_page()
{
if (!m_current_tab)
return;
m_current_tab->show_find_in_page();
}
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());
}
void BrowserWindow::enter_fullscreen()
{
m_tabs_container->set_tab_bar_visible(false);
current_tab()->bookmarks_bar().setVisible(false);
m_restore_to_maximized = isMaximized();
showFullScreen();
}
void BrowserWindow::exit_fullscreen()
{
m_tabs_container->set_tab_bar_visible(true);
current_tab()->bookmarks_bar().setVisible(WebView::Application::settings().show_bookmarks_bar());
if (m_restore_to_maximized)
showMaximized();
else
showNormal();
}
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
if (event->type() == QEvent::WindowActivate)
Application::the().set_active_window(*this);
else if (event->type() == QEvent::WindowDeactivate || event->type() == QEvent::Hide)
clear_resize_cursor();
return QMainWindow::event(event);
}
bool BrowserWindow::eventFilter(QObject* object, QEvent* event)
{
auto* widget = as_if<QWidget>(object);
if (!widget || widget->window() != this)
return QMainWindow::eventFilter(object, event);
auto const is_button = qobject_cast<QAbstractButton*>(object) != nullptr;
if (is_button && (event->type() == QEvent::Enter || event->type() == QEvent::MouseMove || event->type() == QEvent::Leave)) {
clear_resize_cursor();
} else if (event->type() == QEvent::Enter) {
update_resize_cursor(mapFromGlobal(QCursor::pos()));
} else if (event->type() == QEvent::MouseMove) {
auto* mouse_event = static_cast<QMouseEvent*>(event);
update_resize_cursor(widget->mapTo(this, mouse_event->position().toPoint()));
} else if (event->type() == QEvent::Leave) {
auto position = mapFromGlobal(QCursor::pos());
if (rect().contains(position))
update_resize_cursor(position);
else
clear_resize_cursor();
} else if (event->type() != QEvent::MouseButtonPress && event->type() != QEvent::MouseButtonDblClick) {
return QMainWindow::eventFilter(object, event);
}
if (event->type() != QEvent::MouseButtonPress && event->type() != QEvent::MouseButtonDblClick)
return QMainWindow::eventFilter(object, event);
if (is_button)
return QMainWindow::eventFilter(object, event);
auto* mouse_event = static_cast<QMouseEvent*>(event);
if (mouse_event->button() != Qt::LeftButton)
return QMainWindow::eventFilter(object, event);
auto position = widget->mapTo(this, mouse_event->position().toPoint());
if (event->type() == QEvent::MouseButtonPress && !isMaximized() && !isFullScreen()) {
auto edges = resize_edges_for_position(position);
auto* handle = windowHandle();
if (edges != Qt::Edges {} && handle && handle->startSystemResize(edges))
return true;
}
if (isFullScreen() || widget != menuBar() || menuBar()->actionAt(mouse_event->position().toPoint()) != nullptr)
return QMainWindow::eventFilter(object, event);
if (event->type() == QEvent::MouseButtonDblClick) {
toggle_window_maximized();
return true;
}
if (start_window_move())
return true;
return QMainWindow::eventFilter(object, event);
}
Qt::Edges BrowserWindow::resize_edges_for_position(QPoint const& position) const
{
static constexpr int resize_border_width = 6;
Qt::Edges edges;
if (position.x() <= resize_border_width)
edges |= Qt::LeftEdge;
if (position.x() >= width() - resize_border_width)
edges |= Qt::RightEdge;
if (position.y() <= resize_border_width)
edges |= Qt::TopEdge;
if (position.y() >= height() - resize_border_width)
edges |= Qt::BottomEdge;
return edges;
}
Optional<Qt::CursorShape> BrowserWindow::resize_cursor_for_edges(Qt::Edges edges) const
{
if (edges == Qt::Edges {})
return {};
if ((edges & Qt::TopEdge && edges & Qt::LeftEdge) || (edges & Qt::BottomEdge && edges & Qt::RightEdge))
return Qt::SizeFDiagCursor;
if ((edges & Qt::TopEdge && edges & Qt::RightEdge) || (edges & Qt::BottomEdge && edges & Qt::LeftEdge))
return Qt::SizeBDiagCursor;
if (edges & Qt::LeftEdge || edges & Qt::RightEdge)
return Qt::SizeHorCursor;
if (edges & Qt::TopEdge || edges & Qt::BottomEdge)
return Qt::SizeVerCursor;
return {};
}
void BrowserWindow::update_resize_cursor(QPoint const& position)
{
if (isMaximized() || isFullScreen() || !rect().contains(position)) {
clear_resize_cursor();
return;
}
auto cursor_shape = resize_cursor_for_edges(resize_edges_for_position(position));
if (!cursor_shape.has_value()) {
clear_resize_cursor();
return;
}
if (m_resize_cursor_active)
QApplication::changeOverrideCursor(*cursor_shape);
else {
QApplication::setOverrideCursor(*cursor_shape);
m_resize_cursor_active = true;
}
}
void BrowserWindow::clear_resize_cursor()
{
if (!m_resize_cursor_active)
return;
QApplication::restoreOverrideCursor();
m_resize_cursor_active = false;
}
void BrowserWindow::resizeEvent(QResizeEvent* event)
{
QWidget::resizeEvent(event);
for_each_tab([&](auto& tab) {
tab.view().set_window_size({ width(), height() });
});
}
void BrowserWindow::changeEvent(QEvent* event)
{
if (event->type() == QEvent::PaletteChange) {
update_menu_bar_style();
update_menu_bar_window_control_icons();
update_tab_close_button_icons();
} else if (event->type() == QEvent::WindowStateChange) {
update_menu_bar_window_control_icons();
QWindowStateChangeEvent* stateChangeEvent = static_cast<QWindowStateChangeEvent*>(event);
bool was_fullscreen = stateChangeEvent->oldState() & Qt::WindowFullScreen;
bool is_fullscreen = windowState() & Qt::WindowFullScreen;
if (is_fullscreen && !was_fullscreen) {
m_fullscreen_mode->entered_fullscreen();
if (m_fullscreen_mode->is_api_fullscreen())
view().set_is_fullscreen(Web::ViewportIsFullscreen::Yes);
} else if (!is_fullscreen && was_fullscreen) {
view().set_is_fullscreen(Web::ViewportIsFullscreen::No);
}
}
QWidget::changeEvent(event);
}
void BrowserWindow::moveEvent(QMoveEvent* event)
{
QWidget::moveEvent(event);
for_each_tab([&](auto& tab) {
tab.view().set_window_position({ x(), y() });
});
}
void BrowserWindow::wheelEvent(QWheelEvent* event)
{
if (!m_current_tab)
return;
if ((event->modifiers() & Qt::ControlModifier) != 0) {
if (event->angleDelta().y() > 0)
m_current_tab->view().zoom_in();
else if (event->angleDelta().y() < 0)
m_current_tab->view().zoom_out();
}
}
void BrowserWindow::closeEvent(QCloseEvent* event)
{
clear_resize_cursor();
Optional<Vector<URL::URL>> recently_closed_window_urls;
size_t recently_closed_window_active_tab_index { 0 };
if (m_should_record_closed_window_on_close && m_tabs_container->count() > 0) {
recently_closed_window_urls = recently_closed_urls_for_window(*m_tabs_container);
recently_closed_window_active_tab_index = static_cast<size_t>(m_tabs_container->current_index());
}
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());
}
QObject::deleteLater();
QMainWindow::closeEvent(event);
if (event->isAccepted() && recently_closed_window_urls.has_value()) {
Application::history_store().record_closed_window(recently_closed_window_urls.release_value(), recently_closed_window_active_tab_index);
Application::the().update_reopen_recently_closed_actions();
}
}
}
Reference in a new issue View git blame Copy permalink