#include "panels/folders/folderspanel.h"
#include "panels/places/placesitemmodel.h"
#include "panels/places/placespanel.h"
-#include "panels/information/informationpanel.h"
#include "panels/terminal/terminalpanel.h"
#include "settings/dolphinsettingsdialog.h"
#include "statusbar/dolphinstatusbar.h"
#include <KStandardAction>
#include <KStartupInfo>
#include <KSycoca>
+#include <KTerminalLauncherJob>
#include <KToggleAction>
#include <KToolBar>
#include <KToolBarPopupAction>
-#include <KToolInvocation>
#include <KUrlComboBox>
#include <KUrlNavigator>
#include <KWindowSystem>
+#include <KXMLGUIFactory>
+
+#include <kio_version.h>
#include <QApplication>
#include <QClipboard>
#include <QCloseEvent>
#include <QDesktopServices>
#include <QDialog>
+#include <QDomDocument>
#include <QFileInfo>
#include <QLineEdit>
#include <QMenuBar>
namespace {
// Used for GeneralSettings::version() to determine whether
// an updated version of Dolphin is running.
- const int CurrentDolphinVersion = 200;
+ const int CurrentDolphinVersion = 201;
// The maximum number of entries in the back/forward popup menu
const int MaxNumberOfNavigationentries = 12;
// The maximum number of "Activate Tab" shortcuts
if (firstRun) {
menuBar()->setVisible(false);
- // Assure a proper default size if Dolphin runs the first time
- resize(750, 500);
}
const bool showMenu = !menuBar()->isHidden();
QAction* showMenuBarAction = actionCollection()->action(KStandardAction::name(KStandardAction::ShowMenubar));
showMenuBarAction->setChecked(showMenu); // workaround for bug #171080
- if (!showMenu) {
- createControlButton();
+
+ auto hamburgerMenu = static_cast<KHamburgerMenu *>(actionCollection()->action(
+ KStandardAction::name(KStandardAction::HamburgerMenu)));
+ hamburgerMenu->setMenuBar(menuBar());
+ hamburgerMenu->setShowMenuBarAction(showMenuBarAction);
+ connect(hamburgerMenu, &KHamburgerMenu::aboutToShowMenu,
+ this, &DolphinMainWindow::updateHamburgerMenu);
+ hamburgerMenu->hideActionsOf(toolBar());
+ if (GeneralSettings::version() < 201 && !toolBar()->actions().contains(hamburgerMenu)) {
+ addHamburgerMenuToToolbar();
}
updateAllowedToolbarAreas();
connect(KSycoca::self(), QOverload<>::of(&KSycoca::databaseChanged), this, &DolphinMainWindow::updateOpenPreferredSearchToolAction);
QTimer::singleShot(0, this, &DolphinMainWindow::updateOpenPreferredSearchToolAction);
+
+ m_fileItemActions.setParentWidget(this);
+ connect(&m_fileItemActions, &KFileItemActions::error, this, [this](const QString &errorMessage) {
+ showErrorMessage(errorMessage);
+ });
}
DolphinMainWindow::~DolphinMainWindow()
{
+ // This fixes a crash on Wayland when closing the mainwindow while another dialog is open.
+ disconnect(QGuiApplication::clipboard(), &QClipboard::dataChanged, this, &DolphinMainWindow::updatePasteAction);
}
QVector<DolphinViewContainer*> DolphinMainWindow::viewContainers() const
return viewContainers;
}
-void DolphinMainWindow::setViewsWithInvalidPathsToHome()
-{
- const QVector<DolphinViewContainer*> theViewContainers = viewContainers();
- for (DolphinViewContainer *viewContainer : theViewContainers) {
-
- // Only consider local dirs, not remote locations and abstract protocols
- if (viewContainer->url().isLocalFile()) {
- if (!QFileInfo::exists(viewContainer->url().toLocalFile())) {
- viewContainer->setUrl(QUrl::fromLocalFile(QDir::homePath()));
- }
- }
- }
-}
-
void DolphinMainWindow::openDirectories(const QList<QUrl>& dirs, bool splitView)
{
m_tabWidget->openDirectories(dirs, splitView);
bool DolphinMainWindow::isInformationPanelEnabled() const
{
+#ifdef HAVE_BALOO
return actionCollection()->action(QStringLiteral("show_information_panel"))->isChecked();
+#else
+ return false;
+#endif
}
void DolphinMainWindow::openFiles(const QStringList& files, bool splitView)
void DolphinMainWindow::openNewActivatedTab()
{
+ // keep browsers compatibility, new tab is always after last one
+ auto openNewTabAfterLastTabConfigured = GeneralSettings::openNewTabAfterLastTab();
+ GeneralSettings::setOpenNewTabAfterLastTab(true);
m_tabWidget->openNewActivatedTab();
+ GeneralSettings::setOpenNewTabAfterLastTab(openNewTabAfterLastTabConfigured);
}
void DolphinMainWindow::addToPlaces()
}
}
-void DolphinMainWindow::openNewTab(const QUrl& url, DolphinTabWidget::TabPlacement tabPlacement)
-{
- m_tabWidget->openNewTab(url, QUrl(), tabPlacement);
-}
-
-void DolphinMainWindow::openNewTabAfterCurrentTab(const QUrl& url)
-{
- m_tabWidget->openNewTab(url, QUrl(), DolphinTabWidget::AfterCurrentTab);
-}
-
-void DolphinMainWindow::openNewTabAfterLastTab(const QUrl& url)
+void DolphinMainWindow::openNewTab(const QUrl& url)
{
- m_tabWidget->openNewTab(url, QUrl(), DolphinTabWidget::AfterLastTab);
+ m_tabWidget->openNewTab(url, QUrl());
}
void DolphinMainWindow::openInNewTab()
for (const KFileItem& item : list) {
const QUrl& url = DolphinView::openItemAsFolderUrl(item);
if (!url.isEmpty()) {
- openNewTabAfterCurrentTab(url);
+ openNewTab(url);
tabCreated = true;
}
}
// if no new tab has been created from the selection
// open the current directory in a new tab
if (!tabCreated) {
- openNewTabAfterCurrentTab(m_activeViewContainer->url());
+ openNewTab(m_activeViewContainer->url());
}
}
{
if (action) {
const KUrlNavigator *urlNavigator = activeViewContainer()->urlNavigatorInternalWithHistory();
- openNewTabAfterCurrentTab(urlNavigator->locationUrl(action->data().value<int>()));
+ openNewTab(urlNavigator->locationUrl(action->data().value<int>()));
}
}
void DolphinMainWindow::toggleSplitView()
{
DolphinTabPage* tabPage = m_tabWidget->currentTabPage();
- tabPage->setSplitViewEnabled(!tabPage->splitViewEnabled());
+ tabPage->setSplitViewEnabled(!tabPage->splitViewEnabled(), WithAnimation);
updateViewActions();
}
void DolphinMainWindow::toggleSplitStash()
{
DolphinTabPage* tabPage = m_tabWidget->currentTabPage();
- tabPage->setSplitViewEnabled(false);
- tabPage->setSplitViewEnabled(true, QUrl("stash:/"));
+ tabPage->setSplitViewEnabled(false, WithAnimation);
+ tabPage->setSplitViewEnabled(true, WithAnimation, QUrl("stash:/"));
}
void DolphinMainWindow::reloadView()
{
const KUrlNavigator* urlNavigator = activeViewContainer()->urlNavigatorInternalWithHistory();
const int index = urlNavigator->historyIndex() + 1;
- openNewTabAfterCurrentTab(urlNavigator->locationUrl(index));
+ openNewTab(urlNavigator->locationUrl(index));
}
void DolphinMainWindow::goForwardInNewTab()
{
const KUrlNavigator* urlNavigator = activeViewContainer()->urlNavigatorInternalWithHistory();
const int index = urlNavigator->historyIndex() - 1;
- openNewTabAfterCurrentTab(urlNavigator->locationUrl(index));
+ openNewTab(urlNavigator->locationUrl(index));
}
void DolphinMainWindow::goUpInNewTab()
{
const QUrl currentUrl = activeViewContainer()->urlNavigator()->locationUrl();
- openNewTabAfterCurrentTab(KIO::upUrl(currentUrl));
+ openNewTab(KIO::upUrl(currentUrl));
}
void DolphinMainWindow::goHomeInNewTab()
{
- openNewTabAfterCurrentTab(Dolphin::homeUrl());
+ openNewTab(Dolphin::homeUrl());
}
void DolphinMainWindow::compareFiles()
{
const bool visible = menuBar()->isVisible();
menuBar()->setVisible(!visible);
- if (visible) {
- createControlButton();
- } else {
- deleteControlButton();
- }
}
QPointer<QAction> DolphinMainWindow::preferredSearchTool()
const QUrl url = m_activeViewContainer->url();
if (url.isLocalFile()) {
- KToolInvocation::invokeTerminal(QString(), url.toLocalFile());
+ auto job = new KTerminalLauncherJob(QString());
+ job->setWorkingDirectory(url.toLocalFile());
+ job->start();
return;
}
statUrl = job->mostLocalUrl();
}
- KToolInvocation::invokeTerminal(QString(), statUrl.isLocalFile() ? statUrl.toLocalFile() : QDir::homePath());
+ auto job = new KTerminalLauncherJob(QString());
+ job->setWorkingDirectory(statUrl.isLocalFile() ? statUrl.toLocalFile() : QDir::homePath());
+ job->start();
});
return;
}
// Nothing worked, just use $HOME
- KToolInvocation::invokeTerminal(QString(), QDir::homePath());
+ auto job = new KTerminalLauncherJob(QString());
+ job->setWorkingDirectory(QDir::homePath());
+ job->start();
}
void DolphinMainWindow::editSettings()
container->view()->writeSettings();
const QUrl url = container->url();
- DolphinSettingsDialog* settingsDialog = new DolphinSettingsDialog(url, this);
+ DolphinSettingsDialog* settingsDialog = new DolphinSettingsDialog(url, this, actionCollection());
connect(settingsDialog, &DolphinSettingsDialog::settingsChanged, this, &DolphinMainWindow::refreshViews);
connect(settingsDialog, &DolphinSettingsDialog::settingsChanged,
&DolphinUrlNavigatorsController::slotReadSettings);
const QUrl& url,
const QList<QAction*>& customActions)
{
- QPointer<DolphinContextMenu> contextMenu = new DolphinContextMenu(this, pos, item, url);
+ QPointer<DolphinContextMenu> contextMenu = new DolphinContextMenu(this, pos, item, url, &m_fileItemActions);
contextMenu.data()->setCustomActions(customActions);
const DolphinContextMenu::Command command = contextMenu.data()->open();
break;
case DolphinContextMenu::OpenParentFolderInNewTab:
- openNewTabAfterLastTab(KIO::upUrl(item.url()));
+ openNewTab(KIO::upUrl(item.url()));
break;
case DolphinContextMenu::None:
}
}
-void DolphinMainWindow::updateControlMenu()
+void DolphinMainWindow::updateHamburgerMenu()
{
- QMenu* menu = qobject_cast<QMenu*>(sender());
- Q_ASSERT(menu);
-
- // All actions get cleared by QMenu::clear(). This includes the sub-menus
- // because 'menu' is their parent.
- menu->clear();
-
KActionCollection* ac = actionCollection();
-
- menu->addMenu(m_newFileMenu->menu());
- addActionToMenu(ac->action(QStringLiteral("file_new")), menu);
- addActionToMenu(ac->action(QStringLiteral("new_tab")), menu);
- addActionToMenu(ac->action(QStringLiteral("closed_tabs")), menu);
-
- menu->addSeparator();
-
- // Add "Edit" actions
- bool added = addActionToMenu(ac->action(KStandardAction::name(KStandardAction::Undo)), menu) |
- addActionToMenu(ac->action(QString("copy_location")), menu) |
- addActionToMenu(ac->action(QStringLiteral("copy_to_inactive_split_view")), menu) |
- addActionToMenu(ac->action(QStringLiteral("move_to_inactive_split_view")), menu) |
- addActionToMenu(ac->action(KStandardAction::name(KStandardAction::SelectAll)), menu) |
- addActionToMenu(ac->action(QStringLiteral("invert_selection")), menu);
-
- if (added) {
- menu->addSeparator();
+ auto hamburgerMenu = static_cast<KHamburgerMenu *>(
+ ac->action(KStandardAction::name(KStandardAction::HamburgerMenu)));
+ auto menu = hamburgerMenu->menu();
+ if (!menu) {
+ menu = new QMenu(this);
+ hamburgerMenu->setMenu(menu);
+ hamburgerMenu->hideActionsOf(ac->action(QStringLiteral("basic_actions"))->menu());
+ hamburgerMenu->hideActionsOf(ac->action(QStringLiteral("zoom"))->menu());
+ } else {
+ menu->clear();
}
+ const QList<QAction *> toolbarActions = toolBar()->actions();
- // Add "View" actions
- if (!GeneralSettings::showZoomSlider()) {
- addActionToMenu(ac->action(KStandardAction::name(KStandardAction::ZoomIn)), menu);
- addActionToMenu(ac->action(QStringLiteral("view_zoom_reset")), menu);
- addActionToMenu(ac->action(KStandardAction::name(KStandardAction::ZoomOut)), menu);
+ if (!toolBar()->isVisible()) {
+ // If neither the menu bar nor the toolbar are visible, these actions should be available.
+ menu->addAction(ac->action(KStandardAction::name(KStandardAction::ShowMenubar)));
+ menu->addAction(toolBarMenuAction());
menu->addSeparator();
}
- added = addActionToMenu(ac->action(QStringLiteral("show_preview")), menu) |
- addActionToMenu(ac->action(QStringLiteral("show_in_groups")), menu) |
- addActionToMenu(ac->action(QStringLiteral("show_hidden_files")), menu) |
- addActionToMenu(ac->action(QStringLiteral("additional_info")), menu) |
- addActionToMenu(ac->action(QStringLiteral("view_properties")), menu);
+ // This group of actions (until the next separator) contains all the most basic actions
+ // necessary to use Dolphin effectively.
+ menu->addAction(ac->action(QStringLiteral("go_back")));
+ menu->addAction(ac->action(QStringLiteral("go_forward")));
- if (added) {
- menu->addSeparator();
+ menu->addMenu(m_newFileMenu->menu());
+ menu->addAction(ac->action(QStringLiteral("basic_actions")));
+ menu->addAction(ac->action(KStandardAction::name(KStandardAction::Undo)));
+ if (!toolBar()->isVisible()
+ || (!toolbarActions.contains(ac->action(QStringLiteral("toggle_search")))
+ && !toolbarActions.contains(ac->action(QStringLiteral("open_preferred_search_tool"))))
+ ) {
+ menu->addAction(ac->action(KStandardAction::name(KStandardAction::Find)));
+ // This way a search action will only be added if none of the three available
+ // search actions is present on the toolbar.
+ }
+ if (!toolBar()->isVisible()
+ || !toolbarActions.contains(ac->action(QStringLiteral("toggle_filter")))
+ ) {
+ menu->addAction(ac->action(QStringLiteral("show_filter_bar")));
+ // This way a filter action will only be added if none of the two available
+ // filter actions is present on the toolbar.
}
-
- // Add a curated assortment of items from the "Tools" menu
- addActionToMenu(ac->action(QStringLiteral("show_filter_bar")), menu);
- addActionToMenu(ac->action(QStringLiteral("open_preferred_search_tool")), menu);
- addActionToMenu(ac->action(QStringLiteral("open_terminal")), menu);
-
menu->addSeparator();
- // Add "Show Panels" menu
- addActionToMenu(ac->action(QStringLiteral("panels")), menu);
-
- // Add "Settings" menu entries
- addActionToMenu(ac->action(KStandardAction::name(KStandardAction::KeyBindings)), menu);
- addActionToMenu(ac->action(KStandardAction::name(KStandardAction::ConfigureToolbars)), menu);
- addActionToMenu(ac->action(KStandardAction::name(KStandardAction::Preferences)), menu);
- addActionToMenu(ac->action(KStandardAction::name(KStandardAction::ShowMenubar)), menu);
-
- // Add "Help" menu
- auto helpMenu = m_helpMenu->menu();
- helpMenu->setIcon(QIcon::fromTheme(QStringLiteral("system-help")));
- menu->addMenu(helpMenu);
-}
-
-void DolphinMainWindow::updateToolBar()
-{
- if (!menuBar()->isVisible()) {
- createControlButton();
+ // The second group of actions (up until the next separator) contains actions for opening
+ // additional views to interact with the file system.
+ menu->addAction(ac->action(QStringLiteral("file_new")));
+ menu->addAction(ac->action(QStringLiteral("new_tab")));
+ if (ac->action(QStringLiteral("undo_close_tab"))->isEnabled()) {
+ menu->addAction(ac->action(QStringLiteral("closed_tabs")));
}
-}
+ menu->addAction(ac->action(QStringLiteral("open_terminal")));
+ menu->addSeparator();
-void DolphinMainWindow::slotControlButtonDeleted()
-{
- m_controlButton = nullptr;
- m_updateToolBarTimer->start();
+ // The third group contains actions to change what one sees in the view
+ // and to change the more general UI.
+ if (!toolBar()->isVisible()
+ || (!toolbarActions.contains(ac->action(QStringLiteral("icons")))
+ && !toolbarActions.contains(ac->action(QStringLiteral("compact")))
+ && !toolbarActions.contains(ac->action(QStringLiteral("details")))
+ && !toolbarActions.contains(ac->action(QStringLiteral("view_mode"))))
+ ) {
+ menu->addAction(ac->action(QStringLiteral("view_mode")));
+ }
+ menu->addAction(ac->action(QStringLiteral("show_hidden_files")));
+ menu->addAction(ac->action(QStringLiteral("sort")));
+ menu->addAction(ac->action(QStringLiteral("additional_info")));
+ if (!GeneralSettings::showStatusBar() || !GeneralSettings::showZoomSlider()) {
+ menu->addAction(ac->action(QStringLiteral("zoom")));
+ }
+ menu->addAction(ac->action(QStringLiteral("panels")));
+
+ // The "Configure" menu is not added to the actionCollection() because there is hardly
+ // a good reason for users to put it on their toolbar.
+ auto configureMenu = menu->addMenu(QIcon::fromTheme(QStringLiteral("configure")),
+ i18nc("@action:inmenu menu for configure actions", "Configure"));
+ configureMenu->addAction(ac->action(KStandardAction::name(KStandardAction::SwitchApplicationLanguage)));
+ configureMenu->addAction(ac->action(KStandardAction::name(KStandardAction::KeyBindings)));
+ configureMenu->addAction(ac->action(KStandardAction::name(KStandardAction::ConfigureToolbars)));
+ configureMenu->addAction(ac->action(KStandardAction::name(KStandardAction::Preferences)));
+ hamburgerMenu->hideActionsOf(configureMenu);
}
void DolphinMainWindow::slotPlaceActivated(const QUrl& url)
// which had been unmounted earlier, see https://bugs.kde.org/show_bug.cgi?id=161385.
reloadView();
} else {
+ view->disableUrlNavigatorSelectionRequests();
changeUrl(url);
+ view->enableUrlNavigatorSelectionRequests();
}
}
// view and url navigator) and main window.
oldViewContainer->disconnect(this);
oldViewContainer->view()->disconnect(this);
+ oldViewContainer->urlNavigatorInternalWithHistory()->disconnect(this);
auto navigators = static_cast<DolphinNavigatorsWidgetAction *>
(actionCollection()->action(QStringLiteral("url_navigators")));
navigators->primaryUrlNavigator()->disconnect(this);
void DolphinMainWindow::setupActions()
{
+ KStandardAction::hamburgerMenu(nullptr, nullptr, actionCollection());
+
// setup 'File' menu
m_newFileMenu = new DolphinNewFileMenu(actionCollection(), this);
QMenu* menu = m_newFileMenu->menu();
menu->setTitle(i18nc("@title:menu Create new folder, file, link, etc.", "Create New"));
- menu->setIcon(QIcon::fromTheme(QStringLiteral("document-new")));
- m_newFileMenu->setDelayed(false);
+ menu->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));
+ m_newFileMenu->setPopupMode(QToolButton::InstantPopup);
connect(menu, &QMenu::aboutToShow,
this, &DolphinMainWindow::updateNewMenu);
stashSplit->setToolTip(i18nc("@info", "Opens the stash virtual directory in a split window"));
stashSplit->setIcon(QIcon::fromTheme(QStringLiteral("folder-stash")));
stashSplit->setCheckable(false);
- stashSplit->setVisible(QDBusConnection::sessionBus().interface()->isServiceRegistered(QStringLiteral("org.kde.kio.StashNotifier")));
+ QDBusConnectionInterface *sessionInterface = QDBusConnection::sessionBus().interface();
+ stashSplit->setVisible(sessionInterface && sessionInterface->isServiceRegistered(QStringLiteral("org.kde.kio.StashNotifier")));
connect(stashSplit, &QAction::triggered, this, &DolphinMainWindow::toggleSplitStash);
KStandardAction::redisplay(this, &DolphinMainWindow::reloadView, actionCollection());
m_backAction->setObjectName(backAction->objectName());
m_backAction->setShortcuts(backAction->shortcuts());
}
- m_backAction->setDelayed(true);
- m_backAction->setStickyMenu(false);
+ m_backAction->setPopupMode(QToolButton::DelayedPopup);
connect(m_backAction, &QAction::triggered, this, &DolphinMainWindow::goBack);
connect(m_backAction->menu(), &QMenu::aboutToShow, this, &DolphinMainWindow::slotAboutToShowBackPopupMenu);
connect(m_backAction->menu(), &QMenu::triggered, this, &DolphinMainWindow::slotGoBack);
m_forwardAction->setObjectName(forwardAction->objectName());
m_forwardAction->setShortcuts(forwardAction->shortcuts());
}
- m_forwardAction->setDelayed(true);
- m_forwardAction->setStickyMenu(false);
+ m_forwardAction->setPopupMode(QToolButton::DelayedPopup);
connect(m_forwardAction, &QAction::triggered, this, &DolphinMainWindow::goForward);
connect(m_forwardAction->menu(), &QMenu::aboutToShow, this, &DolphinMainWindow::slotAboutToShowForwardPopupMenu);
connect(m_forwardAction->menu(), &QMenu::triggered, this, &DolphinMainWindow::slotGoForward);
KActionMenu *bookmarkMenu = new KActionMenu(i18nc("@title:menu", "&Bookmarks"), this);
bookmarkMenu->setIcon(QIcon::fromTheme(QStringLiteral("bookmarks")));
// Make the toolbar button version work properly on click
- bookmarkMenu->setDelayed(false);
+ bookmarkMenu->setPopupMode(QToolButton::InstantPopup);
m_bookmarkHandler = new DolphinBookmarkHandler(this, actionCollection(), bookmarkMenu->menu(), this);
actionCollection()->addAction(QStringLiteral("bookmarks"), bookmarkMenu);
m_helpMenu = new KHelpMenu(nullptr);
m_helpMenu->menu()->installEventFilter(this);
// remove duplicate shortcuts
- m_helpMenu->action(KHelpMenu::menuHelpContents)->setShortcut(QKeySequence());
- m_helpMenu->action(KHelpMenu::menuWhatsThis)->setShortcut(QKeySequence());
+ auto removeHelpActionShortcut = [this](KHelpMenu::MenuId menuId) {
+ if (auto *action = m_helpMenu->action(menuId)) {
+ action->setShortcut(QKeySequence());
+ }
+ };
+ removeHelpActionShortcut(KHelpMenu::menuHelpContents);
+ removeHelpActionShortcut(KHelpMenu::menuWhatsThis);
// not in menu actions
QList<QKeySequence> nextTabKeys = KStandardShortcut::tabNext();
infoPanel, &InformationPanel::setSelection);
connect(this, &DolphinMainWindow::requestItemInfo,
infoPanel, &InformationPanel::requestDelayedItemInfo);
+ connect(this, &DolphinMainWindow::fileItemsChanged,
+ infoPanel, &InformationPanel::slotFilesItemChanged);
#endif
// i18n: This is the last paragraph for the "What's This"-texts of all four panels.
connect(foldersPanel, &FoldersPanel::folderActivated,
this, &DolphinMainWindow::changeUrl);
connect(foldersPanel, &FoldersPanel::folderMiddleClicked,
- this, &DolphinMainWindow::openNewTabAfterCurrentTab);
+ this, &DolphinMainWindow::openNewTab);
connect(foldersPanel, &FoldersPanel::errorMessage,
this, &DolphinMainWindow::showErrorMessage);
placesDock->setWidget(m_placesPanel);
QAction *placesAction = placesDock->toggleViewAction();
- createPanelAction(QIcon::fromTheme(QStringLiteral("bookmarks")), Qt::Key_F9, placesAction, QStringLiteral("show_places_panel"));
+ createPanelAction(QIcon::fromTheme(QStringLiteral("compass")), Qt::Key_F9, placesAction, QStringLiteral("show_places_panel"));
addDockWidget(Qt::LeftDockWidgetArea, placesDock);
connect(m_placesPanel, &PlacesPanel::placeActivated,
this, &DolphinMainWindow::slotPlaceActivated);
connect(m_placesPanel, &PlacesPanel::placeMiddleClicked,
- this, &DolphinMainWindow::openNewTabAfterCurrentTab);
+ this, &DolphinMainWindow::openNewTab);
connect(m_placesPanel, &PlacesPanel::errorMessage,
this, &DolphinMainWindow::showErrorMessage);
connect(this, &DolphinMainWindow::urlChanged,
KActionMenu* panelsMenu = new KActionMenu(i18nc("@action:inmenu View", "Show Panels"), this);
actionCollection()->addAction(QStringLiteral("panels"), panelsMenu);
panelsMenu->setIcon(QIcon::fromTheme(QStringLiteral("view-sidetree")));
- panelsMenu->setDelayed(false);
+ panelsMenu->setPopupMode(QToolButton::InstantPopup);
const KActionCollection* ac = actionCollection();
panelsMenu->addAction(ac->action(QStringLiteral("show_places_panel")));
#ifdef HAVE_BALOO
goUpAction->setEnabled(KIO::upUrl(currentUrl) != currentUrl);
}
-void DolphinMainWindow::createControlButton()
-{
- if (m_controlButton) {
- return;
- }
- Q_ASSERT(!m_controlButton);
-
- m_controlButton = new QToolButton(this);
- m_controlButton->setAccessibleName(i18nc("@action:intoolbar", "Control"));
- m_controlButton->setIcon(QIcon::fromTheme(QStringLiteral("application-menu")));
- m_controlButton->setToolTip(i18nc("@action", "Show menu"));
- m_controlButton->setAttribute(Qt::WidgetAttribute::WA_CustomWhatsThis);
- m_controlButton->setPopupMode(QToolButton::InstantPopup);
-
- QMenu* controlMenu = new QMenu(m_controlButton);
- connect(controlMenu, &QMenu::aboutToShow, this, &DolphinMainWindow::updateControlMenu);
- controlMenu->installEventFilter(this);
-
- m_controlButton->setMenu(controlMenu);
-
- toolBar()->addWidget(m_controlButton);
- connect(toolBar(), &KToolBar::iconSizeChanged,
- m_controlButton, &QToolButton::setIconSize);
-
- // The added widgets are owned by the toolbar and may get deleted when e.g. the toolbar
- // gets edited. In this case we must add them again. The adding is done asynchronously by
- // m_updateToolBarTimer.
- connect(m_controlButton, &QToolButton::destroyed, this, &DolphinMainWindow::slotControlButtonDeleted);
- m_updateToolBarTimer = new QTimer(this);
- m_updateToolBarTimer->setInterval(500);
- connect(m_updateToolBarTimer, &QTimer::timeout, this, &DolphinMainWindow::updateToolBar);
-}
-
-void DolphinMainWindow::deleteControlButton()
-{
- delete m_controlButton;
- m_controlButton = nullptr;
-
- delete m_updateToolBarTimer;
- m_updateToolBarTimer = nullptr;
-}
-
-bool DolphinMainWindow::addActionToMenu(QAction* action, QMenu* menu)
-{
- Q_ASSERT(action);
- Q_ASSERT(menu);
-
- const KToolBar* toolBarWidget = toolBar();
- const auto associatedWidgets = action->associatedWidgets();
- for (const QWidget* widget : associatedWidgets) {
- if (widget == toolBarWidget) {
- return false;
- }
- }
-
- menu->addAction(action);
- return true;
-}
-
void DolphinMainWindow::refreshViews()
{
m_tabWidget->refreshViews();
// The startup settings have been changed by the user (see bug #254947).
// Synchronize the split-view setting with the active view:
const bool splitView = GeneralSettings::splitView();
- m_tabWidget->currentTabPage()->setSplitViewEnabled(splitView);
+ m_tabWidget->currentTabPage()->setSplitViewEnabled(splitView, WithAnimation);
updateSplitAction();
updateWindowTitle();
}
this, &DolphinMainWindow::slotSelectionChanged);
connect(view, &DolphinView::requestItemInfo,
this, &DolphinMainWindow::requestItemInfo);
+ connect(view, &DolphinView::fileItemsChanged,
+ this, &DolphinMainWindow::fileItemsChanged);
connect(view, &DolphinView::tabRequested,
this, &DolphinMainWindow::openNewTab);
connect(view, &DolphinView::requestContextMenu,
connect(view, &DolphinView::goUpRequested,
this, &DolphinMainWindow::goUp);
+ connect(container->urlNavigatorInternalWithHistory(), &KUrlNavigator::urlChanged,
+ this, &DolphinMainWindow::changeUrl);
+ connect(container->urlNavigatorInternalWithHistory(), &KUrlNavigator::historyChanged,
+ this, &DolphinMainWindow::updateHistory);
+
auto navigators = static_cast<DolphinNavigatorsWidgetAction *>
(actionCollection()->action(QStringLiteral("url_navigators")));
-
const KUrlNavigator *navigator = m_tabWidget->currentTabPage()->primaryViewActive() ?
navigators->primaryUrlNavigator() :
navigators->secondaryUrlNavigator();
- connect(navigator, &KUrlNavigator::urlChanged,
- this, &DolphinMainWindow::changeUrl);
QAction *editableLocactionAction = actionCollection()->action(QStringLiteral("editable_location"));
editableLocactionAction->setChecked(navigator->isUrlEditable());
connect(navigator, &KUrlNavigator::editableStateChanged,
this, &DolphinMainWindow::slotEditableStateChanged);
connect(navigator, &KUrlNavigator::tabRequested,
- this, &DolphinMainWindow::openNewTabAfterLastTab);
+ this, &DolphinMainWindow::openNewTab);
- disconnect(m_updateHistoryConnection);
- m_updateHistoryConnection = connect(
- container->urlNavigatorInternalWithHistory(), &KUrlNavigator::historyChanged,
- this, &DolphinMainWindow::updateHistory);
}
void DolphinMainWindow::updateSplitAction()
// StandardAction separately because both are used in different locations.
// m_helpMenu is only used for createControlButton() button.
+ auto setStandardActionWhatsThis = [this](KStandardAction::StandardAction actionId,
+ const QString &whatsThis) {
+ if (auto *action = actionCollection()->action(KStandardAction::name(actionId))) {
+ action->setWhatsThis(whatsThis);
+ }
+ };
+ auto setHelpActionWhatsThis = [this](KHelpMenu::MenuId menuId, const QString &whatsThis) {
+ if (auto *action = m_helpMenu->action(menuId)) {
+ action->setWhatsThis(whatsThis);
+ }
+ };
+
// Links do not work within the Menubar so texts without links are provided there.
// i18n: If the external link isn't available in your language you should
const QString whatsThisHelpContents = xi18nc("@info:whatsthis handbook",
"<para>This opens the Handbook for this application. It provides "
"explanations for every part of <emphasis>Dolphin</emphasis>.</para>");
- actionCollection()->action(KStandardAction::name(KStandardAction::HelpContents))
- ->setWhatsThis(whatsThisHelpContents
+ setStandardActionWhatsThis(KStandardAction::HelpContents, whatsThisHelpContents
+ xi18nc("@info:whatsthis second half of handbook hb text without link",
"<para>If you want more elaborate introductions to the "
"different features of <emphasis>Dolphin</emphasis> "
"go to the KDE UserBase Wiki.</para>"));
- m_helpMenu->action(KHelpMenu::menuHelpContents)->setWhatsThis(whatsThisHelpContents
+ setHelpActionWhatsThis(KHelpMenu::menuHelpContents, whatsThisHelpContents
+ xi18nc("@info:whatsthis second half of handbook text with link",
"<para>If you want more elaborate introductions to the "
"different features of <emphasis>Dolphin</emphasis> "
"using right now! Click it, then click any component of this "
"application to ask \"What's this?\" about it. The mouse cursor "
"will change appearance if no help is available for a spot.</para>");
- actionCollection()->action(KStandardAction::name(KStandardAction::WhatsThis))
- ->setWhatsThis(whatsThisWhatsThis
+ setStandardActionWhatsThis(KStandardAction::WhatsThis, whatsThisWhatsThis
+ xi18nc("@info:whatsthis second half of whatsthis button text without link",
"<para>There are two other ways to get help for this application: The "
"<interface>Dolphin Handbook</interface> in the <interface>Help"
"article about <emphasis>File Management</emphasis> online."
"</para><para>The \"What's this?\" help is "
"missing in most other windows so don't get too used to this.</para>"));
- m_helpMenu->action(KHelpMenu::menuWhatsThis)->setWhatsThis(whatsThisWhatsThis
+ setHelpActionWhatsThis(KHelpMenu::menuWhatsThis, whatsThisWhatsThis
+ xi18nc("@info:whatsthis second half of whatsthis button text with link",
"<para>There are two other ways to get help: "
"The <link url='help:/dolphin/index.html'>Dolphin Handbook</link> and "
const QString whatsThisReportBug = xi18nc("@info:whatsthis","<para>This opens a "
"window that will guide you through reporting errors or flaws "
"in this application or in other KDE software.</para>");
- actionCollection()->action(KStandardAction::name(KStandardAction::ReportBug))
- ->setWhatsThis(whatsThisReportBug);
- m_helpMenu->action(KHelpMenu::menuReportBug)->setWhatsThis(whatsThisReportBug
+ setStandardActionWhatsThis(KStandardAction::ReportBug, whatsThisReportBug);
+ setHelpActionWhatsThis(KHelpMenu::menuReportBug, whatsThisReportBug
+ xi18nc("@info:whatsthis second half of reportbug text with link",
"<para>High-quality bug reports are much appreciated. To learn "
"how to make your bug report as effective as possible "
"require money like servers, contributor meetings, etc.</para>"
"<para><emphasis>KDE e.V.</emphasis> is the non-profit "
"organization behind the KDE community.</para>");
- actionCollection()->action(KStandardAction::name(KStandardAction::Donate))
- ->setWhatsThis(whatsThisDonate);
- m_helpMenu->action(KHelpMenu::menuDonate)->setWhatsThis(whatsThisDonate);
+ setStandardActionWhatsThis(KStandardAction::Donate, whatsThisDonate);
+ setHelpActionWhatsThis(KHelpMenu::menuDonate, whatsThisDonate);
const QString whatsThisSwitchLanguage = xi18nc("@info:whatsthis",
"With this you can change the language this application uses."
"<nl/>You can even set secondary languages which will be used "
"if texts are not available in your preferred language.");
- actionCollection()->action(KStandardAction::name(KStandardAction::SwitchApplicationLanguage))
- ->setWhatsThis(whatsThisSwitchLanguage);
- m_helpMenu->action(KHelpMenu::menuSwitchLanguage)->setWhatsThis(whatsThisSwitchLanguage);
+ setStandardActionWhatsThis(KStandardAction::SwitchApplicationLanguage,
+ whatsThisSwitchLanguage);
+ setHelpActionWhatsThis(KHelpMenu::menuSwitchLanguage, whatsThisSwitchLanguage);
const QString whatsThisAboutApp = xi18nc("@info:whatsthis","This opens a "
"window that informs you about the version, license, "
"used libraries and maintainers of this application.");
- actionCollection()->action(KStandardAction::name(KStandardAction::AboutApp))
- ->setWhatsThis(whatsThisAboutApp);
- m_helpMenu->action(KHelpMenu::menuAboutApp)->setWhatsThis(whatsThisAboutApp);
+ setStandardActionWhatsThis(KStandardAction::AboutApp, whatsThisAboutApp);
+ setHelpActionWhatsThis(KHelpMenu::menuAboutApp, whatsThisAboutApp);
const QString whatsThisAboutKDE = xi18nc("@info:whatsthis","This opens a "
"window with information about <emphasis>KDE</emphasis>. "
"The KDE community are the people behind this free software."
"<nl/>If you like using this application but don't know "
"about KDE or want to see a cute dragon have a look!");
- actionCollection()->action(KStandardAction::name(KStandardAction::AboutKDE))
- ->setWhatsThis(whatsThisAboutKDE);
- m_helpMenu->action(KHelpMenu::menuAboutKDE)->setWhatsThis(whatsThisAboutKDE);
+ setStandardActionWhatsThis(KStandardAction::AboutKDE, whatsThisAboutKDE);
+ setHelpActionWhatsThis(KHelpMenu::menuAboutKDE, whatsThisAboutKDE);
+}
+
+bool DolphinMainWindow::addHamburgerMenuToToolbar()
+{
+ QDomDocument domDocument = KXMLGUIClient::domDocument();
+ if (domDocument.isNull()) {
+ return false;
+ }
+ QDomNode toolbar = domDocument.elementsByTagName(QStringLiteral("ToolBar")).at(0);
+ if (toolbar.isNull()) {
+ return false;
+ }
+
+ QDomElement hamburgerMenuElement = domDocument.createElement(QStringLiteral("Action"));
+ hamburgerMenuElement.setAttribute(QStringLiteral("name"), QStringLiteral("hamburger_menu"));
+ toolbar.appendChild(hamburgerMenuElement);
+
+ KXMLGUIFactory::saveConfigFile(domDocument, xmlFile());
+ reloadXML();
+ createGUI();
+ return true;
+ // Make sure to also remove the <KXMLGUIFactory> and <QDomDocument> include
+ // whenever this method is removed (maybe in the year ~2026).
}
bool DolphinMainWindow::event(QEvent *event)
return false;
}
+// Set a sane initial window size
+QSize DolphinMainWindow::sizeHint() const
+{
+ return KXmlGuiWindow::sizeHint().expandedTo(QSize(760, 550));
+}
+
void DolphinMainWindow::saveNewToolbarConfig()
{
KXmlGuiWindow::saveNewToolbarConfig(); // Applies the new config. This has to be called first
m_tabWidget->currentTabPage()->insertNavigatorsWidget(navigators);
}
updateAllowedToolbarAreas();
+ (static_cast<KHamburgerMenu *>(actionCollection()->action(KStandardAction::name(
+ KStandardAction::HamburgerMenu))))->hideActionsOf(toolBar());
}
void DolphinMainWindow::focusTerminalPanel()
projects / dolphin.git / blobdiff