diff --git a/plugins/filetemplates/licensepage.cpp b/plugins/filetemplates/licensepage.cpp
index 1bb1a7b869..cc45743b6f 100644
--- a/plugins/filetemplates/licensepage.cpp
+++ b/plugins/filetemplates/licensepage.cpp
@@ -1,283 +1,290 @@
 /* This file is part of KDevelop
     Copyright 2008 Hamish Rodda <rodda@kde.org>
 
    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.
 */
 
 #include "licensepage.h"
 
 #include "ui_licensechooser.h"
 #include "debug.h"
 
 #include <KSharedConfig>
 #include <KLocalizedString>
 #include <KEMailSettings>
 #include <KMessageBox>
 #include <KConfigGroup>
 
 #include <QDirIterator>
 #include <QStandardPaths>
 
 namespace KDevelop {
 
 struct LicensePagePrivate
 {
     struct LicenseInfo
     {
         QString name;
         QString path;
         QString contents;
         bool operator< (const LicenseInfo& o) const
         {
             return name.localeAwareCompare(o.name) < 0;
         }
     };
     typedef QList<LicenseInfo> LicenseList;
 
 
     explicit LicensePagePrivate(LicensePage* page_)
     : license(nullptr)
     , page(page_)
     {
     }
 
     // methods
     void initializeLicenses();
     QString readLicense(int licenseIndex);
     bool saveLicense();
     // slots
     void licenseComboChanged(int license);
 
     Ui::LicenseChooserDialog* license;
     LicenseList availableLicenses;
     LicensePage* page;
 };
 
 //! Read all the license files in the global and local config dirs
 void LicensePagePrivate::initializeLicenses()
 {
     qCDebug(PLUGIN_FILETEMPLATES) << "Searching for available licenses";
     QStringList licenseDirs = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("kdevcodegen/licenses"), QStandardPaths::LocateDirectory);
 
     //Iterate through the possible directories that contain licenses, and load their names
     foreach(const QString& currentDir, licenseDirs)
     {
         QDirIterator it(currentDir, QDir::Files | QDir::Readable);
         while(it.hasNext())
         {
             LicenseInfo newLicense;
             newLicense.path = it.next();
             newLicense.name = it.fileName();
 
             qCDebug(PLUGIN_FILETEMPLATES) << "Found License: " << newLicense.name;
 
             availableLicenses.push_back(newLicense);
         }
     }
 
     std::sort(availableLicenses.begin(), availableLicenses.end());
 
     foreach(const LicenseInfo& info, availableLicenses) {
         license->licenseComboBox->addItem(info.name);
     }
     //Finally add the option other for user specified licenses
     LicenseInfo otherLicense;
     availableLicenses.push_back(otherLicense);
     license->licenseComboBox->addItem(i18n("Other"));
 }
 
 // Read a license index, if it is not loaded, open it from the file
 QString LicensePagePrivate::readLicense(int licenseIndex)
 {
     //If the license is not loaded into memory, read it in
     if(availableLicenses[licenseIndex].contents.isEmpty())
     {
         QString licenseText;
         //If we are dealing with the last option "other" just return a new empty string
         if(licenseIndex != (availableLicenses.size() - 1))
         {
             qCDebug(PLUGIN_FILETEMPLATES) << "Reading license: " << availableLicenses[licenseIndex].name ;
             QFile newLicense(availableLicenses[licenseIndex].path);
 
             if(newLicense.open(QIODevice::ReadOnly | QIODevice::Text))
             {
                 QTextStream newLicenseText(&newLicense);
                 newLicenseText.setAutoDetectUnicode(true);
                 licenseText = newLicenseText.readAll();
                 newLicense.close();
+
+                // license text files are stored with a trailing linebreak,
+                // as otherwise some tools complain about it
+                // so deal with that and remove any potential trailing linebreak
+                // which otherwise would result in a trailing empty line
+                QRegularExpression anyLinebreakAtEnd(QStringLiteral("(\n|\r\n)$"));
+                licenseText.remove(anyLinebreakAtEnd);
             }
             else
                 licenseText = QStringLiteral("Error, could not open license file.\n Was it deleted?");
         }
 
         availableLicenses[licenseIndex].contents = licenseText;
     }
 
     return availableLicenses[licenseIndex].contents;
 }
 
 // ---Slots---
 
 void LicensePagePrivate::licenseComboChanged(int selectedLicense)
 {
     //If the last slot is selected enable the save license combobox
     if(selectedLicense == (availableLicenses.size() - 1))
     {
         license->licenseTextEdit->clear();
         license->licenseTextEdit->setReadOnly(false);
         license->saveLicense->setEnabled(true);
     }
     else
     {
         license->saveLicense->setEnabled(false);
         license->licenseTextEdit->setReadOnly(true);
     }
 
     if(selectedLicense < 0 || selectedLicense >= availableLicenses.size())
         license->licenseTextEdit->setText(i18n("Could not load previous license"));
     else
         license->licenseTextEdit->setText(readLicense(selectedLicense));
 }
 
 bool LicensePagePrivate::saveLicense()
 {
     qCDebug(PLUGIN_FILETEMPLATES) << "Attempting to save custom license: " << license->licenseName->text();
 
     QString localDataDir = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation)+"/kdevcodegen/licenses/";
     QString fullPath = localDataDir + license->licenseName->text();
     QFile newFile(fullPath);
 
     if(newFile.exists())
     {
         KMessageBox::sorry(page, i18n("The specified license already exists. "
                                       "Please provide a different name."));
         return false;
     }
 
     QDir().mkpath(localDataDir);
     newFile.open(QIODevice::WriteOnly);
     qint64 result = newFile.write(license->licenseTextEdit->toPlainText().toUtf8());
     newFile.close();
 
     if(result == -1)
     {
         KMessageBox::sorry(page, i18n("Failed to write custom license template to file %1.", fullPath));
         return false;
     }
 
     // also add to our data structures, this esp. needed for proper saving
     // of the license index so it can be restored the next time we show up
     LicenseInfo info;
     info.name = license->licenseName->text();
     info.path = localDataDir;
     availableLicenses << info;
     // find index of the new the license, omitting the very last item ('Other')
     int idx = availableLicenses.count() - 1;
     for(int i = 0; i < availableLicenses.size() - 1; ++i) {
         if (info < availableLicenses.at(i)) {
             idx = i;
             break;
         }
     }
     availableLicenses.insert(idx, info);
     license->licenseComboBox->insertItem(idx, info.name);
     license->licenseComboBox->setCurrentIndex(idx);
 
 
     return true;
 }
 
 LicensePage::LicensePage(QWidget* parent)
 : QWidget(parent)
 , d(new LicensePagePrivate(this))
 {
     d->license = new Ui::LicenseChooserDialog;
     d->license->setupUi(this);
 
     connect(d->license->licenseComboBox, static_cast<void(KComboBox::*)(int)>(&KComboBox::currentIndexChanged),
             this, [&] (int selectedLicense) { d->licenseComboChanged(selectedLicense); });
     connect(d->license->saveLicense, &QCheckBox::clicked,
             d->license->licenseName, &QLineEdit::setEnabled);
 
     // Read all the available licenses from the standard dirs
     d->initializeLicenses();
 
     //Set the license selection to the previous one
     KConfigGroup config(KSharedConfig::openConfig()->group("CodeGeneration"));
     d->license->licenseComboBox->setCurrentIndex(config.readEntry( "LastSelectedLicense", 0 ));
     // Needed to avoid a bug where licenseComboChanged doesn't get
     // called by QComboBox if the past selection was 0
     d->licenseComboChanged(d->license->licenseComboBox->currentIndex());
 }
 
 LicensePage::~LicensePage()
 {
     if (d->license->saveLicense->isChecked() && !d->license->licenseName->text().isEmpty()) {
         d->saveLicense();
     }
     KConfigGroup config(KSharedConfig::openConfig()->group("CodeGeneration"));
     //Do not save invalid license numbers'
     int index = d->license->licenseComboBox->currentIndex();
     if( index >= 0 || index < d->availableLicenses.size() )
     {
         config.writeEntry("LastSelectedLicense", index);
         config.config()->sync();
     }
     else
     {
         qCWarning(PLUGIN_FILETEMPLATES) << "Attempted to save an invalid license number: " << index
                                         << ". Number of licenses:" << d->availableLicenses.size();
     }
 
     delete d->license;
     delete d;
 }
 
 QString LicensePage::license() const
 {
     QString licenseText = d->license->licenseTextEdit->document()->toPlainText();
     /* Add date, name and email to license text */
     licenseText.replace(QLatin1String("<year>"), QDate::currentDate().toString(QStringLiteral("yyyy")));
     licenseText.replace(QLatin1String("<month>"), QDate::currentDate().toString(QStringLiteral("MM")));
     licenseText.replace(QLatin1String("<day>"), QDate::currentDate().toString(QStringLiteral("dd")));
     QString developer(QStringLiteral("%1 <%2>"));
     KEMailSettings emailSettings;
     QString name = emailSettings.getSetting(KEMailSettings::RealName);
     if (name.isEmpty())
     {
         name = QStringLiteral("<copyright holder>");
     }
     developer = developer.arg(name);
     QString email = emailSettings.getSetting(KEMailSettings::EmailAddress);
     if (email.isEmpty())
     {
         email = QStringLiteral("email"); //no < > as they are already through the email field
     }
     developer = developer.arg(email);
     licenseText.replace(QLatin1String("<copyright holder>"), developer);
 
     return licenseText;
 }
 
 void LicensePage::setFocusToFirstEditWidget()
 {
     d->license->licenseComboBox->setFocus();
 }
 
 }
 
 Q_DECLARE_TYPEINFO(KDevelop::LicensePagePrivate::LicenseInfo, Q_MOVABLE_TYPE);
 
 #include "moc_licensepage.cpp"
diff --git a/plugins/welcomepage/qml/Develop.qml b/plugins/welcomepage/qml/Develop.qml
index 00ccab60a3..9c485ec7a4 100644
--- a/plugins/welcomepage/qml/Develop.qml
+++ b/plugins/welcomepage/qml/Develop.qml
@@ -1,140 +1,140 @@
 /* KDevelop
  *
  * Copyright 2011 Aleix Pol <aleixpol@kde.org>
  * Copyright 2016 Kevin Funk <kfunk@kde.org>
  *
  * 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.
  */
 
 import QtQuick 2.0
 import QtQuick.Layouts 1.2
 import QtQuick.Controls 1.3
 
 import org.kdevelop.welcomepage 4.3
 
 StandardPage
 {
     id: root
 
     ColumnLayout {
         anchors.fill: parent
         anchors.margins: 20
 
         spacing: 20
 
         RowLayout {
             id: toolBar
 
             width: parent.width
 
             Button {
                 iconName: "project-development-new-template"
                 text: i18n("New Project")
                 onClicked: kdev.retrieveMenuAction("project/project_new").trigger()
             }
 
             Button {
                 text: i18n("Open Project")
-                iconName: "project-development-open"
+                iconName: "project-open"
                 onClicked: ICore.projectController.openProject()
             }
 
             Button {
                 text: i18n("Fetch Project")
                 iconName: "edit-download"
                 onClicked: kdev.retrieveMenuAction("project/project_fetch").trigger()
             }
 
             Button {
                 iconName: "document-open-recent"
                 text: i18n("Recent Projects")
                 onClicked: kdev.showMenu("project/project_open_recent")
             }
             Item {
                 Layout.fillWidth: true
             }
         }
 
         Label {
             id: greetingLabel
 
             visible: !sessionsView.visible
             Layout.fillWidth: true
             Layout.fillHeight: true
 
             text: i18n("<h3>Welcome to KDevelop!</h3>\n" +
                 "<p>You can start working on a project by opening an existing or creating a new one via the above buttons.</p>\n" +
                 "<p>If you need help, please check out the <a href=\"https://userbase.kde.org/KDevelop\">User Manual.</a></p>") +
 
                 (Qt.platform.os === "windows" ?
                     i18n("<br/>\n" +
                         "<h3>Note for Windows users</h3>\n" +
                         "<p>Note that KDevelop does NOT ship a C/C++ compiler on Windows!</p>\n" +
                         "<p>You need to install either GCC via MinGW or install a recent version of the Microsoft Visual Studio IDE and make sure the environment is setup correctly <i>before</i> starting KDevelop.</p>\n" +
                         "<p>If you need further assistance, please check out the <a href=\"https://userbase.kde.org/KDevelop4/Manual/WindowsSetup\">KDevelop under Windows instructions.</a></p>") :
                     "")
             wrapMode: Text.WordWrap
             onLinkActivated: Qt.openUrlExternally(link)
 
             MouseArea {
                 anchors.fill: parent
 
                 acceptedButtons: Qt.NoButton // we don't want to eat clicks on the Text
                 cursorShape: parent.hoveredLink ? Qt.PointingHandCursor : Qt.ArrowCursor
             }
         }
 
         ScrollView {
             Layout.fillHeight: true
             Layout.fillWidth: true
 
             visible: sessionsView.count > 1 // we always have at least one active session
 
             ListView {
                 id: sessionsView
 
                 anchors.fill: parent
 
                 delegate: MouseArea {
                     width: sessionsView.width
                     height: visible ? 30 : 0
 
                     visible: projects.length > 0
                     hoverEnabled: true
                     cursorShape: Qt.PointingHandCursor
 
                     onClicked: sessionsModel.loadSession(uuid)
 
                     Label {
                         readonly property string projectNamesString: projectNames.join(", ").replace(/.kdev4/g, "")
 
                         width: parent.width
 
                         text: display == "" ? projectNamesString : i18n("%1: %2", display, projectNamesString)
                         elide: Text.ElideRight
                         opacity: parent.containsMouse ? 0.8 : 1
                     }
                 }
 
                 model: SessionsModel { id: sessionsModel }
 
                 header: Heading {
                     text: i18n("Sessions")
                 }
             }
         }
     }
 }
diff --git a/vcs/vcspluginhelper.cpp b/vcs/vcspluginhelper.cpp
index 5c07b24d1c..d212dc4834 100644
--- a/vcs/vcspluginhelper.cpp
+++ b/vcs/vcspluginhelper.cpp
@@ -1,487 +1,505 @@
 /***************************************************************************
  *   Copyright 2008 Andreas Pakulat <apaku@gmx.de>                         *
  *   Copyright 2010 Aleix Pol Gonzalez <aleixpol@kde.org>                  *
  *                                                                         *
  *   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 "vcspluginhelper.h"
 
 #include <QAction>
 #include <QApplication>
 #include <QClipboard>
 #include <QDialogButtonBox>
 #include <QFileInfo>
 #include <QMenu>
 #include <QTimer>
 #include <QVBoxLayout>
 #include <QVariant>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KParts/MainWindow>
 #include <KTextEditor/AnnotationInterface>
 #include <KTextEditor/Document>
 #include <KTextEditor/ModificationInterface>
 #include <KTextEditor/View>
 
 #include <interfaces/context.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/icore.h>
 #include <interfaces/idocument.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/iplugin.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/iproject.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iruncontroller.h>
 #include <interfaces/isession.h>
 #include <interfaces/iuicontroller.h>
 #include <util/path.h>
 #include <util/scopeddialog.h>
 #include <vcs/interfaces/ibasicversioncontrol.h>
 #include <vcs/models/vcsannotationmodel.h>
 #include <vcs/widgets/vcseventwidget.h>
 #include <vcs/widgets/vcscommitdialog.h>
 #include <vcs/vcsjob.h>
 #include <vcs/vcsrevision.h>
 #include <vcs/vcsdiff.h>
 
 #include "interfaces/idistributedversioncontrol.h"
 #include "vcsevent.h"
 #include "debug.h"
 #include "widgets/vcsdiffpatchsources.h"
 
 namespace KDevelop
 {
 
 class VcsPluginHelperPrivate
 {
 public:
     IPlugin * plugin;
     IBasicVersionControl * vcs;
 
     QList<QUrl> ctxUrls;
     QAction* commitAction;
     QAction* addAction;
     QAction* updateAction;
     QAction* historyAction;
     QAction* annotationAction;
     QAction* diffToBaseAction;
     QAction* revertAction;
     QAction* diffForRevAction;
     QAction* diffForRevGlobalAction;
     QAction* pushAction;
     QAction* pullAction;
 
     void createActions(VcsPluginHelper* parent) {
         commitAction = new QAction(QIcon::fromTheme(QStringLiteral("svn-commit")), i18n("Commit..."), parent);
         updateAction = new QAction(QIcon::fromTheme(QStringLiteral("svn-update")), i18n("Update"), parent);
         addAction = new QAction(QIcon::fromTheme(QStringLiteral("list-add")), i18n("Add"), parent);
         diffToBaseAction = new QAction(QIcon::fromTheme(QStringLiteral("text-x-patch")), i18n("Show Differences..."), parent);
         revertAction = new QAction(QIcon::fromTheme(QStringLiteral("archive-remove")), i18n("Revert"), parent);
         historyAction = new QAction(QIcon::fromTheme(QStringLiteral("view-history")), i18n("History..."), parent);
         annotationAction = new QAction(QIcon::fromTheme(QStringLiteral("user-properties")), i18n("Annotation..."), parent);
         diffForRevAction = new QAction(QIcon::fromTheme(QStringLiteral("text-x-patch")), i18n("Show Diff..."), parent);
         diffForRevGlobalAction = new QAction(QIcon::fromTheme(QStringLiteral("text-x-patch")), i18n("Show Diff (all files)..."), parent);
         pushAction = new QAction(QIcon::fromTheme(QStringLiteral("arrow-up-double")), i18n("Push"), parent);
         pullAction = new QAction(QIcon::fromTheme(QStringLiteral("arrow-down-double")), i18n("Pull"), parent);
 
         QObject::connect(commitAction, &QAction::triggered, parent, &VcsPluginHelper::commit);
         QObject::connect(addAction, &QAction::triggered, parent, &VcsPluginHelper::add);
         QObject::connect(updateAction, &QAction::triggered, parent, &VcsPluginHelper::update);
         QObject::connect(diffToBaseAction, &QAction::triggered, parent, &VcsPluginHelper::diffToBase);
         QObject::connect(revertAction, &QAction::triggered, parent, &VcsPluginHelper::revert);
         QObject::connect(historyAction, &QAction::triggered, parent, [=] { parent->history(); });
         QObject::connect(annotationAction, &QAction::triggered, parent, &VcsPluginHelper::annotation);
         QObject::connect(diffForRevAction, &QAction::triggered, parent, static_cast<void(VcsPluginHelper::*)()>(&VcsPluginHelper::diffForRev));
         QObject::connect(diffForRevGlobalAction, &QAction::triggered, parent, &VcsPluginHelper::diffForRevGlobal);
         QObject::connect(pullAction, &QAction::triggered, parent, &VcsPluginHelper::pull);
         QObject::connect(pushAction, &QAction::triggered, parent, &VcsPluginHelper::push);
     }
 
     bool allLocalFiles(const QList<QUrl>& urls)
     {
         bool ret=true;
         foreach(const QUrl &url, urls) {
             QFileInfo info(url.toLocalFile());
             ret &= info.isFile();
         }
         return ret;
     }
 
     QMenu* createMenu(QWidget* parent)
     {
         bool allVersioned=true;
         foreach(const QUrl &url, ctxUrls) {
             allVersioned=allVersioned && vcs->isVersionControlled(url);
 
             if(!allVersioned)
                 break;
         }
 
         QMenu* menu = new QMenu(vcs->name(), parent);
         menu->setIcon(QIcon::fromTheme(ICore::self()->pluginController()->pluginInfo(plugin).iconName()));
         menu->addAction(commitAction);
         if(plugin->extension<IDistributedVersionControl>()) {
             menu->addAction(pushAction);
             menu->addAction(pullAction);
         } else {
             menu->addAction(updateAction);
         }
         menu->addSeparator();
         menu->addAction(addAction);
         menu->addAction(revertAction);
         menu->addSeparator();
         menu->addAction(historyAction);
         menu->addAction(annotationAction);
         menu->addAction(diffToBaseAction);
 
         const bool singleVersionedFile = ctxUrls.count() == 1 && allVersioned;
         historyAction->setEnabled(singleVersionedFile);
         annotationAction->setEnabled(singleVersionedFile && allLocalFiles(ctxUrls));
         diffToBaseAction->setEnabled(singleVersionedFile);
         commitAction->setEnabled(singleVersionedFile);
 
         return menu;
     }
 };
 
 
 VcsPluginHelper::VcsPluginHelper(KDevelop::IPlugin* parent, KDevelop::IBasicVersionControl* vcs)
         : QObject(parent)
         , d(new VcsPluginHelperPrivate())
 {
     Q_ASSERT(vcs);
     Q_ASSERT(parent);
     d->plugin = parent;
     d->vcs = vcs;
     d->createActions(this);
 }
 
 VcsPluginHelper::~VcsPluginHelper()
 {}
 
 void VcsPluginHelper::addContextDocument(const QUrl &url)
 {
     d->ctxUrls.append(url);
 }
 
 void VcsPluginHelper::disposeEventually(KTextEditor::View *, bool dont)
 {
     if ( ! dont ) {
         deleteLater();
     }
 }
 
 void VcsPluginHelper::disposeEventually(KTextEditor::Document *)
 {
     deleteLater();
 }
 
 void VcsPluginHelper::setupFromContext(Context* context)
 {
     d->ctxUrls = context->urls();
 }
 
 QList<QUrl> VcsPluginHelper::contextUrlList() const
 {
     return d->ctxUrls;
 }
 
 QMenu* VcsPluginHelper::commonActions(QWidget* parent)
 {
     /* TODO: the following logic to determine which actions need to be enabled
      * or disabled does not work properly. What needs to be implemented is that
      * project items that are vc-controlled enable all except add, project
      * items that are not vc-controlled enable add action. For urls that cannot
      * be made into a project item, or if the project has no associated VC
      * plugin we need to check whether a VC controls the parent dir, if we have
      * one we assume the urls can be added but are not currently controlled. If
      * the url is already version controlled then just enable all except add
      */
     return d->createMenu(parent);
 }
 
 #define EXECUTE_VCS_METHOD( method ) \
     d->plugin->core()->runController()->registerJob( d->vcs-> method ( d->ctxUrls ) )
 
 #define SINGLEURL_SETUP_VARS \
     KDevelop::IBasicVersionControl* iface = d->vcs;\
     const QUrl &url = d->ctxUrls.front();
 
 
 void VcsPluginHelper::revert()
 {
     VcsJob* job=d->vcs->revert(d->ctxUrls);
     connect(job, &VcsJob::finished, this, &VcsPluginHelper::revertDone);
 
     foreach(const QUrl &url, d->ctxUrls) {
         IDocument* doc=ICore::self()->documentController()->documentForUrl(url);
 
         if(doc && doc->textDocument()) {
             KTextEditor::ModificationInterface* modif = dynamic_cast<KTextEditor::ModificationInterface*>(doc->textDocument());
             if (modif) {
                 modif->setModifiedOnDiskWarning(false);
             }
             doc->textDocument()->setModified(false);
         }
     }
     job->setProperty("urls", QVariant::fromValue(d->ctxUrls));
 
     d->plugin->core()->runController()->registerJob(job);
 }
 
 void VcsPluginHelper::revertDone(KJob* job)
 {
     QTimer* modificationTimer = new QTimer;
     modificationTimer->setInterval(100);
     connect(modificationTimer, &QTimer::timeout, this, &VcsPluginHelper::delayedModificationWarningOn);
     connect(modificationTimer, &QTimer::timeout, modificationTimer, &QTimer::deleteLater);
 
 
     modificationTimer->setProperty("urls", job->property("urls"));
     modificationTimer->start();
 }
 
 void VcsPluginHelper::delayedModificationWarningOn()
 {
     QObject* timer = sender();
     QList<QUrl> urls = timer->property("urls").value<QList<QUrl>>();
 
     foreach(const QUrl &url, urls) {
         IDocument* doc=ICore::self()->documentController()->documentForUrl(url);
 
         if(doc) {
             doc->reload();
 
             KTextEditor::ModificationInterface* modif=dynamic_cast<KTextEditor::ModificationInterface*>(doc->textDocument());
             modif->setModifiedOnDiskWarning(true);
         }
     }
 }
 
 
 void VcsPluginHelper::diffJobFinished(KJob* job)
 {
     KDevelop::VcsJob* vcsjob = qobject_cast<KDevelop::VcsJob*>(job);
     Q_ASSERT(vcsjob);
 
     if (vcsjob->status() == KDevelop::VcsJob::JobSucceeded) {
         KDevelop::VcsDiff d = vcsjob->fetchResults().value<KDevelop::VcsDiff>();
         if(d.isEmpty())
             KMessageBox::information(ICore::self()->uiController()->activeMainWindow(),
                                      i18n("There are no differences."),
                                      i18n("VCS support"));
         else {
             VCSDiffPatchSource* patch=new VCSDiffPatchSource(d);
             showVcsDiff(patch);
         }
     } else {
         KMessageBox::error(ICore::self()->uiController()->activeMainWindow(), vcsjob->errorString(), i18n("Unable to get difference."));
     }
 }
 
 void VcsPluginHelper::diffToBase()
 {
     SINGLEURL_SETUP_VARS
     ICore::self()->documentController()->saveAllDocuments();
 
     VCSDiffPatchSource* patch =new VCSDiffPatchSource(new VCSStandardDiffUpdater(iface, url));
     showVcsDiff(patch);
 }
 
 void VcsPluginHelper::diffForRev()
 {
     if (d->ctxUrls.isEmpty()) {
         return;
     }
     diffForRev(d->ctxUrls.first());
 }
 
 void VcsPluginHelper::diffForRevGlobal()
 {
     if (d->ctxUrls.isEmpty()) {
         return;
     }
     QUrl url = d->ctxUrls.first();
     IProject* project = ICore::self()->projectController()->findProjectForUrl( url );
     if( project ) {
         url = project->path().toUrl();
     }
 
     diffForRev(url);
 }
 
 void VcsPluginHelper::diffForRev(const QUrl& url)
 {
     QAction* action = qobject_cast<QAction*>( sender() );
     Q_ASSERT(action);
     Q_ASSERT(action->data().canConvert<VcsRevision>());
     VcsRevision rev = action->data().value<VcsRevision>();
 
     ICore::self()->documentController()->saveAllDocuments();
     VcsRevision prev = KDevelop::VcsRevision::createSpecialRevision(KDevelop::VcsRevision::Previous);
     KDevelop::VcsJob* job = d->vcs->diff(url, prev, rev );
 
     connect(job, &VcsJob::finished, this, &VcsPluginHelper::diffJobFinished);
     d->plugin->core()->runController()->registerJob(job);
 }
 
 void VcsPluginHelper::history(const VcsRevision& rev)
 {
     SINGLEURL_SETUP_VARS
     QDialog* dlg = new QDialog(ICore::self()->uiController()->activeMainWindow());
     dlg->setAttribute(Qt::WA_DeleteOnClose);
     dlg->setWindowTitle(i18nc("%1: path or URL, %2: name of a version control system",
                           "%2 History (%1)", url.toDisplayString(QUrl::PreferLocalFile), iface->name()));
 
     QVBoxLayout *mainLayout = new QVBoxLayout(dlg);
 
     KDevelop::VcsEventWidget* logWidget = new KDevelop::VcsEventWidget(url, rev, iface, dlg);
     mainLayout->addWidget(logWidget);
 
     auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     dlg->connect(buttonBox, &QDialogButtonBox::accepted, dlg, &QDialog::accept);
     dlg->connect(buttonBox, &QDialogButtonBox::rejected, dlg, &QDialog::reject);
     mainLayout->addWidget(buttonBox);
 
     dlg->show();
 }
 
 void VcsPluginHelper::annotation()
 {
     SINGLEURL_SETUP_VARS
     KDevelop::IDocument* doc = ICore::self()->documentController()->documentForUrl(url);
 
     if (!doc)
         doc = ICore::self()->documentController()->openDocument(url);
 
     KTextEditor::AnnotationInterface* annotateiface = qobject_cast<KTextEditor::AnnotationInterface*>(doc->textDocument());
     KTextEditor::AnnotationViewInterface* viewiface = qobject_cast<KTextEditor::AnnotationViewInterface*>(doc->activeTextView());
     if (viewiface && viewiface->isAnnotationBorderVisible()) {
         viewiface->setAnnotationBorderVisible(false);
         return;
     }
 
     if (doc && doc->textDocument() && iface) {
         KDevelop::VcsJob* job = iface->annotate(url);
         if( !job )
         {
             qCWarning(VCS) << "Couldn't create annotate job for:" << url << "with iface:" << iface << dynamic_cast<KDevelop::IPlugin*>( iface );
             return;
         }
 
         QColor foreground(Qt::black);
         QColor background(Qt::white);
         if (KTextEditor::View* view = doc->activeTextView()) {
             KTextEditor::Attribute::Ptr style = view->defaultStyleAttribute(KTextEditor::dsNormal);
             foreground = style->foreground().color();
             if (style->hasProperty(QTextFormat::BackgroundBrush)) {
                 background = style->background().color();
             }
         }
 
         if (annotateiface && viewiface) {
+            // TODO: only create model if there is none yet (e.g. from another view)
             KDevelop::VcsAnnotationModel* model = new KDevelop::VcsAnnotationModel(job, url, doc->textDocument(),
                                                                                    foreground, background);
             annotateiface->setAnnotationModel(model);
             viewiface->setAnnotationBorderVisible(true);
             // can't use new signal slot syntax here, AnnotationInterface is not a QObject
             connect(doc->activeTextView(),
                     SIGNAL(annotationContextMenuAboutToShow(KTextEditor::View*,QMenu*,int)),
                     this, SLOT(annotationContextMenuAboutToShow(KTextEditor::View*,QMenu*,int)));
+            connect(doc->activeTextView(), SIGNAL(annotationBorderVisibilityChanged(View*,bool)),
+                    this, SLOT(handleAnnotationBorderVisibilityChanged(View*,bool)));
         } else {
             KMessageBox::error(nullptr, i18n("Cannot display annotations, missing interface KTextEditor::AnnotationInterface for the editor."));
             delete job;
         }
     } else {
         KMessageBox::error(nullptr, i18n("Cannot execute annotate action because the "
                                    "document was not found, or was not a text document:\n%1", url.toDisplayString(QUrl::PreferLocalFile)));
     }
 }
 
 void VcsPluginHelper::annotationContextMenuAboutToShow( KTextEditor::View* view, QMenu* menu, int line )
 {
     KTextEditor::AnnotationInterface* annotateiface =
         qobject_cast<KTextEditor::AnnotationInterface*>(view->document());
 
     VcsAnnotationModel* model = qobject_cast<VcsAnnotationModel*>( annotateiface->annotationModel() );
     Q_ASSERT(model);
 
     VcsRevision rev = model->revisionForLine(line);
     // check if the user clicked on a row without revision information
     if (rev.revisionType() == VcsRevision::Invalid) {
         // in this case, do not action depending on revision information
         return;
     }
 
     d->diffForRevAction->setData(QVariant::fromValue(rev));
     d->diffForRevGlobalAction->setData(QVariant::fromValue(rev));
     menu->addSeparator();
     menu->addAction(d->diffForRevAction);
     menu->addAction(d->diffForRevGlobalAction);
 
     QAction* copyAction = menu->addAction(QIcon::fromTheme(QStringLiteral("edit-copy")), i18n("Copy Revision"));
     connect(copyAction, &QAction::triggered, this, [this, rev]() {
         QApplication::clipboard()->setText(rev.revisionValue().toString());
     });
 
     QAction* historyAction = menu->addAction(QIcon::fromTheme(QStringLiteral("view-history")), i18n("History..."));
     connect(historyAction, &QAction::triggered, this, [this, rev]() {
         history(rev);
     });
 }
 
+void VcsPluginHelper::handleAnnotationBorderVisibilityChanged(View* view, bool visible)
+{
+    if (visible) {
+        return;
+    }
+
+    disconnect(view, SIGNAL(annotationContextMenuAboutToShow(KTextEditor::View*,QMenu*,int)),
+               this, SLOT(annotationContextMenuAboutToShow(KTextEditor::View*,QMenu*,int)));
+
+    disconnect(view, SIGNAL(annotationBorderVisibilityChanged(View*,bool)),
+               this, SLOT(handleAnnotationBorderVisibilityChanged(View*,bool)));
+
+    // TODO: remove the model if last user of it
+}
+
 void VcsPluginHelper::update()
 {
     EXECUTE_VCS_METHOD(update);
 }
 
 void VcsPluginHelper::add()
 {
     EXECUTE_VCS_METHOD(add);
 }
 
 void VcsPluginHelper::commit()
 {
     Q_ASSERT(!d->ctxUrls.isEmpty());
     ICore::self()->documentController()->saveAllDocuments();
 
     QUrl url = d->ctxUrls.first();
 
     // We start the commit UI no matter whether there is real differences, as it can also be used to commit untracked files
     VCSCommitDiffPatchSource* patchSource = new VCSCommitDiffPatchSource(new VCSStandardDiffUpdater(d->vcs, url));
 
     bool ret = showVcsDiff(patchSource);
 
     if(!ret) {
         ScopedDialog<VcsCommitDialog> commitDialog(patchSource);
         commitDialog->setCommitCandidates(patchSource->infos());
         commitDialog->exec();
     }
 }
 
 void VcsPluginHelper::push()
 {
     foreach(const QUrl &url, d->ctxUrls) {
         VcsJob* job = d->plugin->extension<IDistributedVersionControl>()->push(url, VcsLocation());
         ICore::self()->runController()->registerJob(job);
     }
 }
 
 void VcsPluginHelper::pull()
 {
     foreach(const QUrl &url, d->ctxUrls) {
         VcsJob* job = d->plugin->extension<IDistributedVersionControl>()->pull(VcsLocation(), url);
         ICore::self()->runController()->registerJob(job);
     }
 }
 
 }
 
 
diff --git a/vcs/vcspluginhelper.h b/vcs/vcspluginhelper.h
index e8716e021e..ed5f0c424c 100644
--- a/vcs/vcspluginhelper.h
+++ b/vcs/vcspluginhelper.h
@@ -1,86 +1,95 @@
 /***************************************************************************
  *   Copyright 2008 Andreas Pakulat <apaku@gmx.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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef KDEVPLATFORM_VCSPLUGINHELPER_H
 #define KDEVPLATFORM_VCSPLUGINHELPER_H
 
 #include "vcsexport.h"
 
 #include <QUrl>
 
 #include "vcsrevision.h"
 
 class KJob;
 class QMenu;
 
 namespace KTextEditor
 {
 class View;
 class Document;
 }
 
+// KTextEditor::AnnotationViewInterface has a bad signature in the
+// annotationBorderVisibilityChanged signal, using type "View" instead
+// of "KTextEditor::View".
+// To enable a string based signal-slot connection, as needed due to
+// annotationBorderVisibilityChanged being an "interface" signal,
+// with the slot VcsPluginHelper::removeAnnotationModel,
+// make View known here
 using KTextEditor::View;
 
 namespace KDevelop
 {
 class IPlugin;
 class IBasicVersionControl;
 class Context;
 class VcsPluginHelperPrivate;
 
 class KDEVPLATFORMVCS_EXPORT VcsPluginHelper
             : public QObject
 {
     Q_OBJECT
 public:
     VcsPluginHelper(IPlugin * parent, IBasicVersionControl * vcs);
     ~VcsPluginHelper() override;
 
     void setupFromContext(KDevelop::Context*);
     void addContextDocument(const QUrl& url);
     QList<QUrl> contextUrlList() const;
     /**
      * Creates and returns a menu with common actions.
      * Ownership of the actions in the menu stays with this VcsPluginHelper object.
      * @param parent the parent widget set for the QMenu for memory menagement
      */
     QMenu* commonActions(QWidget* parent);
 
 public Q_SLOTS:
     void commit();
     void add();
     void revert();
     void history(const VcsRevision& rev = VcsRevision::createSpecialRevision( VcsRevision::Base ));
     void annotation();
     void annotationContextMenuAboutToShow( KTextEditor::View* view, QMenu* menu, int line);
     void diffToBase();
     void diffForRev();
     void diffForRevGlobal();
     void update();
     void pull();
     void push();
     void diffJobFinished(KJob* job);
 
     void revertDone(KJob* job);
     void disposeEventually(KTextEditor::Document*);
     void disposeEventually(View*, bool);
 
 private Q_SLOTS:
     void delayedModificationWarningOn();
+    // namespace-less type "View" needed here, see comment above on "using KTextEditor::View;"
+    void handleAnnotationBorderVisibilityChanged(View* view, bool visible);
 
 private:
     void diffForRev(const QUrl& url);
 
     QScopedPointer<VcsPluginHelperPrivate> d;
 };
 
 } // namespace KDevelop
 
 #endif