diff --git a/src/views/versioncontrol/kversioncontrolplugin.h b/src/views/versioncontrol/kversioncontrolplugin.h index 287974534..0d94a3fc8 100644 --- a/src/views/versioncontrol/kversioncontrolplugin.h +++ b/src/views/versioncontrol/kversioncontrolplugin.h @@ -1,224 +1,227 @@ /***************************************************************************** * Copyright (C) 2011 by Vishesh Yadav * * Copyright (C) 2011 by Peter Penz * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Library General Public * * License version 2 as published by the Free Software Foundation. * * * * This library 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 * * Library General Public License for more details. * * * * You should have received a copy of the GNU Library General Public License * * along with this library; see the file COPYING.LIB. If not, write to * * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * * Boston, MA 02110-1301, USA. * *****************************************************************************/ #ifndef KVERSIONCONTROLPLUGIN_H #define KVERSIONCONTROLPLUGIN_H #include #include #include class KFileItemList; class KFileItem; /** * @brief Base class for version control plugins. * * Enables the file manager to show the version state * of a versioned file. To write a custom plugin, the following * steps are required (in the example below it is assumed that a plugin for * Subversion will be written): * * - Create a fileviewsvnplugin.desktop file with the following content: * * [Desktop Entry] * Type=Service * Name=Subversion * X-KDE-ServiceTypes=FileViewVersionControlPlugin * MimeType=text/plain; * X-KDE-Library=fileviewsvnplugin * * * - Create a class FileViewSvnPlugin derived from KVersionControlPlugin and * implement all abstract interfaces (fileviewsvnplugin.h, fileviewsvnplugin.cpp). * * - Take care that the constructor has the following signature: * * FileViewSvnPlugin(QObject* parent, const QList& args); * * * - Add the following lines at the top of fileviewsvnplugin.cpp: * * #include * #include * K_PLUGIN_FACTORY(FileViewSvnPluginFactory, registerPlugin();) * K_EXPORT_PLUGIN(FileViewSvnPluginFactory("fileviewsvnplugin")) * * * - Add the following lines to your CMakeLists.txt file: * * kde4_add_plugin(fileviewsvnplugin fileviewsvnplugin.cpp) * target_link_libraries(fileviewsvnplugin konq) * install(FILES fileviewsvnplugin.desktop DESTINATION ${SERVICES_INSTALL_DIR}) * * * General implementation notes: * * - The implementations of beginRetrieval(), endRetrieval() and versionState() * can contain blocking operations, as Dolphin will execute * those methods in a separate thread. It is assured that * all other methods are invoked in a serialized way, so that it is not necessary for * the plugin to use any mutex. * * - Dolphin keeps only one instance of the plugin, which is instantiated shortly after * starting Dolphin. Take care that the constructor does no expensive and time * consuming operations. * * @since 4.8 */ class DOLPHINVCS_EXPORT KVersionControlPlugin : public QObject { Q_OBJECT public: enum ItemVersion { /** The file is not under version control. */ UnversionedVersion, /** * The file is under version control and represents * the latest version. */ NormalVersion, /** * The file is under version control and a newer * version exists on the main branch. */ UpdateRequiredVersion, /** * The file is under version control and has been * modified locally. All modifications will be part * of the next commit. */ LocallyModifiedVersion, /** * The file has not been under version control but * has been marked to get added with the next commit. */ AddedVersion, /** * The file is under version control but has been marked * for getting removed with the next commit. */ RemovedVersion, /** * The file is under version control and has been locally * modified. A modification has also been done on the main * branch. */ ConflictingVersion, /** * The file is under version control and has local * modifications, which will not be part of the next * commit (or are "unstaged" in git jargon). * @since 4.6 */ LocallyModifiedUnstagedVersion, /** * The file is not under version control and is listed * in the ignore list of the version control system. * @since 4.8 */ IgnoredVersion, /** * The file is tracked by the version control system, but * is missing in the directory (e.g. by deleted without using * a version control command). * @since 4.8 */ MissingVersion }; KVersionControlPlugin(QObject* parent = nullptr); ~KVersionControlPlugin() override; /** * Returns the name of the file which stores * the version controls information. * (e. g. .svn, .cvs, .git). */ virtual QString fileName() const = 0; /** * Is invoked whenever the version control * information will get retrieved for the directory * \p directory. It is assured that the directory * contains a trailing slash. */ virtual bool beginRetrieval(const QString& directory) = 0; /** * Is invoked after the version control information has been * received. It is assured that * KVersionControlPlugin::beginRetrieval() has been * invoked before. */ virtual void endRetrieval() = 0; /** * @return The version for the item \p item. * It is assured that KVersionControlPlugin::beginRetrieval() has been * invoked before and that the file is part of the directory specified * in beginRetrieval(). */ virtual ItemVersion itemVersion(const KFileItem& item) const = 0; /** - * @return List of actions that are available for the items \p items. - * It is recommended to keep the number of returned actions small - * in case if an item is an unversioned directory that is not - * inside the hierarchy tree of the version control system. This - * prevents having a cluttered context menu for directories - * outside the version control system. + * @return List of actions that are available for the \p items in a version controlled + * path. */ - virtual QList actions(const KFileItemList& items) const = 0; + virtual QList versionControlActions(const KFileItemList& items) const = 0; + + /** + * @return List of actions that are available for the out of version control + * items \p items. It's opposed to the \p versionedActions. Common usage + * is for clone/checkout actions. + */ + virtual QList outOfVersionControlActions(const KFileItemList& items) const = 0; Q_SIGNALS: /** * Should be emitted when the version state of items might have been changed * after the last retrieval (e. g. by executing a context menu action * of the version control plugin). The file manager will be triggered to * update the version states of the directory \p directory by invoking * KVersionControlPlugin::beginRetrieval(), * KVersionControlPlugin::itemVersion() and * KVersionControlPlugin::endRetrieval(). */ void itemVersionsChanged(); /** * 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); }; #endif // KVERSIONCONTROLPLUGIN_H diff --git a/src/views/versioncontrol/versioncontrolobserver.cpp b/src/views/versioncontrol/versioncontrolobserver.cpp index 2d801686e..f6c74fb5f 100644 --- a/src/views/versioncontrol/versioncontrolobserver.cpp +++ b/src/views/versioncontrol/versioncontrolobserver.cpp @@ -1,367 +1,375 @@ /*************************************************************************** * 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::slotItemsChanged); } m_model = model; if (model) { connect(m_model, &KFileItemModel::itemsInserted, this, &VersionControlObserver::delayedDirectoryVerification); connect(m_model, &KFileItemModel::itemsChanged, 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()) { + if (!m_model || hasNullItems) { return {}; } - return m_plugin->actions(items); + if (isVersionControlled()) { + return m_plugin->versionControlActions(items); + } else { + QList actions; + for (const auto &plugin : qAsConst(m_plugins)) { + actions << plugin.first->outOfVersionControlActions(items); + } + return actions; + } } 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( qMakePair(plugin, plugin->fileName()) ); } } } 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, ... for (const auto &it : qAsConst(m_plugins)) { const QString fileName = directory.path() + '/' + it.second; 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 it.first; } // 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() + '/' + it.second; if (QFile::exists(fileName)) { if (upUrlCounter < bestScore) { bestPlugin = it.first; bestScore = upUrlCounter; } break; } dirUrl = upUrl; upUrl = KIO::upUrl(dirUrl); ++upUrlCounter; } } } return bestPlugin; } -bool VersionControlObserver::isVersioned() const +bool VersionControlObserver::isVersionControlled() const { return m_versionedDirectory && m_plugin; } diff --git a/src/views/versioncontrol/versioncontrolobserver.h b/src/views/versioncontrol/versioncontrolobserver.h index 66f992963..648c9d6fd 100644 --- a/src/views/versioncontrol/versioncontrolobserver.h +++ b/src/views/versioncontrol/versioncontrolobserver.h @@ -1,168 +1,168 @@ /*************************************************************************** * 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; typedef QPair VCSPlugin; 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; + bool isVersionControlled() 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