diff --git a/plugins/patchreview/patchreview.cpp b/plugins/patchreview/patchreview.cpp
index 06d514945..d9226a04a 100644
--- a/plugins/patchreview/patchreview.cpp
+++ b/plugins/patchreview/patchreview.cpp
@@ -1,627 +1,630 @@
 /***************************************************************************
    Copyright 2006-2009 David Nolden <david.nolden.kdevelop@art-master.de>
 ***************************************************************************/
 
 /***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/
 
 #include "patchreview.h"
 
 #include <QDir>
 #include <QFileInfo>
 #include <QStandardPaths>
 #include <QTimer>
 #include <QMimeDatabase>
 
 #include <KActionCollection>
 #include <KLocalizedString>
 #include <KPluginFactory>
 #include <KMessageBox>
 #include <KIO/CopyJob>
 
 #include <interfaces/idocument.h>
 #include <interfaces/icore.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/iuicontroller.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/context.h>
 #include <interfaces/editorcontext.h>
 
 #include <project/projectmodel.h>
 
 #include <util/path.h>
 
 #include <libkomparediff2/komparemodellist.h>
 #include <libkomparediff2/kompare.h>
 #include <libkomparediff2/diffsettings.h>
 
 #include <ktexteditor/document.h>
 #include <ktexteditor/modificationinterface.h>
 #include <ktexteditor/movingrange.h>
 #include <ktexteditor/view.h>
 
 ///Whether arbitrary exceptions that occurred while diff-parsing within the library should be caught
 #define CATCHLIBDIFF
 
 /* Exclude this file from doublequote_chars check as krazy doesn't understand
    std::string*/
 //krazy:excludeall=doublequote_chars
 #include <sublime/controller.h>
 #include <sublime/mainwindow.h>
 #include <sublime/area.h>
 #include <sublime/document.h>
 #include <sublime/view.h>
 #include "patchhighlighter.h"
 #include "patchreviewtoolview.h"
 #include "localpatchsource.h"
 #include "debug.h"
 
 
 Q_LOGGING_CATEGORY(PLUGIN_PATCHREVIEW, "kdevplatform.plugins.patchreview")
 
 using namespace KDevelop;
 
 namespace
 {
 // Maximum number of files to open directly within a tab when the review is started
 const int maximumFilesToOpenDirectly = 15;
 }
 
 Q_DECLARE_METATYPE( const Diff2::DiffModel* )
 
 void PatchReviewPlugin::seekHunk( bool forwards, const QUrl& fileName ) {
     try {
         qCDebug(PLUGIN_PATCHREVIEW) << forwards << fileName << fileName.isEmpty();
         if ( !m_modelList )
             throw "no model";
 
         for ( int a = 0; a < m_modelList->modelCount(); ++a ) {
             const Diff2::DiffModel* model = m_modelList->modelAt( a );
             if ( !model || !model->differences() )
                 continue;
 
             QUrl file = urlForFileModel( model );
 
             if ( !fileName.isEmpty() && fileName != file )
                 continue;
 
             IDocument* doc = ICore::self()->documentController()->documentForUrl( file );
 
             if ( doc && m_highlighters.contains( doc->url() ) && m_highlighters[doc->url()] ) {
                 if ( doc->textDocument() ) {
                     const QList<KTextEditor::MovingRange*> ranges = m_highlighters[doc->url()]->ranges();
 
                     KTextEditor::View * v = doc->activeTextView();
                     int bestLine = -1;
                     if ( v ) {
                         KTextEditor::Cursor c = v->cursorPosition();
                         for ( QList<KTextEditor::MovingRange*>::const_iterator it = ranges.begin(); it != ranges.end(); ++it ) {
                             int line = ( *it )->start().line();
 
                             if ( forwards ) {
                                 if ( line > c.line() && ( bestLine == -1 || line < bestLine ) )
                                     bestLine = line;
                             } else {
                                 if ( line < c.line() && ( bestLine == -1 || line > bestLine ) )
                                     bestLine = line;
                             }
                         }
                         if ( bestLine != -1 ) {
                             v->setCursorPosition( KTextEditor::Cursor( bestLine, 0 ) );
                             return;
                         } else if(fileName.isEmpty()) {
                             int next = qBound(0, forwards ? a+1 : a-1, m_modelList->modelCount()-1);
                             if (next < maximumFilesToOpenDirectly) {
                                 ICore::self()->documentController()->openDocument(urlForFileModel(m_modelList->modelAt(next)));
                             }
                         }
                     }
                 }
             }
         }
     } catch ( const QString & str ) {
         qCDebug(PLUGIN_PATCHREVIEW) << "seekHunk():" << str;
     } catch ( const char * str ) {
         qCDebug(PLUGIN_PATCHREVIEW) << "seekHunk():" << str;
     }
     qCDebug(PLUGIN_PATCHREVIEW) << "no matching hunk found";
 }
 
 void PatchReviewPlugin::addHighlighting( const QUrl& highlightFile, IDocument* document ) {
     try {
         if ( !modelList() )
             throw "no model";
 
         for ( int a = 0; a < modelList()->modelCount(); ++a ) {
             Diff2::DiffModel* model = modelList()->modelAt( a );
             if ( !model )
                 continue;
 
             QUrl file = urlForFileModel( model );
 
             if ( file != highlightFile )
                 continue;
 
             qCDebug(PLUGIN_PATCHREVIEW) << "highlighting" << file.toDisplayString();
 
             IDocument* doc = document;
             if( !doc )
                 doc = ICore::self()->documentController()->documentForUrl( file );
 
             qCDebug(PLUGIN_PATCHREVIEW) << "highlighting file" << file << "with doc" << doc;
 
             if ( !doc || !doc->textDocument() )
                 continue;
 
             removeHighlighting( file );
 
             m_highlighters[file] = new PatchHighlighter( model, doc, this, dynamic_cast<LocalPatchSource*>(m_patch.data()) == nullptr );
         }
     } catch ( const QString & str ) {
         qCDebug(PLUGIN_PATCHREVIEW) << "highlightFile():" << str;
     } catch ( const char * str ) {
         qCDebug(PLUGIN_PATCHREVIEW) << "highlightFile():" << str;
     }
 }
 
 void PatchReviewPlugin::highlightPatch() {
     try {
         if ( !modelList() )
             throw "no model";
 
         for ( int a = 0; a < modelList()->modelCount(); ++a ) {
             const Diff2::DiffModel* model = modelList()->modelAt( a );
             if ( !model )
                 continue;
 
             QUrl file = urlForFileModel( model );
 
             addHighlighting( file );
         }
     } catch ( const QString & str ) {
         qCDebug(PLUGIN_PATCHREVIEW) << "highlightFile():" << str;
     } catch ( const char * str ) {
         qCDebug(PLUGIN_PATCHREVIEW) << "highlightFile():" << str;
     }
 }
 
 void PatchReviewPlugin::removeHighlighting( const QUrl& file ) {
     if ( file.isEmpty() ) {
         ///Remove all highlighting
         qDeleteAll( m_highlighters );
         m_highlighters.clear();
     } else {
         HighlightMap::iterator it = m_highlighters.find( file );
         if ( it != m_highlighters.end() ) {
             delete *it;
             m_highlighters.erase( it );
         }
     }
 }
 
 void PatchReviewPlugin::notifyPatchChanged() {
     if (m_patch) {
         qCDebug(PLUGIN_PATCHREVIEW) << "notifying patch change: " << m_patch->file();
         m_updateKompareTimer->start( 500 );
     } else {
         m_updateKompareTimer->stop();
     }
 }
 
 void PatchReviewPlugin::forceUpdate() {
     if( m_patch ) {
-        m_patch->update();
-
-        notifyPatchChanged();
+        // don't trigger an update if we know the plugin cannot update itself
+        VCSDiffPatchSource *vcsPatch = dynamic_cast<VCSDiffPatchSource*>(m_patch.data());
+        if (!vcsPatch || vcsPatch->m_updater) {
+            m_patch->update();
+            notifyPatchChanged();
+        }
     }
 }
 
 void PatchReviewPlugin::updateKompareModel() {
     if ( !m_patch ) {
         ///TODO: this method should be cleaned up, it can be called by the timer and
         ///      e.g. https://bugs.kde.org/show_bug.cgi?id=267187 shows how it could
         ///      lead to asserts before...
         return;
     }
 
     qCDebug(PLUGIN_PATCHREVIEW) << "updating model";
     removeHighlighting();
     m_modelList.reset( nullptr );
     m_depth = 0;
     delete m_diffSettings;
     {
         IDocument* patchDoc = ICore::self()->documentController()->documentForUrl( m_patch->file() );
         if( patchDoc )
             patchDoc->reload();
     }
 
     QString patchFile;
     if( m_patch->file().isLocalFile() )
         patchFile = m_patch->file().toLocalFile();
     else if( m_patch->file().isValid() && !m_patch->file().isEmpty() ) {
         patchFile = QStandardPaths::writableLocation(QStandardPaths::TempLocation);
         bool ret = KIO::copy(m_patch->file(), QUrl::fromLocalFile(patchFile), KIO::HideProgressInfo)->exec();
         if( !ret ) {
             qCWarning(PLUGIN_PATCHREVIEW) << "Problem while downloading: " << m_patch->file() << "to" << patchFile;
             patchFile.clear();
         }
     }
 
     if (!patchFile.isEmpty()) //only try to construct the model if we have a patch to load
     try {
         m_diffSettings = new DiffSettings( nullptr );
         m_kompareInfo.reset( new Kompare::Info() );
         m_kompareInfo->localDestination = patchFile;
         m_kompareInfo->localSource = m_patch->baseDir().toLocalFile();
         m_kompareInfo->depth = m_patch->depth();
         m_kompareInfo->applied = m_patch->isAlreadyApplied();
 
         m_modelList.reset( new Diff2::KompareModelList( m_diffSettings.data(), new QWidget, this ) );
         m_modelList->slotKompareInfo( m_kompareInfo.data() );
 
         try {
             m_modelList->openDirAndDiff();
         } catch ( const QString & str ) {
             throw;
         } catch ( ... ) {
             throw QStringLiteral( "lib/libdiff2 crashed, memory may be corrupted. Please restart kdevelop." );
         }
 
         for (m_depth = 0; m_depth < 10; ++m_depth) {
             bool allFound = true;
             for( int i = 0; i < m_modelList->modelCount(); i++ ) {
                 if (!QFile::exists(urlForFileModel(m_modelList->modelAt(i)).toLocalFile())) {
                     allFound = false;
                 }
             }
             if (allFound) {
                 break; // found depth
             }
         }
 
         emit patchChanged();
 
         for( int i = 0; i < m_modelList->modelCount(); i++ ) {
             const Diff2::DiffModel* model = m_modelList->modelAt( i );
             for( int j = 0; j < model->differences()->count(); j++ ) {
                 model->differences()->at( j )->apply( m_patch->isAlreadyApplied() );
             }
         }
 
         highlightPatch();
 
         return;
     } catch ( const QString & str ) {
         KMessageBox::error( nullptr, str, i18n( "Kompare Model Update" ) );
     } catch ( const char * str ) {
         KMessageBox::error( nullptr, str, i18n( "Kompare Model Update" ) );
     }
     removeHighlighting();
     m_modelList.reset( nullptr );
     m_depth = 0;
     m_kompareInfo.reset( nullptr );
     delete m_diffSettings;
 
     emit patchChanged();
 }
 
 K_PLUGIN_FACTORY_WITH_JSON(KDevProblemReporterFactory, "kdevpatchreview.json", registerPlugin<PatchReviewPlugin>();)
 
 class PatchReviewToolViewFactory : public KDevelop::IToolViewFactory
 {
 public:
     PatchReviewToolViewFactory( PatchReviewPlugin *plugin ) : m_plugin( plugin ) {}
 
     QWidget* create( QWidget *parent = nullptr ) override {
         return new PatchReviewToolView( parent, m_plugin );
     }
 
     Qt::DockWidgetArea defaultPosition() override {
         return Qt::BottomDockWidgetArea;
     }
 
     QString id() const override {
         return QStringLiteral("org.kdevelop.PatchReview");
     }
 
 private:
     PatchReviewPlugin *m_plugin;
 };
 
 PatchReviewPlugin::~PatchReviewPlugin()
 {
     removeHighlighting();
 
     // Tweak to work around a crash on OS X; see https://bugs.kde.org/show_bug.cgi?id=338829
     // and http://qt-project.org/forums/viewthread/38406/#162801
     // modified tweak: use setPatch() and deleteLater in that method.
     setPatch(nullptr);
 }
 
 void PatchReviewPlugin::clearPatch( QObject* _patch ) {
     qCDebug(PLUGIN_PATCHREVIEW) << "clearing patch" << _patch << "current:" << ( QObject* )m_patch;
     IPatchSource::Ptr patch( ( IPatchSource* )_patch );
 
     if( patch == m_patch ) {
         qCDebug(PLUGIN_PATCHREVIEW) << "is current patch";
         setPatch( IPatchSource::Ptr( new LocalPatchSource ) );
     }
 }
 
 void PatchReviewPlugin::closeReview()
 {
     if( m_patch ) {
         IDocument* patchDocument = ICore::self()->documentController()->documentForUrl( m_patch->file() );
         if (patchDocument) {
             // Revert modifications to the text document which we've done in updateReview
             patchDocument->setPrettyName( QString() );
             patchDocument->textDocument()->setReadWrite( true );
             KTextEditor::ModificationInterface* modif = dynamic_cast<KTextEditor::ModificationInterface*>( patchDocument->textDocument() );
             modif->setModifiedOnDiskWarning( true );
         }
 
         removeHighlighting();
         m_modelList.reset( nullptr );
         m_depth = 0;
 
         if( !dynamic_cast<LocalPatchSource*>( m_patch.data() ) ) {
             // make sure "show" button still openes the file dialog to open a custom patch file
             setPatch( new LocalPatchSource );
         } else
             emit patchChanged();
 
         Sublime::Area* area = ICore::self()->uiController()->activeArea();
         if( area->objectName() == QLatin1String("review") ) {
             if( ICore::self()->documentController()->saveAllDocuments() )
                 ICore::self()->uiController()->switchToArea( QStringLiteral("code"), KDevelop::IUiController::ThisWindow );
         }
     }
 }
 
 void PatchReviewPlugin::cancelReview() {
     if( m_patch ) {
         m_patch->cancelReview();
         closeReview();
     }
 }
 
 void PatchReviewPlugin::finishReview( QList<QUrl> selection ) {
     if( m_patch && m_patch->finishReview( selection ) ) {
         closeReview();
     }
 }
 
 void PatchReviewPlugin::startReview( IPatchSource* patch, IPatchReview::ReviewMode mode ) {
     Q_UNUSED( mode );
     emit startingNewReview();
     setPatch( patch );
     QMetaObject::invokeMethod( this, "updateReview", Qt::QueuedConnection );
 }
 
 void PatchReviewPlugin::switchToEmptyReviewArea()
 {
     foreach(Sublime::Area* area, ICore::self()->uiController()->allAreas()) {
         if (area->objectName() == QLatin1String("review")) {
             area->clearDocuments();
         }
     }
 
     if ( ICore::self()->uiController()->activeArea()->objectName() != QLatin1String("review") )
         ICore::self()->uiController()->switchToArea( QStringLiteral("review"), KDevelop::IUiController::ThisWindow );
 }
 
 QUrl PatchReviewPlugin::urlForFileModel( const Diff2::DiffModel* model )
 {
     KDevelop::Path path(QDir::cleanPath(m_patch->baseDir().toLocalFile()));
     QVector<QString> destPath = KDevelop::Path("/"+model->destinationPath()).segments();
     if (destPath.size() >= (int)m_depth) {
         destPath = destPath.mid(m_depth);
     }
     foreach(QString segment, destPath) {
         path.addPath(segment);
     }
     path.addPath(model->destinationFile());
 
     return path.toUrl();
 }
 
 void PatchReviewPlugin::updateReview()
 {
     if( !m_patch )
         return;
 
     m_updateKompareTimer->stop();
 
     switchToEmptyReviewArea();
 
     KDevelop::IDocumentController *docController = ICore::self()->documentController();
     // don't add documents opened automatically to the Files/Open Recent list
     IDocument* futureActiveDoc = docController->openDocument( m_patch->file(), KTextEditor::Range::invalid(),
                                                               IDocumentController::DoNotAddToRecentOpen );
 
     updateKompareModel();
 
     if ( !m_modelList || !futureActiveDoc || !futureActiveDoc->textDocument() ) {
         // might happen if e.g. openDocument dialog was cancelled by user
         // or under the theoretic possibility of a non-text document getting opened
         return;
     }
 
     futureActiveDoc->textDocument()->setReadWrite( false );
     futureActiveDoc->setPrettyName( i18n( "Overview" ) );
     KTextEditor::ModificationInterface* modif = dynamic_cast<KTextEditor::ModificationInterface*>( futureActiveDoc->textDocument() );
     modif->setModifiedOnDiskWarning( false );
 
     docController->activateDocument( futureActiveDoc );
 
     PatchReviewToolView* toolView = qobject_cast<PatchReviewToolView*>(ICore::self()->uiController()->findToolView( i18n( "Patch Review" ), m_factory ));
     Q_ASSERT( toolView );
 
     //Open all relates files
     for( int a = 0; a < m_modelList->modelCount() && a < maximumFilesToOpenDirectly; ++a ) {
         QUrl absoluteUrl = urlForFileModel( m_modelList->modelAt( a ) );
         if (absoluteUrl.isRelative()) {
             KMessageBox::error( nullptr, i18n("The base directory of the patch must be an absolute directory"), i18n( "Patch Review" ) );
             break;
         }
 
         if( QFileInfo::exists( absoluteUrl.toLocalFile() ) && absoluteUrl.toLocalFile() != QLatin1String("/dev/null") )
         {
             toolView->open( absoluteUrl, false );
         }else{
             // Maybe the file was deleted
             qCDebug(PLUGIN_PATCHREVIEW) << "could not open" << absoluteUrl << "because it doesn't exist";
         }
     }
 }
 
 void PatchReviewPlugin::setPatch( IPatchSource* patch ) {
     if ( patch == m_patch ) {
         return;
     }
 
     if( m_patch ) {
         disconnect( m_patch.data(), &IPatchSource::patchChanged, this, &PatchReviewPlugin::notifyPatchChanged );
         if ( qobject_cast<LocalPatchSource*>( m_patch ) ) {
             // make sure we don't leak this
             // TODO: what about other patch sources?
             m_patch->deleteLater();
         }
     }
     m_patch = patch;
 
     if( m_patch ) {
         qCDebug(PLUGIN_PATCHREVIEW) << "setting new patch" << patch->name() << "with file" << patch->file() << "basedir" << patch->baseDir();
 
         connect( m_patch.data(), &IPatchSource::patchChanged, this, &PatchReviewPlugin::notifyPatchChanged );
     }
     QString finishText = i18n( "Finish Review" );
     if( m_patch && !m_patch->finishReviewCustomText().isEmpty() )
       finishText = m_patch->finishReviewCustomText();
     m_finishReview->setText( finishText );
     m_finishReview->setEnabled( patch );
 
     notifyPatchChanged();
 }
 
 PatchReviewPlugin::PatchReviewPlugin( QObject *parent, const QVariantList & )
     : KDevelop::IPlugin( QStringLiteral("kdevpatchreview"), parent ),
     m_patch( nullptr ), m_factory( new PatchReviewToolViewFactory( this ) )
 {
     qRegisterMetaType<const Diff2::DiffModel*>( "const Diff2::DiffModel*" );
 
     setXMLFile( QStringLiteral("kdevpatchreview.rc") );
 
     connect( ICore::self()->documentController(), &IDocumentController::documentClosed, this, &PatchReviewPlugin::documentClosed );
     connect( ICore::self()->documentController(), &IDocumentController::textDocumentCreated, this, &PatchReviewPlugin::textDocumentCreated );
     connect( ICore::self()->documentController(), &IDocumentController::documentSaved, this, &PatchReviewPlugin::documentSaved );
 
     m_updateKompareTimer = new QTimer( this );
     m_updateKompareTimer->setSingleShot( true );
     connect( m_updateKompareTimer, &QTimer::timeout, this, &PatchReviewPlugin::updateKompareModel );
 
     m_finishReview = new QAction(i18n("Finish Review"), this);
     m_finishReview->setIcon( QIcon::fromTheme( QStringLiteral("dialog-ok") ) );
     actionCollection()->setDefaultShortcut( m_finishReview, Qt::CTRL|Qt::Key_Return );
     actionCollection()->addAction(QStringLiteral("commit_or_finish_review"), m_finishReview);
 
     foreach(Sublime::Area* area, ICore::self()->uiController()->allAreas()) {
         if (area->objectName() == QLatin1String("review"))
             area->addAction(m_finishReview);
     }
 
     core()->uiController()->addToolView( i18n( "Patch Review" ), m_factory, IUiController::None );
 
     areaChanged(ICore::self()->uiController()->activeArea());
 }
 
 void PatchReviewPlugin::documentClosed( IDocument* doc ) {
     removeHighlighting( doc->url() );
 }
 
 void PatchReviewPlugin::documentSaved( IDocument* doc ) {
     // Only update if the url is not the patch-file, because our call to
     // the reload() KTextEditor function also causes this signal,
     // which would lead to an endless update loop.
     // Also, don't automatically update local patch sources, because
     // they may correspond to static files which don't match any more
     // after an edit was done.
     if( m_patch && doc->url() != m_patch->file() && !dynamic_cast<LocalPatchSource*>(m_patch.data()) )
         forceUpdate();
 }
 
 void PatchReviewPlugin::textDocumentCreated( IDocument* doc ) {
     if (m_patch) {
         addHighlighting( doc->url(), doc );
     }
 }
 
 void PatchReviewPlugin::unload() {
     core()->uiController()->removeToolView( m_factory );
 
     KDevelop::IPlugin::unload();
 }
 
 void PatchReviewPlugin::areaChanged(Sublime::Area* area)
 {
     bool reviewing = area->objectName() == QLatin1String("review");
     m_finishReview->setEnabled(reviewing);
     if(!reviewing) {
         closeReview();
     }
 }
 
 KDevelop::ContextMenuExtension PatchReviewPlugin::contextMenuExtension( KDevelop::Context* context )
 {
     QList<QUrl> urls;
 
     if ( context->type() == KDevelop::Context::FileContext ) {
         KDevelop::FileContext* filectx = dynamic_cast<KDevelop::FileContext*>( context );
         urls = filectx->urls();
     } else if ( context->type() == KDevelop::Context::ProjectItemContext ) {
         KDevelop::ProjectItemContext* projctx = dynamic_cast<KDevelop::ProjectItemContext*>( context );
         foreach( KDevelop::ProjectBaseItem* item, projctx->items() ) {
             if ( item->file() ) {
                 urls << item->file()->path().toUrl();
             }
         }
     } else if ( context->type() == KDevelop::Context::EditorContext ) {
         KDevelop::EditorContext *econtext = dynamic_cast<KDevelop::EditorContext*>( context );
         urls << econtext->url();
     }
 
     if (urls.size() == 1) {
         QString mimetype = QMimeDatabase().mimeTypeForUrl(urls.first()).name();
         QAction* reviewAction = new QAction( i18n( "Review Patch" ), this );
         reviewAction->setData(QVariant(urls[0]));
         connect( reviewAction, &QAction::triggered, this, &PatchReviewPlugin::executeFileReviewAction );
         ContextMenuExtension cm;
         cm.addAction( KDevelop::ContextMenuExtension::ExtensionGroup, reviewAction );
         return cm;
     }
 
     return KDevelop::IPlugin::contextMenuExtension( context );
 }
 
 void PatchReviewPlugin::executeFileReviewAction()
 {
     QAction* reviewAction = qobject_cast<QAction*>(sender());
     KDevelop::Path path(reviewAction->data().toUrl());
     LocalPatchSource* ps = new LocalPatchSource();
     ps->setFilename(path.toUrl());
     ps->setBaseDir(path.parent().toUrl());
     ps->setAlreadyApplied(true);
     ps->createWidget();
     startReview(ps, OpenAndRaise);
 }
 
 #include "patchreview.moc"
 
 // kate: space-indent on; indent-width 4; tab-width 4; replace-tabs on
diff --git a/vcs/dvcs/ui/branchmanager.cpp b/vcs/dvcs/ui/branchmanager.cpp
index cbe5c29c2..12eff825d 100644
--- a/vcs/dvcs/ui/branchmanager.cpp
+++ b/vcs/dvcs/ui/branchmanager.cpp
@@ -1,240 +1,282 @@
 /***************************************************************************
  *   Copyright 2008 Evgeniy Ivanov <powerfox@kde.ru>                       *
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   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, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "branchmanager.h"
 
 #include <QListWidget>
 #include <QInputDialog>
 
 #include <KJob>
 #include <KMessageBox>
 #include <KLocalizedString>
 
 #include "../dvcsjob.h"
 #include "../dvcsplugin.h"
 #include <vcs/models/brancheslistmodel.h>
 #include "ui_branchmanager.h"
 #include "../../debug.h"
 #include "widgets/vcsdiffpatchsources.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/iruncontroller.h>
 #include <KConfigGroup>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 #include <KParts/MainWindow>
 
 using namespace KDevelop;
 
 BranchManager::BranchManager(const QString& repository, KDevelop::DistributedVersionControlPlugin* executor, QWidget *parent)
     : QDialog(parent)
     , m_repository(repository)
     , m_dvcPlugin(executor)
 {
     setWindowTitle(i18n("Branch Manager"));
 
     QWidget *mainWidget = new QWidget(this);
     QVBoxLayout *mainLayout = new QVBoxLayout(this);
     mainLayout->addWidget(mainWidget);
 
     m_ui = new Ui::BranchDialogBase;
     QWidget* w = new QWidget(this);
     m_ui->setupUi(w);
     mainLayout->addWidget(w);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     connect(buttonBox, &QDialogButtonBox::accepted, this, &BranchManager::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &BranchManager::reject);
     mainLayout->addWidget(buttonBox);
 
     m_model = new BranchesListModel(this);
     m_model->initialize(m_dvcPlugin, QUrl::fromLocalFile(repository));
     m_ui->branchView->setModel(m_model);
 
     QString branchName = m_model->currentBranch();
     // apply initial selection
     QList< QStandardItem* > items = m_model->findItems(branchName);
     if (!items.isEmpty()) {
         m_ui->branchView->setCurrentIndex(items.first()->index());
     }
 
     m_ui->newButton->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));
     connect(m_ui->newButton, &QPushButton::clicked, this, &BranchManager::createBranch);
     m_ui->deleteButton->setIcon(QIcon::fromTheme(QStringLiteral("list-remove")));
     connect(m_ui->deleteButton, &QPushButton::clicked, this, &BranchManager::deleteBranch);
     m_ui->renameButton->setIcon(QIcon::fromTheme(QStringLiteral("edit-rename")));
     connect(m_ui->renameButton, &QPushButton::clicked, this, &BranchManager::renameBranch);
     m_ui->checkoutButton->setIcon(QIcon::fromTheme(QStringLiteral("dialog-ok-apply")));
     connect(m_ui->checkoutButton, &QPushButton::clicked, this, &BranchManager::checkoutBranch);
 
     // checkout branch on double-click
     connect(m_ui->branchView, &QListView::doubleClicked, this, &BranchManager::checkoutBranch);
 
     m_ui->mergeButton->setIcon(QIcon::fromTheme(QStringLiteral("merge")));
     connect(m_ui->mergeButton, &QPushButton::clicked, this, &BranchManager::mergeBranch);
     m_ui->diffButton->setIcon(QIcon::fromTheme(QStringLiteral("text-x-patch")));
     connect(m_ui->diffButton, &QPushButton::clicked, this, &BranchManager::diffFromBranch);
 }
 
 BranchManager::~BranchManager()
 {
     delete m_ui;
 }
 
 void BranchManager::createBranch()
 {
     const QModelIndex currentBranchIdx = m_ui->branchView->currentIndex();
     if (!currentBranchIdx.isValid()) {
         KMessageBox::messageBox(this, KMessageBox::Error,
                                 i18n("You must select a base branch from the list before creating a new branch."));
         return;
     }
     QString baseBranch = currentBranchIdx.data().toString();
     bool branchNameEntered = false;
     QString newBranch = QInputDialog::getText(this, i18n("New branch"), i18n("Name of the new branch:"),
             QLineEdit::Normal, QString(), &branchNameEntered);
     if (!branchNameEntered)
         return;
 
     if (!m_model->findItems(newBranch).isEmpty())
     {
         KMessageBox::messageBox(this, KMessageBox::Sorry,
                                 i18n("Branch \"%1\" already exists.\n"
                                         "Please, choose another name.",
                                         newBranch));
     }
     else
         m_model->createBranch(baseBranch, newBranch);
 }
 
 void BranchManager::deleteBranch()
 {
     QString baseBranch = m_ui->branchView->selectionModel()->selection().indexes().first().data().toString();
 
     if (baseBranch == m_model->currentBranch())
     {
         KMessageBox::messageBox(this, KMessageBox::Sorry,
                                     i18n("Currently at the branch \"%1\".\n"
                                             "To remove it, please change to another branch.",
                                             baseBranch));
         return;
     }
 
     int ret = KMessageBox::messageBox(this, KMessageBox::WarningYesNo,
                                       i18n("Are you sure you want to irreversibly remove the branch '%1'?", baseBranch));
     if (ret == KMessageBox::Yes)
         m_model->removeBranch(baseBranch);
 }
 
 void BranchManager::renameBranch()
 {
     QModelIndex currentIndex = m_ui->branchView->currentIndex();
     if (!currentIndex.isValid())
         return;
 
     m_ui->branchView->edit(currentIndex);
 }
 
 void BranchManager::checkoutBranch()
 {
     QString branch = m_ui->branchView->currentIndex().data().toString();
     if (branch == m_model->currentBranch())
     {
         KMessageBox::messageBox(this, KMessageBox::Sorry,
                                 i18n("Already on branch \"%1\"\n",
                                         branch));
         return;
     }
 
     qCDebug(VCS) << "Switching to" << branch << "in" << m_repository;
     KDevelop::VcsJob *branchJob = m_dvcPlugin->switchBranch(QUrl::fromLocalFile(m_repository), branch);
 //     connect(branchJob, SIGNAL(finished(KJob*)), m_model, SIGNAL(resetCurrent()));
 
     ICore::self()->runController()->registerJob(branchJob);
     close();
 }
 
 void BranchManager::mergeBranch()
 {
     const QModelIndex branchToMergeIdx = m_ui->branchView->currentIndex();
 
     if (branchToMergeIdx.isValid()) {
         QString branchToMerge = branchToMergeIdx.data().toString();
 
         if (m_model->findItems(branchToMerge).isEmpty()) {
             KMessageBox::messageBox(this, KMessageBox::Sorry, i18n("Branch \"%1\" doesn't exists.\n"
                                                                    "Please, choose another name.",
                                                                    branchToMerge));
         } else {
             KDevelop::VcsJob* branchJob = m_dvcPlugin->mergeBranch(QUrl::fromLocalFile(m_repository), branchToMerge);
             ICore::self()->runController()->registerJob(branchJob);
             close();
         }
     } else {
         KMessageBox::messageBox(this, KMessageBox::Error,
                                 i18n("You must select a branch to merge into current one from the list."));
     }
 }
 
+// adapted from VCSStandardDiffUpdater
+class VCSBranchDiffUpdater : public VCSDiffUpdater {
+public:
+    VCSBranchDiffUpdater(const QString& repo, const QString& src, KDevelop::DistributedVersionControlPlugin* vcs);
+    ~VCSBranchDiffUpdater() override;
+    KDevelop::VcsDiff update() const override;
+    KDevelop::IBasicVersionControl* vcs() const override { return m_vcs; }
+    QUrl url() const override { return QUrl::fromLocalFile(m_repository); }
+private:
+    const QString m_repository;
+    const QString m_src;
+    KDevelop::DistributedVersionControlPlugin* m_vcs;
+};
+
+VCSBranchDiffUpdater::VCSBranchDiffUpdater(const QString& repo, const QString& src,
+        KDevelop::DistributedVersionControlPlugin* vcs)
+    : m_repository(repo)
+    , m_src(src)
+    , m_vcs(vcs)
+{
+}
+
+VCSBranchDiffUpdater::~VCSBranchDiffUpdater() {
+}
+
+VcsDiff VCSBranchDiffUpdater::update() const
+{
+    VcsRevision srcRev;
+    srcRev.setRevisionValue(m_src, KDevelop::VcsRevision::GlobalNumber);
+    // see comment in BranchManager::diffFromBranch()
+    const auto destRev = VcsRevision::createSpecialRevision(KDevelop::VcsRevision::Working);
+    QScopedPointer<VcsJob> diffJob(m_vcs->diff(QUrl::fromLocalFile(m_repository), srcRev, destRev));
+    const bool success = diffJob ? diffJob->exec() : false;
+    if (!success) {
+        KMessageBox::error(nullptr, i18n("Could not create a patch for the current version."));
+        return {};
+    }
+
+    return diffJob->fetchResults().value<VcsDiff>();
+}
+
 void BranchManager::diffFromBranch()
 {
     const auto dest = m_model->currentBranch();
     const auto src = m_ui->branchView->currentIndex().data().toString();
     if (src == dest) {
         KMessageBox::messageBox(this, KMessageBox::Information, i18n("Already on branch \"%1\"\n", src));
         return;
     }
 
     VcsRevision srcRev;
     srcRev.setRevisionValue(src, KDevelop::VcsRevision::GlobalNumber);
     // We have two options here:
     // * create a regular VcsRevision to represent the last commit on the current branch or
     // * create a special branch to reflect the staging area. I choosed this one.
     // If the staing area is clean it automatically defaults to the first option.
     const auto destRev = VcsRevision::createSpecialRevision(KDevelop::VcsRevision::Working);
     const auto job = m_dvcPlugin->diff(QUrl::fromLocalFile(m_repository), srcRev, destRev);
     connect(job, &VcsJob::finished, this, &BranchManager::diffJobFinished);
     m_dvcPlugin->core()->runController()->registerJob(job);
 }
 
 void BranchManager::diffJobFinished(KJob* job)
 {
     auto vcsjob = qobject_cast<KDevelop::VcsJob*>(job);
     Q_ASSERT(vcsjob);
 
     if (vcsjob->status() != KDevelop::VcsJob::JobSucceeded) {
         KMessageBox::error(ICore::self()->uiController()->activeMainWindow(), vcsjob->errorString(),
                            i18n("Unable to retrieve diff."));
         return;
     }
 
     auto diff = vcsjob->fetchResults().value<KDevelop::VcsDiff>();
     if(diff.isEmpty()){
         KMessageBox::information(ICore::self()->uiController()->activeMainWindow(),
                                     i18n("There are no committed differences."),
                                     i18n("VCS support"));
         return;
     }
 
-    auto patch = new VCSDiffPatchSource(diff);
+    auto patch = new VCSDiffPatchSource(new VCSBranchDiffUpdater(m_repository,
+        m_ui->branchView->currentIndex().data().toString(), m_dvcPlugin));
     showVcsDiff(patch);
     close();
 }