From: Emmanuel Pescosta Date: Fri, 22 Aug 2014 21:17:02 +0000 (+0200) Subject: Merge branch 'master' into frameworks X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/commitdiff_plain/d4fb129710d7fadf8e21f2cfd2588a794f774e41 Merge branch 'master' into frameworks Conflicts: dolphin/src/dolphinmainwindow.cpp dolphin/src/dolphinmainwindow.h dolphin/src/dolphinrecenttabsmenu.cpp dolphin/src/dolphinviewcontainer.cpp kfind/CMakeLists.txt --- d4fb129710d7fadf8e21f2cfd2588a794f774e41 diff --cc src/dolphinmainwindow.cpp index 104ade036,95b08af96..21d132020 --- a/src/dolphinmainwindow.cpp +++ b/src/dolphinmainwindow.cpp @@@ -138,37 -143,13 +144,13 @@@ DolphinMainWindow::DolphinMainWindow() setupActions(); m_actionHandler = new DolphinViewActionHandler(actionCollection(), this); - connect(m_actionHandler, SIGNAL(actionBeingHandled()), SLOT(clearStatusBar())); - connect(m_actionHandler, SIGNAL(createDirectory()), SLOT(createDirectory())); + connect(m_actionHandler, &DolphinViewActionHandler::actionBeingHandled, this, &DolphinMainWindow::clearStatusBar); + connect(m_actionHandler, &DolphinViewActionHandler::createDirectory, this, &DolphinMainWindow::createDirectory); m_remoteEncoding = new DolphinRemoteEncoding(this, m_actionHandler); - connect(this, SIGNAL(urlChanged(KUrl)), - m_remoteEncoding, SLOT(slotAboutToOpenUrl())); + connect(this, &DolphinMainWindow::urlChanged, + m_remoteEncoding, &DolphinRemoteEncoding::slotAboutToOpenUrl); - m_tabBar = new DolphinTabBar(this); - connect(m_tabBar, SIGNAL(currentChanged(int)), - this, SLOT(setActiveTab(int))); - connect(m_tabBar, SIGNAL(tabCloseRequested(int)), - this, SLOT(closeTab(int))); - connect(m_tabBar, SIGNAL(openNewActivatedTab(int)), - this, SLOT(openNewActivatedTab(int))); - connect(m_tabBar, SIGNAL(tabMoved(int,int)), - this, SLOT(slotTabMoved(int,int))); - connect(m_tabBar, SIGNAL(tabDropEvent(int,QDropEvent*)), - this, SLOT(tabDropEvent(int,QDropEvent*))); - connect(m_tabBar, SIGNAL(tabDetachRequested(int)), - this, SLOT(detachTab(int))); - - m_tabBar->blockSignals(true); // signals get unblocked after at least 2 tabs are open - m_tabBar->hide(); - - QWidget* centralWidget = new QWidget(this); - m_centralWidgetLayout = new QVBoxLayout(centralWidget); - m_centralWidgetLayout->setSpacing(0); - m_centralWidgetLayout->setMargin(0); - m_centralWidgetLayout->addWidget(m_tabBar); - - setCentralWidget(centralWidget); setupDockWidgets(); setupGUI(Keys | Save | Create | ToolBar); @@@ -552,12 -402,12 +404,12 @@@ void DolphinMainWindow::closeEvent(QClo } switch (result) { - case KDialog::Yes: + case QDialogButtonBox::Yes: // Quit break; - case KDialog::No: + case QDialogButtonBox::No: // Close only the current tab - closeTab(); + m_tabWidget->closeTab(); default: event->ignore(); return; @@@ -1258,31 -977,31 +980,31 @@@ void DolphinMainWindow::setupActions( { // setup 'File' menu m_newFileMenu = new DolphinNewFileMenu(actionCollection(), this); - KMenu* menu = m_newFileMenu->menu(); + QMenu* menu = m_newFileMenu->menu(); menu->setTitle(i18nc("@title:menu Create new folder, file, link, etc.", "Create New")); - menu->setIcon(KIcon("document-new")); + menu->setIcon(QIcon::fromTheme("document-new")); m_newFileMenu->setDelayed(false); - connect(menu, SIGNAL(aboutToShow()), - this, SLOT(updateNewMenu())); + connect(menu, &QMenu::aboutToShow, + this, &DolphinMainWindow::updateNewMenu); - KAction* newWindow = actionCollection()->addAction("new_window"); - newWindow->setIcon(KIcon("window-new")); + QAction* newWindow = actionCollection()->addAction("new_window"); + newWindow->setIcon(QIcon::fromTheme("window-new")); newWindow->setText(i18nc("@action:inmenu File", "New &Window")); newWindow->setShortcut(Qt::CTRL | Qt::Key_N); - connect(newWindow, SIGNAL(triggered()), this, SLOT(openNewMainWindow())); + connect(newWindow, &QAction::triggered, this, &DolphinMainWindow::openNewMainWindow); - KAction* newTab = actionCollection()->addAction("new_tab"); - newTab->setIcon(KIcon("tab-new")); + QAction* newTab = actionCollection()->addAction("new_tab"); + newTab->setIcon(QIcon::fromTheme("tab-new")); newTab->setText(i18nc("@action:inmenu File", "New Tab")); - newTab->setShortcut(KShortcut(Qt::CTRL | Qt::Key_T, Qt::CTRL | Qt::SHIFT | Qt::Key_N)); - connect(newTab, SIGNAL(triggered()), this, SLOT(openNewActivatedTab())); + newTab->setShortcuts(QList() << QKeySequence(Qt::CTRL | Qt::Key_T) << QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_N)); - connect(newTab, &QAction::triggered, this, static_cast(&DolphinMainWindow::openNewTab)); ++ connect(newTab, &QAction::triggered, this, static_cast(&DolphinMainWindow::openNewActivatedTab)); - KAction* closeTab = actionCollection()->addAction("close_tab"); - closeTab->setIcon(KIcon("tab-close")); + QAction* closeTab = actionCollection()->addAction("close_tab"); + closeTab->setIcon(QIcon::fromTheme("tab-close")); closeTab->setText(i18nc("@action:inmenu File", "Close Tab")); closeTab->setShortcut(Qt::CTRL | Qt::Key_W); closeTab->setEnabled(false); - connect(closeTab, &QAction::triggered, this, static_cast(&DolphinMainWindow::closeTab)); - connect(closeTab, SIGNAL(triggered()), m_tabWidget, SLOT(closeTab())); ++ connect(closeTab, &QAction::triggered, m_tabWidget, static_cast(&DolphinTabWidget::closeTab)); KStandardAction::quit(this, SLOT(quit()), actionCollection()); @@@ -1409,14 -1134,14 +1131,14 @@@ activateNextTab->setIconText(i18nc("@action:inmenu", "Next Tab")); activateNextTab->setText(i18nc("@action:inmenu", "Activate Next Tab")); activateNextTab->setEnabled(false); - connect(activateNextTab, &QAction::triggered, this, &DolphinMainWindow::activateNextTab); - connect(activateNextTab, SIGNAL(triggered()), m_tabWidget, SLOT(activateNextTab())); ++ connect(activateNextTab, &QAction::triggered, m_tabWidget, &DolphinTabWidget::activateNextTab); activateNextTab->setShortcuts(QApplication::isRightToLeft() ? prevTabKeys : nextTabKeys); - KAction* activatePrevTab = actionCollection()->addAction("activate_prev_tab"); + QAction* activatePrevTab = actionCollection()->addAction("activate_prev_tab"); activatePrevTab->setIconText(i18nc("@action:inmenu", "Previous Tab")); activatePrevTab->setText(i18nc("@action:inmenu", "Activate Previous Tab")); activatePrevTab->setEnabled(false); - connect(activatePrevTab, &QAction::triggered, this, &DolphinMainWindow::activatePrevTab); - connect(activatePrevTab, SIGNAL(triggered()), m_tabWidget, SLOT(activatePrevTab())); ++ connect(activatePrevTab, &QAction::triggered, m_tabWidget, &DolphinTabWidget::activatePrevTab); activatePrevTab->setShortcuts(QApplication::isRightToLeft() ? nextTabKeys : prevTabKeys); // for context menu @@@ -1533,22 -1258,24 +1255,24 @@@ void DolphinMainWindow::setupDockWidget placesDock->setWidget(placesPanel); QAction* placesAction = placesDock->toggleViewAction(); - createPanelAction(KIcon("bookmarks"), Qt::Key_F9, placesAction, "show_places_panel"); + createPanelAction(QIcon::fromTheme("bookmarks"), Qt::Key_F9, placesAction, "show_places_panel"); addDockWidget(Qt::LeftDockWidgetArea, placesDock); - connect(placesPanel, SIGNAL(placeActivated(KUrl)), - this, SLOT(slotPlaceActivated(KUrl))); + connect(placesPanel, &PlacesPanel::placeActivated, + this, &DolphinMainWindow::slotPlaceActivated); connect(placesPanel, SIGNAL(placeMiddleClicked(KUrl)), this, SLOT(openNewTab(KUrl))); - connect(placesPanel, SIGNAL(errorMessage(QString)), - this, SLOT(slotPanelErrorMessage(QString))); - connect(this, SIGNAL(urlChanged(KUrl)), - placesPanel, SLOT(setUrl(KUrl))); - connect(placesDock, SIGNAL(visibilityChanged(bool)), - m_tabWidget, SLOT(slotPlacesPanelVisibilityChanged(bool))); - connect(this, SIGNAL(settingsChanged()), - placesPanel, SLOT(readSettings())); + connect(placesPanel, &PlacesPanel::errorMessage, + this, &DolphinMainWindow::slotPanelErrorMessage); + connect(this, &DolphinMainWindow::urlChanged, + placesPanel, &PlacesPanel::setUrl); + connect(placesDock, &DolphinDockWidget::visibilityChanged, - this, &DolphinMainWindow::slotPlacesPanelVisibilityChanged); ++ m_tabWidget, &DolphinTabWidget::slotPlacesPanelVisibilityChanged); + connect(this, &DolphinMainWindow::settingsChanged, + placesPanel, &PlacesPanel::readSettings); + m_tabWidget->slotPlacesPanelVisibilityChanged(placesPanel->isVisible()); + // Add actions into the "Panels" menu KActionMenu* panelsMenu = new KActionMenu(i18nc("@action:inmenu View", "Panels"), this); actionCollection()->addAction("panels", panelsMenu); @@@ -1779,29 -1486,7 +1483,7 @@@ bool DolphinMainWindow::isKompareInstal return installed; } - void DolphinMainWindow::setUrlAsCaption(const KUrl& url) - { - QString caption; - if (!url.isLocalFile()) { - caption.append(url.protocol() + " - "); - if (url.hasHost()) { - caption.append(url.host() + " - "); - } - } - - const QString fileName = url.fileName().isEmpty() ? "/" : url.fileName(); - caption.append(fileName); - - setCaption(caption); - } - - QString DolphinMainWindow::squeezedText(const QString& text) const - { - const QFontMetrics fm = fontMetrics(); - return fm.elidedText(text, Qt::ElideMiddle, fm.maxWidth() * 10); - } - -void DolphinMainWindow::createPanelAction(const KIcon& icon, +void DolphinMainWindow::createPanelAction(const QIcon& icon, const QKeySequence& shortcut, QAction* dockAction, const QString& actionName) diff --cc src/dolphinmainwindow.h index 50c8f8923,9d4c003af..fd231cf0b --- a/src/dolphinmainwindow.h +++ b/src/dolphinmainwindow.h @@@ -39,18 -38,16 +39,15 @@@ typedef KIO::FileUndoManager::CommandTy class DolphinViewActionHandler; class DolphinApplication; class DolphinSettingsDialog; - class DolphinTabBar; class DolphinViewContainer; class DolphinRemoteEncoding; - class DolphinTabPage; + class DolphinTabWidget; -class KAction; class KFileItem; class KFileItemList; class KJob; class KNewFileMenu; - class QSplitter; -class KUrl; class QToolButton; - class QVBoxLayout; +class QIcon; /** * @short Main window for Dolphin. diff --cc src/dolphinrecenttabsmenu.cpp index 0f90e634b,fa3eaf166..5440a1b37 --- a/src/dolphinrecenttabsmenu.cpp +++ b/src/dolphinrecenttabsmenu.cpp @@@ -21,7 -21,7 +21,7 @@@ #include #include --#include ++#include #include DolphinRecentTabsMenu::DolphinRecentTabsMenu(QObject* parent) : @@@ -40,19 -40,14 +40,14 @@@ this, SLOT(handleAction(QAction*))); } - void DolphinRecentTabsMenu::rememberClosedTab(const KUrl& primaryUrl, const KUrl& secondaryUrl) + void DolphinRecentTabsMenu::rememberClosedTab(const KUrl& url, const QByteArray& state) { QAction* action = new QAction(menu()); - action->setText(primaryUrl.path()); - - const QString iconName = KMimeType::iconNameForUrl(primaryUrl); + action->setText(url.path()); + action->setData(state); - const QString iconName = KMimeType::iconNameForUrl(url); - action->setIcon(KIcon(iconName)); ++ const QString iconName = KIO::iconNameForUrl(url); + action->setIcon(QIcon::fromTheme(iconName)); - KUrl::List urls; - urls << primaryUrl; - urls << secondaryUrl; - action->setData(QVariant::fromValue(urls)); - // Add the closed tab menu entry after the separator and // "Empty Recently Closed Tabs" entry if (menu()->actions().size() == 2) { diff --cc src/dolphintabwidget.cpp index 000000000,b1b2d858f..4dd7df742 mode 000000,100644..100644 --- a/src/dolphintabwidget.cpp +++ b/src/dolphintabwidget.cpp @@@ -1,0 -1,360 +1,360 @@@ + /*************************************************************************** + * Copyright (C) 2014 by Emmanuel Pescosta * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + + #include "dolphintabwidget.h" + + #include "dolphintabbar.h" + #include "dolphintabpage.h" + #include "dolphinviewcontainer.h" + #include "dolphin_generalsettings.h" + #include "views/draganddrophelper.h" + + #include + #include -#include ++#include + #include + + DolphinTabWidget::DolphinTabWidget(QWidget* parent) : + QTabWidget(parent), + m_placesSelectorVisible(true) + { + connect(this, SIGNAL(tabCloseRequested(int)), + this, SLOT(closeTab(int))); + connect(this, SIGNAL(currentChanged(int)), + this, SLOT(currentTabChanged(int))); + + DolphinTabBar* tabBar = new DolphinTabBar(this); + connect(tabBar, SIGNAL(openNewActivatedTab(int)), + this, SLOT(openNewActivatedTab(int))); + connect(tabBar, SIGNAL(tabDropEvent(int,QDropEvent*)), + this, SLOT(tabDropEvent(int,QDropEvent*))); + connect(tabBar, SIGNAL(tabDetachRequested(int)), + this, SLOT(detachTab(int))); + tabBar->hide(); + + setTabBar(tabBar); + setDocumentMode(true); + setElideMode(Qt::ElideRight); + setUsesScrollButtons(true); + } + + DolphinTabPage* DolphinTabWidget::currentTabPage() const + { + return tabPageAt(currentIndex()); + } + + DolphinTabPage* DolphinTabWidget::tabPageAt(const int index) const + { + return static_cast(widget(index)); + } + + void DolphinTabWidget::saveProperties(KConfigGroup& group) const + { + const int tabCount = count(); + group.writeEntry("Tab Count", tabCount); + group.writeEntry("Active Tab Index", currentIndex()); + + for (int i = 0; i < tabCount; ++i) { + const DolphinTabPage* tabPage = tabPageAt(i); + group.writeEntry("Tab Data " % QString::number(i), tabPage->saveState()); + } + } + + void DolphinTabWidget::readProperties(const KConfigGroup& group) + { + const int tabCount = group.readEntry("Tab Count", 0); + for (int i = 0; i < tabCount; ++i) { + if (i >= count()) { + openNewActivatedTab(); + } + if (group.hasKey("Tab Data " % QString::number(i))) { + // Tab state created with Dolphin > 4.14.x + const QByteArray state = group.readEntry("Tab Data " % QString::number(i), QByteArray()); + tabPageAt(i)->restoreState(state); + } else { + // Tab state created with Dolphin <= 4.14.x + const QByteArray state = group.readEntry("Tab " % QString::number(i), QByteArray()); + tabPageAt(i)->restoreStateV1(state); + } + } + + const int index = group.readEntry("Active Tab Index", 0); + setCurrentIndex(index); + } + + void DolphinTabWidget::refreshViews() + { + const int tabCount = count(); + for (int i = 0; i < tabCount; ++i) { + tabPageAt(i)->refreshViews(); + } + } + + void DolphinTabWidget::openNewActivatedTab() + { + const DolphinViewContainer* oldActiveViewContainer = currentTabPage()->activeViewContainer(); + Q_ASSERT(oldActiveViewContainer); + + const bool isUrlEditable = oldActiveViewContainer->urlNavigator()->isUrlEditable(); + + openNewActivatedTab(oldActiveViewContainer->url()); + + DolphinViewContainer* newActiveViewContainer = currentTabPage()->activeViewContainer(); + Q_ASSERT(newActiveViewContainer); + + // The URL navigator of the new tab should have the same editable state + // as the current tab + KUrlNavigator* navigator = newActiveViewContainer->urlNavigator(); + navigator->setUrlEditable(isUrlEditable); + + if (isUrlEditable) { + // If a new tab is opened and the URL is editable, assure that + // the user can edit the URL without manually setting the focus + navigator->setFocus(); + } + } + + void DolphinTabWidget::openNewActivatedTab(const KUrl& primaryUrl, const KUrl& secondaryUrl) + { + openNewTab(primaryUrl, secondaryUrl); + setCurrentIndex(count() - 1); + } + + void DolphinTabWidget::openNewTab(const KUrl& primaryUrl, const KUrl& secondaryUrl) + { + QWidget* focusWidget = QApplication::focusWidget(); + + DolphinTabPage* tabPage = new DolphinTabPage(primaryUrl, secondaryUrl, this); + tabPage->setPlacesSelectorVisible(m_placesSelectorVisible); + connect(tabPage, SIGNAL(activeViewChanged(DolphinViewContainer*)), + this, SIGNAL(activeViewChanged(DolphinViewContainer*))); + connect(tabPage, SIGNAL(activeViewUrlChanged(KUrl)), + this, SLOT(tabUrlChanged(KUrl))); - addTab(tabPage, KIcon(KMimeType::iconNameForUrl(primaryUrl)), tabName(primaryUrl)); ++ addTab(tabPage, QIcon::fromTheme(KIO::iconNameForUrl(primaryUrl)), tabName(primaryUrl)); + + if (focusWidget) { + // The DolphinViewContainer grabbed the keyboard focus. As the tab is opened + // in background, assure that the previous focused widget gets the focus back. + focusWidget->setFocus(); + } + } + + void DolphinTabWidget::openDirectories(const QList& dirs) + { + const bool hasSplitView = GeneralSettings::splitView(); + + // Open each directory inside a new tab. If the "split view" option has been enabled, + // always show two directories within one tab. + QList::const_iterator it = dirs.constBegin(); + while (it != dirs.constEnd()) { + const KUrl& primaryUrl = *(it++); + if (hasSplitView && (it != dirs.constEnd())) { + const KUrl& secondaryUrl = *(it++); + openNewTab(primaryUrl, secondaryUrl); + } else { + openNewTab(primaryUrl); + } + } + } + + void DolphinTabWidget::openFiles(const QList& files) + { + if (files.isEmpty()) { + return; + } + + // Get all distinct directories from 'files' and open a tab + // for each directory. If the "split view" option is enabled, two + // directories are shown inside one tab (see openDirectories()). + QList dirs; + foreach (const KUrl& url, files) { + const KUrl dir(url.directory()); + if (!dirs.contains(dir)) { + dirs.append(dir); + } + } + + const int oldTabCount = count(); + openDirectories(dirs); + const int tabCount = count(); + + // Select the files. Although the files can be split between several + // tabs, there is no need to split 'files' accordingly, as + // the DolphinView will just ignore invalid selections. + for (int i = oldTabCount; i < tabCount; ++i) { + DolphinTabPage* tabPage = tabPageAt(i); + tabPage->markUrlsAsSelected(files); + tabPage->markUrlAsCurrent(files.first()); + } + } + + void DolphinTabWidget::closeTab() + { + closeTab(currentIndex()); + } + + void DolphinTabWidget::closeTab(const int index) + { + Q_ASSERT(index >= 0); + Q_ASSERT(index < count()); + + if (count() < 2) { + // Never close the last tab. + return; + } + + DolphinTabPage* tabPage = tabPageAt(index); + emit rememberClosedTab(tabPage->activeViewContainer()->url(), tabPage->saveState()); + + removeTab(index); + tabPage->deleteLater(); + } + + void DolphinTabWidget::activateNextTab() + { + const int index = currentIndex() + 1; + setCurrentIndex(index < count() ? index : 0); + } + + void DolphinTabWidget::activatePrevTab() + { + const int index = currentIndex() - 1; + setCurrentIndex(index >= 0 ? index : (count() - 1)); + } + + void DolphinTabWidget::slotPlacesPanelVisibilityChanged(bool visible) + { + // The places-selector from the URL navigator should only be shown + // if the places dock is invisible + m_placesSelectorVisible = !visible; + + const int tabCount = count(); + for (int i = 0; i < tabCount; ++i) { + DolphinTabPage* tabPage = tabPageAt(i); + tabPage->setPlacesSelectorVisible(m_placesSelectorVisible); + } + } + + void DolphinTabWidget::restoreClosedTab(const QByteArray& state) + { + openNewActivatedTab(); + currentTabPage()->restoreState(state); + } + + void DolphinTabWidget::detachTab(int index) + { + Q_ASSERT(index >= 0); + + const QString separator(QLatin1Char(' ')); + QString command = QLatin1String("dolphin"); + + const DolphinTabPage* tabPage = tabPageAt(index); + command += separator + tabPage->primaryViewContainer()->url().url(); + if (tabPage->splitViewEnabled()) { + command += separator + tabPage->secondaryViewContainer()->url().url(); + command += separator + QLatin1String("-split"); + } + + KRun::runCommand(command, this); + + closeTab(index); + } + + void DolphinTabWidget::openNewActivatedTab(int index) + { + Q_ASSERT(index >= 0); + const DolphinTabPage* tabPage = tabPageAt(index); + openNewActivatedTab(tabPage->activeViewContainer()->url()); + } + + void DolphinTabWidget::tabDropEvent(int index, QDropEvent* event) + { + if (index >= 0) { + const DolphinView* view = tabPageAt(index)->activeViewContainer()->view(); + + QString error; + DragAndDropHelper::dropUrls(view->rootItem(), view->url(), event, error); + if (!error.isEmpty()) { + currentTabPage()->activeViewContainer()->showMessage(error, DolphinViewContainer::Error); + } + } + } + + void DolphinTabWidget::tabUrlChanged(const KUrl& url) + { + const int index = indexOf(qobject_cast(sender())); + if (index >= 0) { + tabBar()->setTabText(index, tabName(url)); - tabBar()->setTabIcon(index, KIcon(KMimeType::iconNameForUrl(url))); ++ tabBar()->setTabIcon(index, QIcon::fromTheme(KIO::iconNameForUrl(url))); + + // Emit the currentUrlChanged signal if the url of the current tab has been changed. + if (index == currentIndex()) { + emit currentUrlChanged(url); + } + } + } + + void DolphinTabWidget::currentTabChanged(int index) + { + DolphinViewContainer* viewContainer = tabPageAt(index)->activeViewContainer(); + emit activeViewChanged(viewContainer); + emit currentUrlChanged(viewContainer->url()); + } + + void DolphinTabWidget::tabInserted(int index) + { + QTabWidget::tabInserted(index); + + if (count() > 1) { + tabBar()->show(); + } + + emit tabCountChanged(count()); + } + + void DolphinTabWidget::tabRemoved(int index) + { + QTabWidget::tabRemoved(index); + + // If only one tab is left, then remove the tab entry so that + // closing the last tab is not possible. + if (count() < 2) { + tabBar()->hide(); + } + + emit tabCountChanged(count()); + } + + QString DolphinTabWidget::tabName(const KUrl& url) const + { + QString name; + if (url.equals(KUrl("file:///"))) { + name = '/'; + } else { + name = url.fileName(); + if (name.isEmpty()) { + name = url.protocol(); + } else { + // Make sure that a '&' inside the directory name is displayed correctly + // and not misinterpreted as a keyboard shortcut in QTabBar::setTabText() + name.replace('&', "&&"); + } + } + return name; + } diff --cc src/dolphinviewcontainer.cpp index 46225f931,93af3e8fb..b18e43631 --- a/src/dolphinviewcontainer.cpp +++ b/src/dolphinviewcontainer.cpp @@@ -108,51 -108,34 +108,53 @@@ DolphinViewContainer::DolphinViewContai m_messageWidget->hide(); m_view = new DolphinView(url, this); - connect(m_view, SIGNAL(urlChanged(KUrl)), m_urlNavigator, SLOT(setUrl(KUrl))); - connect(m_view, SIGNAL(urlChanged(KUrl)), m_messageWidget, SLOT(hide())); - connect(m_view, SIGNAL(directoryLoadingCompleted()), m_messageWidget, SLOT(hide())); - connect(m_view, SIGNAL(writeStateChanged(bool)), this, SIGNAL(writeStateChanged(bool))); - connect(m_view, SIGNAL(requestItemInfo(KFileItem)), this, SLOT(showItemInfo(KFileItem))); - connect(m_view, SIGNAL(itemActivated(KFileItem)), this, SLOT(slotItemActivated(KFileItem))); - connect(m_view, SIGNAL(itemsActivated(KFileItemList)), this, SLOT(slotItemsActivated(KFileItemList))); - connect(m_view, SIGNAL(redirection(KUrl,KUrl)), this, SLOT(redirect(KUrl,KUrl))); - connect(m_view, SIGNAL(directoryLoadingStarted()), this, SLOT(slotDirectoryLoadingStarted())); - connect(m_view, SIGNAL(directoryLoadingCompleted()), this, SLOT(slotDirectoryLoadingCompleted())); - connect(m_view, SIGNAL(directoryLoadingCanceled()), this, SLOT(slotDirectoryLoadingCanceled())); - connect(m_view, SIGNAL(itemCountChanged()), this, SLOT(delayedStatusBarUpdate())); - connect(m_view, SIGNAL(directoryLoadingProgress(int)), this, SLOT(updateDirectoryLoadingProgress(int))); - connect(m_view, SIGNAL(directorySortingProgress(int)), this, SLOT(updateDirectorySortingProgress(int))); - connect(m_view, SIGNAL(selectionChanged(KFileItemList)), this, SLOT(delayedStatusBarUpdate())); - connect(m_view, SIGNAL(urlAboutToBeChanged(KUrl)), this, SLOT(slotViewUrlAboutToBeChanged(KUrl))); - connect(m_view, SIGNAL(errorMessage(QString)), this, SLOT(showErrorMessage(QString))); - connect(m_view, SIGNAL(urlIsFileError(KUrl)), this, SLOT(slotUrlIsFileError(KUrl))); - connect(m_view, SIGNAL(activated()), this, SLOT(activate())); - - connect(m_urlNavigator, SIGNAL(urlAboutToBeChanged(KUrl)), - this, SLOT(slotUrlNavigatorLocationAboutToBeChanged(KUrl))); - connect(m_urlNavigator, SIGNAL(urlChanged(KUrl)), - this, SLOT(slotUrlNavigatorLocationChanged(KUrl))); - connect(m_urlNavigator, SIGNAL(historyChanged()), - this, SLOT(slotHistoryChanged())); - connect(m_urlNavigator, SIGNAL(returnPressed()), - this, SLOT(slotReturnPressed())); + connect(m_view, &DolphinView::urlChanged, + m_urlNavigator, &KUrlNavigator::setUrl); + connect(m_view, &DolphinView::urlChanged, + m_messageWidget, &KMessageWidget::hide); ++ connect(m_view, &DolphinView::directoryLoadingCompleted, ++ m_messageWidget, &KMessageWidget::hide); + connect(m_view, &DolphinView::writeStateChanged, + this, &DolphinViewContainer::writeStateChanged); + connect(m_view, &DolphinView::requestItemInfo, + this, &DolphinViewContainer::showItemInfo); + connect(m_view, &DolphinView::itemActivated, + this, &DolphinViewContainer::slotItemActivated); + connect(m_view, &DolphinView::itemsActivated, + this, &DolphinViewContainer::slotItemsActivated); + connect(m_view, &DolphinView::redirection, + this, &DolphinViewContainer::redirect); + connect(m_view, &DolphinView::directoryLoadingStarted, + this, &DolphinViewContainer::slotDirectoryLoadingStarted); + connect(m_view, &DolphinView::directoryLoadingCompleted, + this, &DolphinViewContainer::slotDirectoryLoadingCompleted); + connect(m_view, &DolphinView::directoryLoadingCanceled, + this, &DolphinViewContainer::slotDirectoryLoadingCanceled); + connect(m_view, &DolphinView::itemCountChanged, + this, &DolphinViewContainer::delayedStatusBarUpdate); + connect(m_view, &DolphinView::directoryLoadingProgress, + this, &DolphinViewContainer::updateDirectoryLoadingProgress); + connect(m_view, &DolphinView::directorySortingProgress, + this, &DolphinViewContainer::updateDirectorySortingProgress); + connect(m_view, &DolphinView::selectionChanged, + this, &DolphinViewContainer::delayedStatusBarUpdate); + connect(m_view, &DolphinView::urlAboutToBeChanged, + this, &DolphinViewContainer::slotViewUrlAboutToBeChanged); + connect(m_view, &DolphinView::errorMessage, + this, &DolphinViewContainer::showErrorMessage); + connect(m_view, &DolphinView::urlIsFileError, + this, &DolphinViewContainer::slotUrlIsFileError); + connect(m_view, &DolphinView::activated, + this, &DolphinViewContainer::activate); + + connect(m_urlNavigator, &KUrlNavigator::urlAboutToBeChanged, + this, &DolphinViewContainer::slotUrlNavigatorLocationAboutToBeChanged); + connect(m_urlNavigator, &KUrlNavigator::urlChanged, + this, &DolphinViewContainer::slotUrlNavigatorLocationChanged); + connect(m_urlNavigator, &KUrlNavigator::historyChanged, + this, &DolphinViewContainer::slotHistoryChanged); + connect(m_urlNavigator, &KUrlNavigator::returnPressed, + this, &DolphinViewContainer::slotReturnPressed); // Initialize status bar m_statusBar = new DolphinStatusBar(this);