diff --git a/src/dolphinviewcontainer.cpp b/src/dolphinviewcontainer.cpp index 6c5edc13f..2b829f4e0 100644 --- a/src/dolphinviewcontainer.cpp +++ b/src/dolphinviewcontainer.cpp @@ -1,700 +1,721 @@ /*************************************************************************** * Copyright (C) 2007 by Peter Penz * * * * 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 "dolphinviewcontainer.h" #include "dolphin_generalsettings.h" #include "dolphindebug.h" #include "filterbar/filterbar.h" #include "global.h" #include "search/dolphinsearchbox.h" #include "statusbar/dolphinstatusbar.h" #include "trash/dolphintrash.h" #include "views/viewmodecontroller.h" #include "views/viewproperties.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include DolphinViewContainer::DolphinViewContainer(const QUrl& url, QWidget* parent) : QWidget(parent), m_topLayout(nullptr), + m_navigatorWidget(nullptr), m_urlNavigator(nullptr), + m_emptyTrashButton(nullptr), m_searchBox(nullptr), m_messageWidget(nullptr), m_view(nullptr), m_filterBar(nullptr), m_statusBar(nullptr), m_statusBarTimer(nullptr), m_statusBarTimestamp(), m_autoGrabFocus(true) #ifdef KActivities_FOUND , m_activityResourceInstance(0) #endif { hide(); m_topLayout = new QVBoxLayout(this); m_topLayout->setSpacing(0); m_topLayout->setMargin(0); + m_navigatorWidget = new QWidget(this); + QHBoxLayout* navigatorLayout = new QHBoxLayout(m_navigatorWidget); + navigatorLayout->setSpacing(0); + navigatorLayout->setMargin(0); + m_urlNavigator = new KUrlNavigator(new KFilePlacesModel(this), url, this); connect(m_urlNavigator, &KUrlNavigator::activated, this, &DolphinViewContainer::activate); connect(m_urlNavigator->editor(), &KUrlComboBox::completionModeChanged, this, &DolphinViewContainer::saveUrlCompletionMode); const GeneralSettings* settings = GeneralSettings::self(); m_urlNavigator->setUrlEditable(settings->editableUrl()); m_urlNavigator->setShowFullPath(settings->showFullPath()); m_urlNavigator->setHomeUrl(Dolphin::homeUrl()); KUrlComboBox* editor = m_urlNavigator->editor(); editor->setCompletionMode(KCompletion::CompletionMode(settings->urlCompletionMode())); + m_emptyTrashButton = new QPushButton(QIcon::fromTheme(QStringLiteral("user-trash")), "&Empty Trash", this); + m_emptyTrashButton->setFlat(true); + connect(m_emptyTrashButton, &QPushButton::clicked, this, [this]() { Trash::empty(this); }); + connect(&Trash::instance(), &Trash::emptinessChanged, m_emptyTrashButton, &QPushButton::setDisabled); + m_emptyTrashButton->setDisabled(Trash::isEmpty()); + m_emptyTrashButton->hide(); + m_searchBox = new DolphinSearchBox(this); m_searchBox->hide(); connect(m_searchBox, &DolphinSearchBox::activated, this, &DolphinViewContainer::activate); connect(m_searchBox, &DolphinSearchBox::closeRequest, this, &DolphinViewContainer::closeSearchBox); connect(m_searchBox, &DolphinSearchBox::searchRequest, this, &DolphinViewContainer::startSearching); connect(m_searchBox, &DolphinSearchBox::returnPressed, this, &DolphinViewContainer::requestFocus); m_messageWidget = new KMessageWidget(this); m_messageWidget->setCloseButtonVisible(true); m_messageWidget->hide(); m_view = new DolphinView(url, this); connect(m_view, &DolphinView::urlChanged, m_urlNavigator, &KUrlNavigator::setLocationUrl); connect(m_view, &DolphinView::urlChanged, 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::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::urlSelectionRequested, this, &DolphinViewContainer::slotUrlSelectionRequested); connect(m_urlNavigator, &KUrlNavigator::returnPressed, this, &DolphinViewContainer::slotReturnPressed); connect(m_urlNavigator, &KUrlNavigator::urlsDropped, this, [=](const QUrl &destination, QDropEvent *event) { #if KIO_VERSION >= QT_VERSION_CHECK(5, 37, 0) m_view->dropUrls(destination, event, m_urlNavigator->dropWidget()); #else // TODO: remove as soon as we can hard-depend of KF5 >= 5.37 m_view->dropUrls(destination, event, m_view); #endif }); + connect(m_view, &DolphinView::directoryLoadingCompleted, this, [this]() { + m_emptyTrashButton->setVisible(m_view->url().scheme() == QLatin1String("trash")); + }); + // Initialize status bar m_statusBar = new DolphinStatusBar(this); m_statusBar->setUrl(m_view->url()); m_statusBar->setZoomLevel(m_view->zoomLevel()); connect(m_view, &DolphinView::urlChanged, m_statusBar, &DolphinStatusBar::setUrl); connect(m_view, &DolphinView::zoomLevelChanged, m_statusBar, &DolphinStatusBar::setZoomLevel); connect(m_view, &DolphinView::infoMessage, m_statusBar, &DolphinStatusBar::setText); connect(m_view, &DolphinView::operationCompletedMessage, m_statusBar, &DolphinStatusBar::setText); connect(m_statusBar, &DolphinStatusBar::stopPressed, this, &DolphinViewContainer::stopDirectoryLoading); connect(m_statusBar, &DolphinStatusBar::zoomLevelChanged, this, &DolphinViewContainer::slotStatusBarZoomLevelChanged); m_statusBarTimer = new QTimer(this); m_statusBarTimer->setSingleShot(true); m_statusBarTimer->setInterval(300); connect(m_statusBarTimer, &QTimer::timeout, this, &DolphinViewContainer::updateStatusBar); KIO::FileUndoManager* undoManager = KIO::FileUndoManager::self(); connect(undoManager, &KIO::FileUndoManager::jobRecordingFinished, this, &DolphinViewContainer::delayedStatusBarUpdate); // Initialize filter bar m_filterBar = new FilterBar(this); m_filterBar->setVisible(settings->filterBar()); connect(m_filterBar, &FilterBar::filterChanged, this, &DolphinViewContainer::setNameFilter); connect(m_filterBar, &FilterBar::closeRequest, this, &DolphinViewContainer::closeFilterBar); connect(m_filterBar, &FilterBar::focusViewRequest, this, &DolphinViewContainer::requestFocus); connect(m_view, &DolphinView::urlChanged, m_filterBar, &FilterBar::slotUrlChanged); - m_topLayout->addWidget(m_urlNavigator); + navigatorLayout->addWidget(m_urlNavigator); + navigatorLayout->addWidget(m_emptyTrashButton); + + m_topLayout->addWidget(m_navigatorWidget); m_topLayout->addWidget(m_searchBox); m_topLayout->addWidget(m_messageWidget); m_topLayout->addWidget(m_view); m_topLayout->addWidget(m_filterBar); m_topLayout->addWidget(m_statusBar); setSearchModeEnabled(isSearchUrl(url)); // Initialize kactivities resource instance #ifdef KActivities_FOUND m_activityResourceInstance = new KActivities::ResourceInstance( window()->winId(), url); m_activityResourceInstance->setParent(this); #endif } DolphinViewContainer::~DolphinViewContainer() { } QUrl DolphinViewContainer::url() const { return m_view->url(); } void DolphinViewContainer::setActive(bool active) { m_searchBox->setActive(active); m_urlNavigator->setActive(active); m_view->setActive(active); #ifdef KActivities_FOUND if (active) { m_activityResourceInstance->notifyFocusedIn(); } else { m_activityResourceInstance->notifyFocusedOut(); } #endif } bool DolphinViewContainer::isActive() const { Q_ASSERT(m_view->isActive() == m_urlNavigator->isActive()); return m_view->isActive(); } void DolphinViewContainer::setAutoGrabFocus(bool grab) { m_autoGrabFocus = grab; } bool DolphinViewContainer::autoGrabFocus() const { return m_autoGrabFocus; } QString DolphinViewContainer::currentSearchText() const { return m_searchBox->text(); } const DolphinStatusBar* DolphinViewContainer::statusBar() const { return m_statusBar; } DolphinStatusBar* DolphinViewContainer::statusBar() { return m_statusBar; } const KUrlNavigator* DolphinViewContainer::urlNavigator() const { return m_urlNavigator; } KUrlNavigator* DolphinViewContainer::urlNavigator() { return m_urlNavigator; } const DolphinView* DolphinViewContainer::view() const { return m_view; } DolphinView* DolphinViewContainer::view() { return m_view; } void DolphinViewContainer::showMessage(const QString& msg, MessageType type) { if (msg.isEmpty()) { return; } m_messageWidget->setText(msg); switch (type) { case Information: m_messageWidget->setMessageType(KMessageWidget::Information); break; case Warning: m_messageWidget->setMessageType(KMessageWidget::Warning); break; case Error: m_messageWidget->setMessageType(KMessageWidget::Error); break; default: Q_ASSERT(false); break; } m_messageWidget->setWordWrap(false); const int unwrappedWidth = m_messageWidget->sizeHint().width(); m_messageWidget->setWordWrap(unwrappedWidth > size().width()); if (m_messageWidget->isVisible()) { m_messageWidget->hide(); } m_messageWidget->animatedShow(); } void DolphinViewContainer::readSettings() { if (GeneralSettings::modifiedStartupSettings()) { // The startup settings should only get applied if they have been // modified by the user. Otherwise keep the (possibly) different current // settings of the URL navigator and the filterbar. m_urlNavigator->setUrlEditable(GeneralSettings::editableUrl()); m_urlNavigator->setShowFullPath(GeneralSettings::showFullPath()); m_urlNavigator->setHomeUrl(Dolphin::homeUrl()); setFilterBarVisible(GeneralSettings::filterBar()); } m_view->readSettings(); m_statusBar->readSettings(); } bool DolphinViewContainer::isFilterBarVisible() const { return m_filterBar->isVisible(); } void DolphinViewContainer::setSearchModeEnabled(bool enabled) { if (enabled == isSearchModeEnabled()) { if (enabled && !m_searchBox->hasFocus()) { m_searchBox->setFocus(); m_searchBox->selectAll(); } return; } m_searchBox->setVisible(enabled); - m_urlNavigator->setVisible(!enabled); + m_navigatorWidget->setVisible(!enabled); if (enabled) { const QUrl& locationUrl = m_urlNavigator->locationUrl(); m_searchBox->fromSearchUrl(locationUrl); } else { m_view->setViewPropertiesContext(QString()); // Restore the URL for the URL navigator. If Dolphin has been // started with a search-URL, the home URL is used as fallback. QUrl url = m_searchBox->searchPath(); if (url.isEmpty() || !url.isValid() || isSearchUrl(url)) { url = Dolphin::homeUrl(); } m_urlNavigator->setLocationUrl(url); } } bool DolphinViewContainer::isSearchModeEnabled() const { return m_searchBox->isVisible(); } QString DolphinViewContainer::placesText() const { QString text; if (isSearchModeEnabled()) { text = i18n("Search for %1 in %2", m_searchBox->text(), m_searchBox->searchPath().fileName()); } else { text = url().fileName(); if (text.isEmpty()) { text = url().host(); } if (text.isEmpty()) { text = url().scheme(); } } return text; } void DolphinViewContainer::reload() { view()->reload(); m_messageWidget->hide(); } void DolphinViewContainer::setUrl(const QUrl& newUrl) { if (newUrl != m_urlNavigator->locationUrl()) { m_urlNavigator->setLocationUrl(newUrl); } #ifdef KActivities_FOUND m_activityResourceInstance->setUri(newUrl); #endif } void DolphinViewContainer::setFilterBarVisible(bool visible) { Q_ASSERT(m_filterBar); if (visible) { m_filterBar->show(); m_filterBar->setFocus(); m_filterBar->selectAll(); } else { closeFilterBar(); } } void DolphinViewContainer::delayedStatusBarUpdate() { if (m_statusBarTimer->isActive() && (m_statusBarTimestamp.elapsed() > 2000)) { // No update of the statusbar has been done during the last 2 seconds, // although an update has been requested. Trigger an immediate update. m_statusBarTimer->stop(); updateStatusBar(); } else { // Invoke updateStatusBar() with a small delay. This assures that // when a lot of delayedStatusBarUpdates() are done in a short time, // no bottleneck is given. m_statusBarTimer->start(); } } void DolphinViewContainer::updateStatusBar() { m_statusBarTimestamp.start(); const QString text = m_view->statusBarText(); m_statusBar->setDefaultText(text); m_statusBar->resetToDefaultText(); } void DolphinViewContainer::updateDirectoryLoadingProgress(int percent) { if (m_statusBar->progressText().isEmpty()) { m_statusBar->setProgressText(i18nc("@info:progress", "Loading folder...")); } m_statusBar->setProgress(percent); } void DolphinViewContainer::updateDirectorySortingProgress(int percent) { if (m_statusBar->progressText().isEmpty()) { m_statusBar->setProgressText(i18nc("@info:progress", "Sorting...")); } m_statusBar->setProgress(percent); } void DolphinViewContainer::slotDirectoryLoadingStarted() { if (isSearchUrl(url())) { // Search KIO-slaves usually don't provide any progress information. Give // a hint to the user that a searching is done: updateStatusBar(); m_statusBar->setProgressText(i18nc("@info", "Searching...")); m_statusBar->setProgress(-1); } else { // Trigger an undetermined progress indication. The progress // information in percent will be triggered by the percent() signal // of the directory lister later. updateDirectoryLoadingProgress(-1); } } void DolphinViewContainer::slotDirectoryLoadingCompleted() { if (!m_statusBar->progressText().isEmpty()) { m_statusBar->setProgressText(QString()); m_statusBar->setProgress(100); } if (isSearchUrl(url()) && m_view->itemsCount() == 0) { // The dir lister has been completed on a Baloo-URI and no items have been found. Instead // of showing the default status bar information ("0 items") a more helpful information is given: m_statusBar->setText(i18nc("@info:status", "No items found.")); } else { updateStatusBar(); } } void DolphinViewContainer::slotDirectoryLoadingCanceled() { if (!m_statusBar->progressText().isEmpty()) { m_statusBar->setProgressText(QString()); m_statusBar->setProgress(100); } m_statusBar->setText(QString()); } void DolphinViewContainer::slotUrlIsFileError(const QUrl& url) { const KFileItem item(url); // Find out if the file can be opened in the view (for example, this is the // case if the file is an archive). The mime type must be known for that. item.determineMimeType(); const QUrl& folderUrl = DolphinView::openItemAsFolderUrl(item, true); if (!folderUrl.isEmpty()) { setUrl(folderUrl); } else { slotItemActivated(item); } } void DolphinViewContainer::slotItemActivated(const KFileItem& item) { // It is possible to activate items on inactive views by // drag & drop operations. Assure that activating an item always // results in an active view. m_view->setActive(true); const QUrl& url = DolphinView::openItemAsFolderUrl(item, GeneralSettings::browseThroughArchives()); if (!url.isEmpty()) { setUrl(url); return; } KRun *run = new KRun(item.targetUrl(), this); run->setShowScriptExecutionPrompt(true); } void DolphinViewContainer::slotItemsActivated(const KFileItemList& items) { Q_ASSERT(items.count() >= 2); KFileItemActions fileItemActions(this); fileItemActions.runPreferredApplications(items, QString()); } void DolphinViewContainer::showItemInfo(const KFileItem& item) { if (item.isNull()) { m_statusBar->resetToDefaultText(); } else { m_statusBar->setText(item.getStatusBarInfo()); } } void DolphinViewContainer::closeFilterBar() { m_filterBar->closeFilterBar(); m_view->setFocus(); emit showFilterBarChanged(false); } void DolphinViewContainer::setNameFilter(const QString& nameFilter) { m_view->setNameFilter(nameFilter); delayedStatusBarUpdate(); } void DolphinViewContainer::activate() { setActive(true); } void DolphinViewContainer::slotUrlNavigatorLocationAboutToBeChanged(const QUrl&) { saveViewState(); } void DolphinViewContainer::slotUrlNavigatorLocationChanged(const QUrl& url) { slotReturnPressed(); if (KProtocolManager::supportsListing(url)) { setSearchModeEnabled(isSearchUrl(url)); m_view->setUrl(url); tryRestoreViewState(); if (m_autoGrabFocus && isActive() && !isSearchUrl(url)) { // When an URL has been entered, the view should get the focus. // The focus must be requested asynchronously, as changing the URL might create // a new view widget. QTimer::singleShot(0, this, &DolphinViewContainer::requestFocus); } } else if (KProtocolManager::isSourceProtocol(url)) { QString app = QStringLiteral("konqueror"); if (url.scheme().startsWith(QLatin1String("http"))) { showMessage(i18nc("@info:status", // krazy:exclude=qmethods "Dolphin does not support web pages, the web browser has been launched"), Information); const KConfigGroup config(KSharedConfig::openConfig(QStringLiteral("kdeglobals")), "General"); const QString browser = config.readEntry("BrowserApplication"); if (!browser.isEmpty()) { app = browser; if (app.startsWith('!')) { // a literal command has been configured, remove the '!' prefix app = app.mid(1); } } } else { showMessage(i18nc("@info:status", "Protocol not supported by Dolphin, Konqueror has been launched"), Information); } const QString secureUrl = KShell::quoteArg(url.toDisplayString(QUrl::PreferLocalFile)); const QString command = app + ' ' + secureUrl; KRun::runCommand(command, app, app, this); } else { showMessage(i18nc("@info:status", "Invalid protocol"), Error); } } void DolphinViewContainer::slotUrlSelectionRequested(const QUrl& url) { qCDebug(DolphinDebug) << "slotUrlSelectionRequested: " << url; m_view->markUrlsAsSelected({url}); m_view->markUrlAsCurrent(url); // makes the item scroll into view } void DolphinViewContainer::redirect(const QUrl& oldUrl, const QUrl& newUrl) { Q_UNUSED(oldUrl); const bool block = m_urlNavigator->signalsBlocked(); m_urlNavigator->blockSignals(true); // Assure that the location state is reset for redirection URLs. This // allows to skip redirection URLs when going back or forward in the // URL history. m_urlNavigator->saveLocationState(QByteArray()); m_urlNavigator->setLocationUrl(newUrl); setSearchModeEnabled(isSearchUrl(newUrl)); m_urlNavigator->blockSignals(block); } void DolphinViewContainer::requestFocus() { m_view->setFocus(); } void DolphinViewContainer::saveUrlCompletionMode(KCompletion::CompletionMode completion) { GeneralSettings::setUrlCompletionMode(completion); } void DolphinViewContainer::slotReturnPressed() { if (!GeneralSettings::editableUrl()) { m_urlNavigator->setUrlEditable(false); } } void DolphinViewContainer::startSearching() { const QUrl url = m_searchBox->urlForSearching(); if (url.isValid() && !url.isEmpty()) { m_view->setViewPropertiesContext(QStringLiteral("search")); m_urlNavigator->setLocationUrl(url); } } void DolphinViewContainer::closeSearchBox() { setSearchModeEnabled(false); } void DolphinViewContainer::stopDirectoryLoading() { m_view->stopLoading(); m_statusBar->setProgress(100); } void DolphinViewContainer::slotStatusBarZoomLevelChanged(int zoomLevel) { m_view->setZoomLevel(zoomLevel); } void DolphinViewContainer::showErrorMessage(const QString& msg) { showMessage(msg, Error); } bool DolphinViewContainer::isSearchUrl(const QUrl& url) const { return url.scheme().contains(QStringLiteral("search")); } void DolphinViewContainer::saveViewState() { QByteArray locationState; QDataStream stream(&locationState, QIODevice::WriteOnly); m_view->saveState(stream); m_urlNavigator->saveLocationState(locationState); } void DolphinViewContainer::tryRestoreViewState() { QByteArray locationState = m_urlNavigator->locationState(); if (!locationState.isEmpty()) { QDataStream stream(&locationState, QIODevice::ReadOnly); m_view->restoreState(stream); } } diff --git a/src/dolphinviewcontainer.h b/src/dolphinviewcontainer.h index 993584b7a..b5bcc78ad 100644 --- a/src/dolphinviewcontainer.h +++ b/src/dolphinviewcontainer.h @@ -1,341 +1,344 @@ /*************************************************************************** * Copyright (C) 2007 by Peter Penz * * * * 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 * ***************************************************************************/ #ifndef DOLPHINVIEWCONTAINER_H #define DOLPHINVIEWCONTAINER_H #include "config-dolphin.h" #include "views/dolphinview.h" #include #include #include #include #include +#include #include #ifdef KF5Activities_FOUND namespace KActivities { class ResourceInstance; } #endif class FilterBar; class KMessageWidget; class QUrl; class KUrlNavigator; class DolphinSearchBox; class DolphinStatusBar; /** * @short Represents a view for the directory content * including the navigation bar, filter bar and status bar. * * View modes for icons, compact and details are supported. Currently * Dolphin allows to have up to two views inside the main window. * * @see DolphinView * @see FilterBar * @see KUrlNavigator * @see DolphinStatusBar */ class DolphinViewContainer : public QWidget { Q_OBJECT public: enum MessageType { Information, Warning, Error }; DolphinViewContainer(const QUrl& url, QWidget* parent); ~DolphinViewContainer() override; /** * Returns the current active URL, where all actions are applied. * The URL navigator is synchronized with this URL. */ QUrl url() const; /** * If \a active is true, the view container will marked as active. The active * view container is defined as view where all actions are applied to. */ void setActive(bool active); bool isActive() const; /** * If \a grab is set to true, the container automatically grabs the focus * as soon as the URL has been changed. Per default the grabbing * of the focus is enabled. */ void setAutoGrabFocus(bool grab); bool autoGrabFocus() const; QString currentSearchText() const; const DolphinStatusBar* statusBar() const; DolphinStatusBar* statusBar(); const KUrlNavigator* urlNavigator() const; KUrlNavigator* urlNavigator(); const DolphinView* view() const; DolphinView* view(); /** * Shows the message \msg with the given type non-modal above * the view-content. */ void showMessage(const QString& msg, MessageType type); /** * Refreshes the view container to get synchronized with the (updated) Dolphin settings. */ void readSettings(); /** Returns true, if the filter bar is visible. */ bool isFilterBarVisible() const; /** * Enables the search mode, if \p enabled is true. In the search mode the URL navigator * will be hidden and replaced by a line editor that allows to enter a search term. */ void setSearchModeEnabled(bool enabled); bool isSearchModeEnabled() const; /** * @return Text that should be used for the current URL when creating * a new place. */ QString placesText() const; /** * Reload the view of this container. This will also hide messages in a messagewidget. */ void reload(); public slots: /** * Sets the current active URL, where all actions are applied. The * URL navigator is synchronized with this URL. The signals * KUrlNavigator::urlChanged() and KUrlNavigator::historyChanged() * are emitted. * @see DolphinViewContainer::urlNavigator() */ void setUrl(const QUrl& url); /** * Popups the filter bar above the status bar if \a visible is true. * It \a visible is true, it is assured that the filter bar gains * the keyboard focus. */ void setFilterBarVisible(bool visible); signals: /** * Is emitted whenever the filter bar has changed its visibility state. */ void showFilterBarChanged(bool shown); /** * Is emitted when the write state of the folder has been changed. The application * should disable all actions like "Create New..." that depend on the write * state. */ void writeStateChanged(bool isFolderWritable); private slots: /** * Updates the number of items (= number of files + number of * directories) in the statusbar. If files are selected, the number * of selected files and the sum of the filesize is shown. The update * is done asynchronously, as getting the sum of the * filesizes can be an expensive operation. * Unless a previous OperationCompletedMessage was set very shortly before * calling this method, it will be overwritten (see DolphinStatusBar::setMessage). * Previous ErrorMessages however are always preserved. */ void delayedStatusBarUpdate(); /** * Is invoked by DolphinViewContainer::delayedStatusBarUpdate() and * updates the status bar synchronously. */ void updateStatusBar(); void updateDirectoryLoadingProgress(int percent); void updateDirectorySortingProgress(int percent); /** * Updates the statusbar to show an undetermined progress with the correct * context information whether a searching or a directory loading is done. */ void slotDirectoryLoadingStarted(); /** * Assures that the viewport position is restored and updates the * statusbar to reflect the current content. */ void slotDirectoryLoadingCompleted(); /** * Updates the statusbar to show, that the directory loading has * been canceled. */ void slotDirectoryLoadingCanceled(); /** * Is called if the URL set by DolphinView::setUrl() represents * a file and not a directory. Takes care to activate the file. */ void slotUrlIsFileError(const QUrl& url); /** * Handles clicking on an item. If the item is a directory, the * directory is opened in the view. If the item is a file, the file * gets started by the corresponding application. */ void slotItemActivated(const KFileItem& item); /** * Handles activation of multiple files. The files get started by * the corresponding applications. */ void slotItemsActivated(const KFileItemList& items); /** * Shows the information for the item \a item inside the statusbar. If the * item is null, the default statusbar information is shown. */ void showItemInfo(const KFileItem& item); void closeFilterBar(); /** * Filters the currently shown items by \a nameFilter. All items * which contain the given filter string will be shown. */ void setNameFilter(const QString& nameFilter); /** * Marks the view container as active * (see DolphinViewContainer::setActive()). */ void activate(); /** * Is invoked if the signal urlAboutToBeChanged() from the URL navigator * is emitted. Tries to save the view-state. */ void slotUrlNavigatorLocationAboutToBeChanged(const QUrl& url); /** * Restores the current view to show \a url and assures * that the root URL of the view is respected. */ void slotUrlNavigatorLocationChanged(const QUrl& url); /** * @see KUrlNavigator::urlSelectionRequested */ void slotUrlSelectionRequested(const QUrl& url); /** * Is invoked when a redirection is done and changes the * URL of the URL navigator to \a newUrl without triggering * a reloading of the directory. */ void redirect(const QUrl& oldUrl, const QUrl& newUrl); /** Requests the focus for the view \a m_view. */ void requestFocus(); /** * Saves the currently used URL completion mode of * the URL navigator. */ void saveUrlCompletionMode(KCompletion::CompletionMode completion); void slotReturnPressed(); /** * Gets the search URL from the searchbox and starts searching. */ void startSearching(); void closeSearchBox(); /** * Stops the loading of a directory. Is connected with the "stopPressed" signal * from the statusbar. */ void stopDirectoryLoading(); void slotStatusBarZoomLevelChanged(int zoomLevel); /** * Slot that calls showMessage(msg, Error). */ void showErrorMessage(const QString& msg); private: /** * @return True if the URL protocol is a search URL (e. g. baloosearch:// or filenamesearch://). */ bool isSearchUrl(const QUrl& url) const; /** * Saves the state of the current view: contents position, * root URL, ... */ void saveViewState(); /** * Restores the state of the current view iff the URL navigator contains a * non-empty location state. */ void tryRestoreViewState(); private: QVBoxLayout* m_topLayout; + QWidget* m_navigatorWidget; KUrlNavigator* m_urlNavigator; + QPushButton* m_emptyTrashButton; DolphinSearchBox* m_searchBox; KMessageWidget* m_messageWidget; DolphinView* m_view; FilterBar* m_filterBar; DolphinStatusBar* m_statusBar; QTimer* m_statusBarTimer; // Triggers a delayed update QElapsedTimer m_statusBarTimestamp; // Time in ms since last update bool m_autoGrabFocus; #ifdef KF5Activities_FOUND private: KActivities::ResourceInstance * m_activityResourceInstance; #endif }; #endif // DOLPHINVIEWCONTAINER_H