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);
}
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;
{
// 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>() << QKeySequence(Qt::CTRL | Qt::Key_T) << QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_N));
- connect(newTab, &QAction::triggered, this, static_cast<void(DolphinMainWindow::*)()>(&DolphinMainWindow::openNewTab));
++ connect(newTab, &QAction::triggered, this, static_cast<void(DolphinMainWindow::*)()>(&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<void(DolphinMainWindow::*)()>(&DolphinMainWindow::closeTab));
- connect(closeTab, SIGNAL(triggered()), m_tabWidget, SLOT(closeTab()));
++ connect(closeTab, &QAction::triggered, m_tabWidget, static_cast<void(DolphinTabWidget::*)()>(&DolphinTabWidget::closeTab));
KStandardAction::quit(this, SLOT(quit()), actionCollection());
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
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);
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)
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.
#include <KLocalizedString>
#include <KAcceleratorManager>
--#include <KMimeType>
++#include <kio/global.h>
#include <KMenu>
DolphinRecentTabsMenu::DolphinRecentTabsMenu(QObject* parent) :
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) {
--- /dev/null
-#include <KIcon>
+ /***************************************************************************
+ * Copyright (C) 2014 by Emmanuel Pescosta <emmanuelpescosta099@gmail.com> *
+ * *
+ * 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 <QApplication>
+ #include <KConfigGroup>
- addTab(tabPage, KIcon(KMimeType::iconNameForUrl(primaryUrl)), tabName(primaryUrl));
++#include <kio/global.h>
+ #include <KRun>
+
+ 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<DolphinTabPage*>(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)));
- tabBar()->setTabIcon(index, KIcon(KMimeType::iconNameForUrl(url)));
++ 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<KUrl>& 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<KUrl>::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<KUrl>& 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<KUrl> 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<QWidget*>(sender()));
+ if (index >= 0) {
+ tabBar()->setTabText(index, tabName(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;
+ }
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);
projects / dolphin.git / commitdiff