diff --git a/src/views/versioncontrol/versioncontrolobserver.cpp b/src/views/versioncontrol/versioncontrolobserver.cpp index fc74390a9..65c13ef7d 100644 --- a/src/views/versioncontrol/versioncontrolobserver.cpp +++ b/src/views/versioncontrol/versioncontrolobserver.cpp @@ -1,355 +1,367 @@ /*************************************************************************** * Copyright (C) 2009 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 "versioncontrolobserver.h" #include "dolphin_versioncontrolsettings.h" #include "dolphindebug.h" #include "views/dolphinview.h" #include "kitemviews/kfileitemmodel.h" #include "updateitemstatesthread.h" #include #include #include #include VersionControlObserver::VersionControlObserver(QObject* parent) : QObject(parent), m_pendingItemStatesUpdate(false), m_versionedDirectory(false), m_silentUpdate(false), m_view(nullptr), m_model(nullptr), m_dirVerificationTimer(nullptr), m_pluginsInitialized(false), m_plugin(nullptr), m_updateItemStatesThread(nullptr) { // The verification timer specifies the timeout until the shown directory // is checked whether it is versioned. Per default it is assumed that users // don't iterate through versioned directories and a high timeout is used // The timeout will be decreased as soon as a versioned directory has been // found (see verifyDirectory()). m_dirVerificationTimer = new QTimer(this); m_dirVerificationTimer->setSingleShot(true); m_dirVerificationTimer->setInterval(500); connect(m_dirVerificationTimer, &QTimer::timeout, this, &VersionControlObserver::verifyDirectory); } VersionControlObserver::~VersionControlObserver() { if (m_plugin) { m_plugin->disconnect(this); m_plugin = nullptr; } } void VersionControlObserver::setModel(KFileItemModel* model) { if (m_model) { disconnect(m_model, &KFileItemModel::itemsInserted, this, &VersionControlObserver::delayedDirectoryVerification); disconnect(m_model, &KFileItemModel::itemsChanged, - this, &VersionControlObserver::delayedDirectoryVerification); + this, &VersionControlObserver::slotItemsChanged); } m_model = model; if (model) { connect(m_model, &KFileItemModel::itemsInserted, this, &VersionControlObserver::delayedDirectoryVerification); connect(m_model, &KFileItemModel::itemsChanged, - this, &VersionControlObserver::delayedDirectoryVerification); + this, &VersionControlObserver::slotItemsChanged); } } KFileItemModel* VersionControlObserver::model() const { return m_model; } void VersionControlObserver::setView(DolphinView* view) { if (m_view) { disconnect(m_view, &DolphinView::activated, this, &VersionControlObserver::delayedDirectoryVerification); } m_view = view; if (m_view) { connect(m_view, &DolphinView::activated, this, &VersionControlObserver::delayedDirectoryVerification); } } DolphinView* VersionControlObserver::view() const { return m_view; } QList VersionControlObserver::actions(const KFileItemList& items) const { bool hasNullItems = false; foreach (const KFileItem& item, items) { if (item.isNull()) { qCWarning(DolphinDebug) << "Requesting version-control-actions for empty items"; hasNullItems = true; break; } } if (!m_model || hasNullItems || !isVersioned()) { return {}; } return m_plugin->actions(items); } void VersionControlObserver::delayedDirectoryVerification() { m_silentUpdate = false; m_dirVerificationTimer->start(); } void VersionControlObserver::silentDirectoryVerification() { m_silentUpdate = true; m_dirVerificationTimer->start(); } +void VersionControlObserver::slotItemsChanged(const KItemRangeList& itemRanges, const QSet& roles) +{ + Q_UNUSED(itemRanges) + + // Because "version" role is emitted by VCS plugin (ourselfs) we don't need to + // analyze it and update directory item states information. So lets check if + // there is only "version". + if ( !(roles.count() == 1 && roles.contains("version")) ) { + delayedDirectoryVerification(); + } +} + void VersionControlObserver::verifyDirectory() { if (!m_model) { return; } const KFileItem rootItem = m_model->rootItem(); if (rootItem.isNull() || !rootItem.url().isLocalFile()) { return; } if (m_plugin) { m_plugin->disconnect(this); } m_plugin = searchPlugin(rootItem.url()); if (m_plugin) { connect(m_plugin, &KVersionControlPlugin::itemVersionsChanged, this, &VersionControlObserver::silentDirectoryVerification); connect(m_plugin, &KVersionControlPlugin::infoMessage, this, &VersionControlObserver::infoMessage); connect(m_plugin, &KVersionControlPlugin::errorMessage, this, &VersionControlObserver::errorMessage); connect(m_plugin, &KVersionControlPlugin::operationCompletedMessage, this, &VersionControlObserver::operationCompletedMessage); if (!m_versionedDirectory) { m_versionedDirectory = true; // The directory is versioned. Assume that the user will further browse through // versioned directories and decrease the verification timer. m_dirVerificationTimer->setInterval(100); } updateItemStates(); } else if (m_versionedDirectory) { m_versionedDirectory = false; // The directory is not versioned. Reset the verification timer to a higher // value, so that browsing through non-versioned directories is not slown down // by an immediate verification. m_dirVerificationTimer->setInterval(500); } } void VersionControlObserver::slotThreadFinished() { UpdateItemStatesThread* thread = m_updateItemStatesThread; m_updateItemStatesThread = nullptr; // The thread deletes itself automatically (see updateItemStates()) if (!m_plugin || !thread) { return; } const QMap >& itemStates = thread->itemStates(); QMap >::const_iterator it = itemStates.constBegin(); for (; it != itemStates.constEnd(); ++it) { const QVector& items = it.value(); foreach (const ItemState& item, items) { const KFileItem& fileItem = item.first; const KVersionControlPlugin::ItemVersion version = item.second; QHash values; values.insert("version", QVariant(version)); m_model->setData(m_model->index(fileItem), values); } } if (!m_silentUpdate) { // Using an empty message results in clearing the previously shown information message and showing // the default status bar information. This is useful as the user already gets feedback that the // operation has been completed because of the icon emblems. emit operationCompletedMessage(QString()); } if (m_pendingItemStatesUpdate) { m_pendingItemStatesUpdate = false; updateItemStates(); } } void VersionControlObserver::updateItemStates() { Q_ASSERT(m_plugin); if (m_updateItemStatesThread) { // An update is currently ongoing. Wait until the thread has finished // the update (see slotThreadFinished()). m_pendingItemStatesUpdate = true; return; } QMap > itemStates; createItemStatesList(itemStates); if (!itemStates.isEmpty()) { if (!m_silentUpdate) { emit infoMessage(i18nc("@info:status", "Updating version information...")); } m_updateItemStatesThread = new UpdateItemStatesThread(m_plugin, itemStates); connect(m_updateItemStatesThread, &UpdateItemStatesThread::finished, this, &VersionControlObserver::slotThreadFinished); connect(m_updateItemStatesThread, &UpdateItemStatesThread::finished, m_updateItemStatesThread, &UpdateItemStatesThread::deleteLater); m_updateItemStatesThread->start(); // slotThreadFinished() is called when finished } } int VersionControlObserver::createItemStatesList(QMap >& itemStates, const int firstIndex) { const int itemCount = m_model->count(); const int currentExpansionLevel = m_model->expandedParentsCount(firstIndex); QVector items; items.reserve(itemCount - firstIndex); int index; for (index = firstIndex; index < itemCount; ++index) { const int expansionLevel = m_model->expandedParentsCount(index); if (expansionLevel == currentExpansionLevel) { ItemState itemState; itemState.first = m_model->fileItem(index); itemState.second = KVersionControlPlugin::UnversionedVersion; items.append(itemState); } else if (expansionLevel > currentExpansionLevel) { // Sub folder index += createItemStatesList(itemStates, index) - 1; } else { break; } } if (!items.isEmpty()) { const QUrl& url = items.first().first.url(); itemStates.insert(url.adjusted(QUrl::RemoveFilename).path(), items); } return index - firstIndex; // number of processed items } KVersionControlPlugin* VersionControlObserver::searchPlugin(const QUrl& directory) { if (!m_pluginsInitialized) { // No searching for plugins has been done yet. Query the KServiceTypeTrader for // all fileview version control plugins and remember them in 'plugins'. const QStringList enabledPlugins = VersionControlSettings::enabledPlugins(); const KService::List pluginServices = KServiceTypeTrader::self()->query(QStringLiteral("FileViewVersionControlPlugin")); for (KService::List::ConstIterator it = pluginServices.constBegin(); it != pluginServices.constEnd(); ++it) { if (enabledPlugins.contains((*it)->name())) { KVersionControlPlugin* plugin = (*it)->createInstance(this); if (plugin) { m_plugins.append(plugin); } } } m_pluginsInitialized = true; } if (m_plugins.empty()) { // A searching for plugins has already been done, but no // plugins are installed return nullptr; } // We use the number of upUrl() calls to find the best matching plugin // for the given directory. The smaller value, the better it is (0 is best). KVersionControlPlugin* bestPlugin = nullptr; int bestScore = INT_MAX; // Verify whether the current directory contains revision information // like .svn, .git, ... foreach (KVersionControlPlugin* plugin, m_plugins) { const QString fileName = directory.path() + '/' + plugin->fileName(); if (QFile::exists(fileName)) { // The score of this plugin is 0 (best), so we can just return this plugin, // instead of going through the plugin scoring procedure, we can't find a better one ;) return plugin; } // Version control systems like Git provide the version information // file only in the root directory. Check whether the version information file can // be found in one of the parent directories. For performance reasons this // step is only done, if the previous directory was marked as versioned by // m_versionedDirectory. Drawback: Until e. g. Git is recognized, the root directory // must be shown at least once. if (m_versionedDirectory) { QUrl dirUrl(directory); QUrl upUrl = KIO::upUrl(dirUrl); int upUrlCounter = 1; while ((upUrlCounter < bestScore) && (upUrl != dirUrl)) { const QString fileName = dirUrl.path() + '/' + plugin->fileName(); if (QFile::exists(fileName)) { if (upUrlCounter < bestScore) { bestPlugin = plugin; bestScore = upUrlCounter; } break; } dirUrl = upUrl; upUrl = KIO::upUrl(dirUrl); ++upUrlCounter; } } } return bestPlugin; } bool VersionControlObserver::isVersioned() const { return m_versionedDirectory && m_plugin; } diff --git a/src/views/versioncontrol/versioncontrolobserver.h b/src/views/versioncontrol/versioncontrolobserver.h index 08279dc86..7b269abec 100644 --- a/src/views/versioncontrol/versioncontrolobserver.h +++ b/src/views/versioncontrol/versioncontrolobserver.h @@ -1,160 +1,167 @@ /*************************************************************************** * Copyright (C) 2009 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 VERSIONCONTROLOBSERVER_H #define VERSIONCONTROLOBSERVER_H #include "dolphin_export.h" #include "kversioncontrolplugin.h" #include #include #include #include #include class KFileItemList; class KFileItemModel; +class KItemRangeList; class QAction; class QTimer; class UpdateItemStatesThread; class DolphinView; /** * @brief Observes all version control plugins. * * The items of the directory-model get updated automatically if the currently * shown directory is under version control. * * @see VersionControlPlugin */ class DOLPHIN_EXPORT VersionControlObserver : public QObject { Q_OBJECT public: explicit VersionControlObserver(QObject* parent = nullptr); ~VersionControlObserver() override; void setModel(KFileItemModel* model); KFileItemModel* model() const; void setView(DolphinView* view); DolphinView* view() const; QList actions(const KFileItemList& items) const; signals: /** * Is emitted if an information message with the content \a msg * should be shown. */ void infoMessage(const QString& msg); /** * Is emitted if an error message with the content \a msg * should be shown. */ void errorMessage(const QString& msg); /** * Is emitted if an "operation completed" message with the content \a msg * should be shown. */ void operationCompletedMessage(const QString& msg); private slots: /** * Invokes verifyDirectory() with a small delay. If delayedDirectoryVerification() * is invoked before the delay has been exceeded, the delay will be reset. This * assures that a lot of short requests for directory verification only result * in one (expensive) call. */ void delayedDirectoryVerification(); /** * Invokes verifyDirectory() with a small delay. In opposite to * delayedDirectoryVerification() it and assures that the verification of * the directory is done silently without information messages. */ void silentDirectoryVerification(); + /** + * Invokes delayedDirectoryVerification() only if the itemsChanged() signal has not + * been triggered by the VCS plugin itself. + */ + void slotItemsChanged(const KItemRangeList& itemRanges, const QSet& roles); + void verifyDirectory(); /** * Is invoked if the thread m_updateItemStatesThread has been finished * and applys the item states. */ void slotThreadFinished(); private: typedef QPair ItemState; void updateItemStates(); /** * It creates a item state list for every expanded directory and stores * this list together with the directory url in the \a itemStates map. * * @itemStates A map of item state lists for every expanded directory * and its items, where the "key" is the directory url and * the "value" is a list of ItemStates for every item * within this directory. * @firstIndex The index to start the processing from, this is needed * because this function is recursively called. * * @return The number of (recursive) processed items. */ int createItemStatesList(QMap >& itemStates, const int firstIndex = 0); /** * Returns a matching plugin for the given directory. * 0 is returned, if no matching plugin has been found. */ KVersionControlPlugin* searchPlugin(const QUrl& directory); /** * Returns true, if the directory contains a version control information. */ bool isVersioned() const; private: bool m_pendingItemStatesUpdate; bool m_versionedDirectory; bool m_silentUpdate; // if true, no messages will be send during the update // of version states DolphinView* m_view; KFileItemModel* m_model; QTimer* m_dirVerificationTimer; bool m_pluginsInitialized; KVersionControlPlugin* m_plugin; QList m_plugins; UpdateItemStatesThread* m_updateItemStatesThread; friend class UpdateItemStatesThread; }; #endif // REVISIONCONTROLOBSERVER_H