diff --git a/plugins/subversion/CMakeLists.txt b/plugins/subversion/CMakeLists.txt
index 4da8b2d6d6..7069e21b1d 100644
--- a/plugins/subversion/CMakeLists.txt
+++ b/plugins/subversion/CMakeLists.txt
@@ -1,98 +1,96 @@
 add_definitions(-DTRANSLATION_DOMAIN=\"kdevsubversion\")
 project(KDevSubversionPlugin)
 
 add_subdirectory(tests)
 add_subdirectory(icons)
 
 include_directories( ${KDevSubversionPlugin_SOURCE_DIR}
                      ${KDevPlatform_SOURCE_DIR}/interfaces
                      ${SUBVERSION_INCLUDE_DIRS}
                      ${KDevSubversionPlugin_BINARY_DIR}
 )
 
 
 kde_enable_exceptions()
 
 ########### next target ###############
 
 set(kdevsubversion_WRAPPER_SRCS
     kdevsvncpp/apr.cpp
     kdevsvncpp/client_annotate.cpp
     kdevsvncpp/client_cat.cpp
     kdevsvncpp/client.cpp
     kdevsvncpp/client_diff.cpp
     kdevsvncpp/client_ls.cpp
     kdevsvncpp/client_modify.cpp
     kdevsvncpp/client_property.cpp
     kdevsvncpp/client_status.cpp
     kdevsvncpp/context.cpp
     kdevsvncpp/datetime.cpp
     kdevsvncpp/dirent.cpp
     kdevsvncpp/entry.cpp
     kdevsvncpp/exception.cpp
     kdevsvncpp/info.cpp
     kdevsvncpp/log_entry.cpp
     kdevsvncpp/path.cpp
     kdevsvncpp/pool.cpp
     kdevsvncpp/property.cpp
     kdevsvncpp/revision.cpp
     kdevsvncpp/status.cpp
     kdevsvncpp/status_selection.cpp
     kdevsvncpp/targets.cpp
     kdevsvncpp/url.cpp
     kdevsvncpp/wc.cpp
 )
 
 set(kdevsubversion_JOB_SRCS
     svninternaljobbase.cpp
     svnjobbase.cpp
     svncommitjob.cpp
     svnstatusjob.cpp
     svnaddjob.cpp
     svnupdatejob.cpp
     svnrevertjob.cpp
     svnremovejob.cpp
     svninfojob.cpp
     svndiffjob.cpp
     svncatjob.cpp
     svncopyjob.cpp
     svnmovejob.cpp
     svnlogjob.cpp
     svnblamejob.cpp
     svnimportjob.cpp
     svncheckoutjob.cpp
 )
 
 set(kdevsubversion_PART_SRCS
     kdevsvnplugin.cpp
     svnssldialog.cpp
     svnimportmetadatawidget.cpp
     svncheckoutmetadatawidget.cpp
     svnclient.cpp
     svnlocationwidget.cpp
 )
 
 set(kdevsubversion_PART_UI
     ui/ssltrustdialog.ui
     ui/importmetadatawidget.ui
     ui/checkoutmetadatawidget.ui
 )
 
 ki18n_wrap_ui(kdevsubversion_PART_SRCS ${kdevsubversion_PART_UI})
 
 kdevplatform_add_plugin(kdevsubversion JSON kdevsubversion.json SOURCES ${kdevsubversion_PART_SRCS} ${kdevsubversion_JOB_SRCS} ${kdevsubversion_WRAPPER_SRCS})
 
 target_link_libraries(kdevsubversion
     ${SUBVERSION_LIBRARIES}
     KF5::KIOCore
     KF5::TextEditor
     KF5::ThreadWeaver
     KF5::Parts
     KDev::Interfaces
     KDev::Vcs
     KDev::OutputView
     KDev::Project
     KDev::Language
-    # FIXME: poort away from this
-    KF5::KDELibs4Support
 )
diff --git a/plugins/subversion/kdevsvnplugin.cpp b/plugins/subversion/kdevsvnplugin.cpp
index 7e6e6ec12b..e2638c1110 100644
--- a/plugins/subversion/kdevsvnplugin.cpp
+++ b/plugins/subversion/kdevsvnplugin.cpp
@@ -1,530 +1,532 @@
 /***************************************************************************
  *   Copyright 2007 Dukju Ahn <dukjuahn@gmail.com>                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "kdevsvnplugin.h"
 
 #include <QAction>
-#include <QVariant>
-#include <QTextStream>
+#include <QDialog>
 #include <QMenu>
+#include <QVBoxLayout>
+#include <QVariant>
 
-#include <kparts/part.h>
-#include <kparts/partmanager.h>
-#include <kparts/mainwindow.h>
-#include <kaboutdata.h>
-#include <ktexteditor/document.h>
-#include <ktexteditor/markinterface.h>
-#include <kpluginfactory.h>
-#include <kpluginloader.h>
-#include <KLocalizedString>
-#include <kurlrequester.h>
-#include <QAction>
-#include <kurlrequesterdialog.h>
-#include <kfile.h>
-#include <QTemporaryFile>
-#include <kmessagebox.h>
+#include <KFile>
 #include <KIO/Global>
-#include <KDialog>
-
-#include <ThreadWeaver/Queue>
+#include <KLocalizedString>
+#include <KMessageBox>
+#include <KPluginFactory>
+#include <KTextEditor/Document>
+#include <KTextEditor/MarkInterface>
+#include <KUrlRequester>
+#include <KUrlRequesterDialog>
 
 #include <interfaces/iuicontroller.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/idocument.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/icore.h>
 #include <interfaces/iruncontroller.h>
 #include <project/projectmodel.h>
 #include <interfaces/context.h>
 #include <interfaces/contextmenuextension.h>
 #include <vcs/vcsrevision.h>
 #include <vcs/vcsevent.h>
 #include <vcs/vcsstatusinfo.h>
 #include <vcs/vcsannotation.h>
 #include <vcs/widgets/vcseventwidget.h>
 #include <vcs/widgets/vcsdiffwidget.h>
 #include <vcs/widgets/vcscommitdialog.h>
 #include <language/interfaces/editorcontext.h>
 
 #include "kdevsvncpp/apr.hpp"
 
 #include "svncommitjob.h"
 #include "svnstatusjob.h"
 #include "svnaddjob.h"
 #include "svnrevertjob.h"
 #include "svnremovejob.h"
 #include "svnupdatejob.h"
 #include "svninfojob.h"
 #include "svndiffjob.h"
 #include "svncopyjob.h"
 #include "svnmovejob.h"
 #include "svnlogjob.h"
 #include "svnblamejob.h"
 #include "svnimportjob.h"
 #include "svncheckoutjob.h"
 
 #include "svnimportmetadatawidget.h"
 #include "svncheckoutmetadatawidget.h"
 #include <vcs/vcspluginhelper.h>
 #include <vcs/widgets/standardvcslocationwidget.h>
 #include "svnlocationwidget.h"
 #include "debug.h"
 
 Q_LOGGING_CATEGORY(PLUGIN_SVN, "kdevplatform.plugins.svn")
 K_PLUGIN_FACTORY_WITH_JSON(KDevSvnFactory, "kdevsubversion.json", registerPlugin<KDevSvnPlugin>();)
 
 KDevSvnPlugin::KDevSvnPlugin(QObject *parent, const QVariantList &)
         : KDevelop::IPlugin("kdevsubversion", parent)
         , m_common(new KDevelop::VcsPluginHelper(this, this))
         , copy_action( 0 )
         , move_action( 0 )
         , m_jobQueue(new ThreadWeaver::Queue(this))
 {
     KDEV_USE_EXTENSION_INTERFACE(KDevelop::IBasicVersionControl)
     KDEV_USE_EXTENSION_INTERFACE(KDevelop::ICentralizedVersionControl)
 
     qRegisterMetaType<KDevelop::VcsStatusInfo>();
     qRegisterMetaType<SvnInfoHolder>();
     qRegisterMetaType<KDevelop::VcsEvent>();
     qRegisterMetaType<KDevelop::VcsRevision>();
     qRegisterMetaType<KDevelop::VcsRevision::RevisionSpecialType>();
     qRegisterMetaType<KDevelop::VcsAnnotation>();
     qRegisterMetaType<KDevelop::VcsAnnotationLine>();
 }
 
 KDevSvnPlugin::~KDevSvnPlugin()
 {
 }
 
 bool KDevSvnPlugin::isVersionControlled(const QUrl &localLocation)
 {
     ///TODO: also check this in the other functions?
     if (!localLocation.isValid()) {
         return false;
     }
 
     SvnInfoJob* job = new SvnInfoJob(this);
 
     job->setLocation(localLocation);
 
     if (job->exec()) {
         QVariant result = job->fetchResults();
 
         if (result.isValid()) {
             SvnInfoHolder h = result.value<SvnInfoHolder>();
             return !h.name.isEmpty();
         }
     } else {
         qCDebug(PLUGIN_SVN) << "Couldn't execute job";
     }
 
     return false;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::repositoryLocation(const QUrl &localLocation)
 {
     SvnInfoJob* job = new SvnInfoJob(this);
 
     job->setLocation(localLocation);
     job->setProvideInformation(SvnInfoJob::RepoUrlOnly);
     return job;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::status(const QList<QUrl>& localLocations,
                                         KDevelop::IBasicVersionControl::RecursionMode mode)
 {
     SvnStatusJob* job = new SvnStatusJob(this);
     job->setLocations(localLocations);
     job->setRecursive((mode == KDevelop::IBasicVersionControl::Recursive));
     return job;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::add(const QList<QUrl>& localLocations,
                                      KDevelop::IBasicVersionControl::RecursionMode recursion)
 {
     SvnAddJob* job = new SvnAddJob(this);
     job->setLocations(localLocations);
     job->setRecursive((recursion == KDevelop::IBasicVersionControl::Recursive));
     return job;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::remove(const QList<QUrl>& localLocations)
 {
     SvnRemoveJob* job = new SvnRemoveJob(this);
     job->setLocations(localLocations);
     return job;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::edit(const QUrl& /*localLocation*/)
 {
     return 0;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::unedit(const QUrl& /*localLocation*/)
 {
     return 0;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::localRevision(const QUrl &localLocation, KDevelop::VcsRevision::RevisionType type)
 {
     SvnInfoJob* job = new SvnInfoJob(this);
 
     job->setLocation(localLocation);
     job->setProvideInformation(SvnInfoJob::RevisionOnly);
     job->setProvideRevisionType(type);
     return job;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::copy(const QUrl &localLocationSrc, const QUrl& localLocationDstn)
 {
     SvnCopyJob* job = new SvnCopyJob(this);
     job->setSourceLocation(localLocationSrc);
     job->setDestinationLocation(localLocationDstn);
     return job;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::move(const QUrl &localLocationSrc, const QUrl& localLocationDst)
 {
     SvnMoveJob* job = new SvnMoveJob(this);
     job->setSourceLocation(localLocationSrc);
     job->setDestinationLocation(localLocationDst);
     return job;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::revert(const QList<QUrl>& localLocations,
                                         KDevelop::IBasicVersionControl::RecursionMode recursion)
 {
     SvnRevertJob* job = new SvnRevertJob(this);
     job->setLocations(localLocations);
     job->setRecursive((recursion == KDevelop::IBasicVersionControl::Recursive));
     return job;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::update(const QList<QUrl>& localLocations,
                                         const KDevelop::VcsRevision& rev,
                                         KDevelop::IBasicVersionControl::RecursionMode recursion)
 {
     SvnUpdateJob* job = new SvnUpdateJob(this);
     job->setLocations(localLocations);
     job->setRevision(rev);
     job->setRecursive((recursion == KDevelop::IBasicVersionControl::Recursive));
     return job;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::commit(const QString& message, const QList<QUrl>& localLocations,
                                         KDevelop::IBasicVersionControl::RecursionMode recursion)
 {
     SvnCommitJob* job = new SvnCommitJob(this);
     qCDebug(PLUGIN_SVN) << "Committing locations:" << localLocations << endl;
     job->setUrls(localLocations);
     job->setCommitMessage(message) ;
     job->setRecursive((recursion == KDevelop::IBasicVersionControl::Recursive));
     return job;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::diff(const QUrl &fileOrDirectory,
                                       const KDevelop::VcsRevision& srcRevision,
                                       const KDevelop::VcsRevision& dstRevision,
                                       KDevelop::VcsDiff::Type diffType,
                                       KDevelop::IBasicVersionControl::RecursionMode recurse)
 {
     KDevelop::VcsLocation loc(fileOrDirectory);
     return diff2(loc, loc, srcRevision, dstRevision, diffType, recurse);
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::diff2(const KDevelop::VcsLocation& src,
                                        const KDevelop::VcsLocation& dst,
                                        const KDevelop::VcsRevision& srcRevision,
                                        const KDevelop::VcsRevision& dstRevision,
                                        KDevelop::VcsDiff::Type diffType,
                                        KDevelop::IBasicVersionControl::RecursionMode recurse)
 {
     SvnDiffJob* job = new SvnDiffJob(this);
     job->setSource(src);
     job->setDestination(dst);
     job->setSrcRevision(srcRevision);
     job->setDstRevision(dstRevision);
     job->setDiffType(diffType);
     job->setRecursive((recurse == KDevelop::IBasicVersionControl::Recursive));
     return job;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::log(const QUrl &localLocation, const KDevelop::VcsRevision& rev, unsigned long limit)
 {
     SvnLogJob* job = new SvnLogJob(this);
     job->setLocation(localLocation);
     job->setStartRevision(rev);
     job->setLimit(limit);
     return job;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::log(const QUrl &localLocation,
                                      const KDevelop::VcsRevision& startRev,
                                      const KDevelop::VcsRevision& endRev)
 {
     SvnLogJob* job = new SvnLogJob(this);
     job->setLocation(localLocation);
     job->setStartRevision(startRev);
     job->setEndRevision(endRev);
     return job;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::annotate(const QUrl &localLocation,
         const KDevelop::VcsRevision& rev)
 {
     SvnBlameJob* job = new SvnBlameJob(this);
     job->setLocation(localLocation);
     job->setEndRevision(rev);
     return job;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::merge(const KDevelop::VcsLocation& localOrRepoLocationSrc,
                                        const KDevelop::VcsLocation& localOrRepoLocationDst,
                                        const KDevelop::VcsRevision& srcRevision,
                                        const KDevelop::VcsRevision& dstRevision,
                                        const QUrl &localLocation)
 {
     // TODO implement merge
     Q_UNUSED(localOrRepoLocationSrc)
     Q_UNUSED(localOrRepoLocationDst)
     Q_UNUSED(srcRevision)
     Q_UNUSED(dstRevision)
     Q_UNUSED(localLocation)
     return 0;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::resolve(const QList<QUrl>& /*localLocations*/,
         KDevelop::IBasicVersionControl::RecursionMode /*recursion*/)
 {
     return 0;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::import(const QString & commitMessage, const QUrl &sourceDirectory, const KDevelop::VcsLocation & destinationRepository)
 {
     SvnImportJob* job = new SvnImportJob(this);
     job->setMapping(sourceDirectory, destinationRepository);
     job->setMessage(commitMessage);
     return job;
 }
 
 KDevelop::VcsJob* KDevSvnPlugin::createWorkingCopy(const KDevelop::VcsLocation & sourceRepository, const QUrl &destinationDirectory, KDevelop::IBasicVersionControl::RecursionMode recursion)
 {
     SvnCheckoutJob* job = new SvnCheckoutJob(this);
     job->setMapping(sourceRepository, destinationDirectory, recursion);
     return job;
 }
 
 
 KDevelop::ContextMenuExtension KDevSvnPlugin::contextMenuExtension(KDevelop::Context* context)
 {
     m_common->setupFromContext(context);
 
     const QList<QUrl> & ctxUrlList  = m_common->contextUrlList();
 
     bool hasVersionControlledEntries = false;
     foreach(const QUrl &url, ctxUrlList) {
         if (isVersionControlled(url) || isVersionControlled(KIO::upUrl(url))) {
             hasVersionControlledEntries = true;
             break;
         }
     }
 
     qCDebug(PLUGIN_SVN) << "version controlled?" << hasVersionControlledEntries;
 
     if (!hasVersionControlledEntries)
         return IPlugin::contextMenuExtension(context);
 
 
     QMenu* svnmenu= m_common->commonActions();
     svnmenu->addSeparator();
 
     if( !copy_action )
     {
         copy_action = new QAction(i18n("Copy..."), this);
         connect(copy_action, SIGNAL(triggered()), this, SLOT(ctxCopy()));
     }
     svnmenu->addAction(copy_action);
 
     if( !move_action )
     {
         move_action = new QAction(i18n("Move..."), this);
         connect(move_action, SIGNAL(triggered()), this, SLOT(ctxMove()));
     }
     svnmenu->addAction(move_action);
 
     KDevelop::ContextMenuExtension menuExt;
     menuExt.addAction(KDevelop::ContextMenuExtension::VcsGroup, svnmenu->menuAction());
 
     return menuExt;
 }
 
 void KDevSvnPlugin::ctxInfo()
 {
     QList<QUrl> const & ctxUrlList = m_common->contextUrlList();
     if (ctxUrlList.count() != 1) {
         KMessageBox::error(0, i18n("Please select only one item for this operation"));
         return;
     }
 }
 
 void KDevSvnPlugin::ctxStatus()
 {
     QList<QUrl> const & ctxUrlList = m_common->contextUrlList();
     if (ctxUrlList.count() > 1) {
         KMessageBox::error(0, i18n("Please select only one item for this operation"));
         return;
     }
 }
 
 void KDevSvnPlugin::ctxCopy()
 {
     QList<QUrl> const & ctxUrlList = m_common->contextUrlList();
     if (ctxUrlList.count() > 1) {
         KMessageBox::error(0, i18n("Please select only one item for this operation"));
         return;
     }
 
     QUrl source = ctxUrlList.first();
 
     if (source.isLocalFile()) {
         QUrl dir = source;
         bool isFile = QFileInfo(source.toLocalFile()).isFile();
 
         if (isFile) {
             dir = dir.adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash);
         }
 
         KUrlRequesterDialog dlg(dir, i18n("Destination file/directory"), 0);
 
         if (isFile) {
             dlg.urlRequester()->setMode(KFile::File | KFile::Directory | KFile::LocalOnly);
         } else {
             dlg.urlRequester()->setMode(KFile::Directory | KFile::LocalOnly);
         }
 
         if (dlg.exec() == QDialog::Accepted) {
             KDevelop::ICore::self()->runController()->registerJob(copy(source, dlg.selectedUrl()));
         }
     } else {
         KMessageBox::error(0, i18n("Copying only works on local files"));
         return;
     }
 
 }
 
 void KDevSvnPlugin::ctxMove()
 {
     QList<QUrl> const & ctxUrlList = m_common->contextUrlList();
     if (ctxUrlList.count() != 1) {
         KMessageBox::error(0, i18n("Please select only one item for this operation"));
         return;
     }
 
     QUrl source = ctxUrlList.first();
 
     if (source.isLocalFile()) {
         QUrl dir = source;
         bool isFile = QFileInfo(source.toLocalFile()).isFile();
 
         if (isFile) {
             dir = source.adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash);
         }
 
         KUrlRequesterDialog dlg(dir, i18n("Destination file/directory"), 0);
 
-        dlg.fileDialog()->setAcceptMode(QFileDialog::AcceptSave);
         if (isFile) {
             dlg.urlRequester()->setMode(KFile::File | KFile::Directory | KFile::LocalOnly);
         } else {
             dlg.urlRequester()->setMode(KFile::Directory | KFile::LocalOnly);
         }
 
         if (dlg.exec() == QDialog::Accepted) {
             KDevelop::ICore::self()->runController()->registerJob(move(source, dlg.selectedUrl()));
         }
     } else {
         KMessageBox::error(0, i18n("Moving only works on local files/dirs"));
         return;
     }
 }
 
 void KDevSvnPlugin::ctxCat()
 {
     QList<QUrl> const & ctxUrlList = m_common->contextUrlList();
     if (ctxUrlList.count() != 1) {
         KMessageBox::error(0, i18n("Please select only one item for this operation"));
         return;
     }
 }
 
 QString KDevSvnPlugin::name() const
 {
     return i18n("Subversion");
 }
 
 KDevelop::VcsImportMetadataWidget* KDevSvnPlugin::createImportMetadataWidget(QWidget* parent)
 {
     return new SvnImportMetadataWidget(parent);
 }
 
 void KDevSvnPlugin::ctxImport()
 {
     QList<QUrl> const & ctxUrlList = m_common->contextUrlList();
     if (ctxUrlList.count() != 1) {
         KMessageBox::error(0, i18n("Please select only one item for this operation"));
         return;
     }
 
-    KDialog dlg;
+    QDialog dlg;
 
-    dlg.setCaption(i18n("Import into Subversion repository"));
+    dlg.setWindowTitle(i18n("Import into Subversion repository"));
     SvnImportMetadataWidget* widget = new SvnImportMetadataWidget(&dlg);
     widget->setSourceLocation(KDevelop::VcsLocation(ctxUrlList.first()));
     widget->setSourceLocationEditable(false);
-    dlg.setMainWidget(widget);
+    auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
+    auto layout = new QVBoxLayout();
+    dlg.setLayout(layout);
+    layout->addWidget(widget);
+    layout->addWidget(buttonBox);
+    connect(buttonBox, &QDialogButtonBox::accepted, &dlg, &QDialog::accept);
+    connect(buttonBox, &QDialogButtonBox::rejected, &dlg, &QDialog::reject);
 
     if (dlg.exec() == QDialog::Accepted) {
         KDevelop::ICore::self()->runController()->registerJob(import(widget->message(), widget->source(), widget->destination()));
     }
 }
 
 void KDevSvnPlugin::ctxCheckout()
 {
     QList<QUrl> const & ctxUrlList = m_common->contextUrlList();
     if (ctxUrlList.count() != 1) {
         KMessageBox::error(0, i18n("Please select only one item for this operation"));
         return;
     }
 
-    KDialog dlg;
+    QDialog dlg;
 
-    dlg.setCaption(i18n("Checkout from Subversion repository"));
+    dlg.setWindowTitle(i18n("Checkout from Subversion repository"));
     SvnCheckoutMetadataWidget* widget = new SvnCheckoutMetadataWidget(&dlg);
     QUrl tmp = KIO::upUrl(ctxUrlList.first());
     widget->setDestinationLocation(tmp);
-    dlg.setMainWidget(widget);
+    auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
+    auto layout = new QVBoxLayout();
+    dlg.setLayout(layout);
+    layout->addWidget(widget);
+    layout->addWidget(buttonBox);
+    connect(buttonBox, &QDialogButtonBox::accepted, &dlg, &QDialog::accept);
+    connect(buttonBox, &QDialogButtonBox::rejected, &dlg, &QDialog::reject);
 
     if (dlg.exec() == QDialog::Accepted) {
         KDevelop::ICore::self()->runController()->registerJob(createWorkingCopy(widget->source(), widget->destination(), widget->recursionMode()));
     }
 }
 
 KDevelop::VcsLocationWidget* KDevSvnPlugin::vcsLocation(QWidget* parent) const
 {
     return new SvnLocationWidget(parent);
 }
 
 ThreadWeaver::Queue* KDevSvnPlugin::jobQueue() const
 {
     return m_jobQueue;
 }
 
 #include "kdevsvnplugin.moc"
diff --git a/plugins/subversion/svncheckoutjob.cpp b/plugins/subversion/svncheckoutjob.cpp
index 0cdd5025fe..5c669ee323 100644
--- a/plugins/subversion/svncheckoutjob.cpp
+++ b/plugins/subversion/svncheckoutjob.cpp
@@ -1,124 +1,123 @@
 /***************************************************************************
  *   This file is part of KDevelop                                         *
  *   Copyright 2007 Andreas Pakulat <apaku@gmx.de>                        *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU Library 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 Library 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 "svncheckoutjob.h"
 #include "svncheckoutjob_p.h"
 
+#include <QFileInfo>
 #include <QMutexLocker>
 
-#include <KLocalizedString>
 #include <KIO/Global>
+#include <KLocalizedString>
 
 #include "kdevsvncpp/client.hpp"
 #include "kdevsvncpp/path.hpp"
 
 #include <vcs/vcslocation.h>
 #include <util/path.h>
 
-#include <QFileInfo>
-
 SvnInternalCheckoutJob::SvnInternalCheckoutJob( SvnJobBase* parent )
     : SvnInternalJobBase( parent )
     , m_recursion( KDevelop::IBasicVersionControl::Recursive )
 {
 }
 
 bool SvnInternalCheckoutJob::isValid() const
 {
     QMutexLocker l( m_mutex );
     return m_sourceRepository.isValid() && m_destinationDirectory.isLocalFile() && QFileInfo(KIO::upUrl(m_destinationDirectory).toLocalFile()).exists();
 }
 
 void SvnInternalCheckoutJob::run(ThreadWeaver::JobPointer /*self*/, ThreadWeaver::Thread* /*thread*/)
 {
     initBeforeRun();
 
     svn::Client cli(m_ctxt);
     try {
         bool recurse = ( recursion() == KDevelop::IBasicVersionControl::Recursive );
         QUrl desturl = QUrl( source().repositoryServer() ).adjusted(QUrl::StripTrailingSlash | QUrl::NormalizePathSegments  );
         const QByteArray srcba = desturl.url().toUtf8();
         KDevelop::Path destdir(KDevelop::Path(destination()).parent(), destination().fileName());
         QByteArray destba = destdir.toLocalFile().toUtf8();
         qCDebug(PLUGIN_SVN) << srcba << destba << recurse;
         cli.checkout( srcba.data(), svn::Path( destba.data() ), svn::Revision::HEAD, recurse );
     } catch( svn::ClientException ce ) {
         qCDebug(PLUGIN_SVN) << "Exception while checking out: " << source().repositoryServer() << ce.message();
         setErrorMessage( QString::fromUtf8( ce.message() ) );
         m_success = false;
     }
 }
 
 
 void SvnInternalCheckoutJob::setMapping( const KDevelop::VcsLocation & sourceRepository, const QUrl & destinationDirectory, KDevelop::IBasicVersionControl::RecursionMode recursion )
 {
     QMutexLocker l( m_mutex );
     m_sourceRepository = sourceRepository;
     m_destinationDirectory = destinationDirectory;
     m_recursion = recursion;
 }
 
 KDevelop::VcsLocation SvnInternalCheckoutJob::source() const
 {
     QMutexLocker l( m_mutex );
     return m_sourceRepository;
 }
 
 KDevelop::IBasicVersionControl::RecursionMode SvnInternalCheckoutJob::recursion() const
 {
     QMutexLocker l( m_mutex );
     return m_recursion;
 }
 
 QUrl SvnInternalCheckoutJob::destination() const
 {
     QMutexLocker l( m_mutex );
     return m_destinationDirectory;
 }
 
 SvnCheckoutJob::SvnCheckoutJob( KDevSvnPlugin* parent )
     : SvnJobBaseImpl( new SvnInternalCheckoutJob(this), parent, KDevelop::OutputJob::Silent )
 {
     setType( KDevelop::VcsJob::Import );
     setObjectName(i18n("Subversion Checkout"));
 }
 
 QVariant SvnCheckoutJob::fetchResults()
 {
     return QVariant();
 }
 
 void SvnCheckoutJob::start()
 {
     if (!m_job->isValid() ) {
         internalJobFailed();
         setErrorText( i18n( "Not enough information to checkout" ) );
     } else {
         qCDebug(PLUGIN_SVN) << "checking out: " << m_job->source().repositoryServer();
         startInternalJob();
     }
 }
 
 void SvnCheckoutJob::setMapping( const KDevelop::VcsLocation & sourceRepository, const QUrl & destinationDirectory, KDevelop::IBasicVersionControl::RecursionMode recursion )
 {
     if( status() == KDevelop::VcsJob::JobNotStarted ) {
         m_job->setMapping(sourceRepository, destinationDirectory, recursion);
     }
 }
diff --git a/plugins/subversion/svnssldialog.cpp b/plugins/subversion/svnssldialog.cpp
index 23b4bc4ced..b654d7c7c3 100644
--- a/plugins/subversion/svnssldialog.cpp
+++ b/plugins/subversion/svnssldialog.cpp
@@ -1,83 +1,85 @@
 /***************************************************************************
  *   Copyright 2007 Dukju Ahn <dukjuahn@gmail.com>                         *
  *                                                                         *
  *   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 "svnssldialog.h"
+
+#include <QPushButton>
 #include <QTreeWidgetItem>
+
 #include <KLocalizedString>
 
 #include "ui_ssltrustdialog.h"
 
 class SvnSSLTrustDialogPrivate
 {
 public:
     Ui::SvnSSLTrustDialog ui;
     bool temporarily;
 };
 
 SvnSSLTrustDialog::SvnSSLTrustDialog( QWidget *parent )
-    : KDialog( parent ), d( new SvnSSLTrustDialogPrivate )
+    : QDialog( parent ), d( new SvnSSLTrustDialogPrivate )
 {
-    d->ui.setupUi( mainWidget() );
+    d->ui.setupUi( this );
     d->temporarily = true;
-    setCaption( i18n( "Ssl Server Certificate" ) );
-    setButtons( KDialog::User1 | KDialog::User2 | KDialog::Cancel );
-    setDefaultButton( KDialog::User2 );
-    setButtonText( KDialog::User2, i18n("Trust Temporarily") );
-    setButtonText( KDialog::User1, i18n("Trust Permanently") );
-    connect( this, SIGNAL(user1Clicked()), this, SLOT(permanentlyClicked()) );
-    connect( this, SIGNAL(user2Clicked()), this, SLOT(temporarilyClicked()) );
+    setWindowTitle( i18n( "Ssl Server Certificate" ) );
+    buttonBox = new QDialogButtonBox(QDialogButtonBox::Cancel);
+    buttonBox->addButton(i18n("Trust Permanently"), QDialogButtonBox::YesRole);
+    buttonBox->addButton(i18n("Trust Temporarily"), QDialogButtonBox::AcceptRole)->setDefault(true);
+    auto layout = new QVBoxLayout();
+    setLayout(layout);
+    layout->addWidget(buttonBox);
+    connect(buttonBox, &QDialogButtonBox::clicked, this, &SvnSSLTrustDialog::buttonClicked);
 }
 SvnSSLTrustDialog::~SvnSSLTrustDialog()
 {
     delete d;
 }
 
 void SvnSSLTrustDialog::setCertInfos( const QString& hostname,
                                       const QString& fingerPrint,
                                       const QString& validfrom,
                                       const QString& validuntil,
                                       const QString& issuerName,
                                       const QString& realm,
                                       const QStringList& failures )
 {
     QString txt = "<ul>";
     foreach( const QString &fail, failures )
     {
         txt += "<li>"+fail+"</li>";
     }
     d->ui.reasons->setHtml( txt );
 
     d->ui.hostname->setText( hostname );
     d->ui.fingerprint->setText( fingerPrint );
     d->ui.validUntil->setText( validuntil );
     d->ui.validFrom->setText( validfrom );
     d->ui.issuer->setText( issuerName );
-    setCaption( i18n( "Ssl Server Certificate: %1", realm ) );
+    setWindowTitle( i18n( "Ssl Server Certificate: %1", realm ) );
 
 }
 
 bool SvnSSLTrustDialog::useTemporarily()
 {
     return d->temporarily;
 }
 
-void SvnSSLTrustDialog::temporarilyClicked()
-{
-    d->temporarily = true;
-    accept();
-}
-
-void SvnSSLTrustDialog::permanentlyClicked()
+void SvnSSLTrustDialog::buttonClicked(QAbstractButton *button)
 {
-    d->temporarily = false;
+    if (buttonBox->buttonRole(button) == QDialogButtonBox::AcceptRole)
+    {
+        d->temporarily = true;
+    } else
+    {
+        d->temporarily = false;
+    }
     accept();
 }
-
-
diff --git a/plugins/subversion/svnssldialog.h b/plugins/subversion/svnssldialog.h
index 5f9565e0a9..6ccc9b8e47 100644
--- a/plugins/subversion/svnssldialog.h
+++ b/plugins/subversion/svnssldialog.h
@@ -1,35 +1,36 @@
 /***************************************************************************
  *   Copyright 2007 Dukju Ahn <dukjuahn@gmail.com>                         *
  *                                                                         *
  *   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_PLUGIN_SVN_SSLDIALOG_H
 #define KDEVPLATFORM_PLUGIN_SVN_SSLDIALOG_H
 
-#include <kdialog.h>
+#include <QDialog>
+#include <QDialogButtonBox>
 
-class SvnSSLTrustDialog: public KDialog
+class SvnSSLTrustDialog: public QDialog
 {
     Q_OBJECT
 public:
     SvnSSLTrustDialog( QWidget *parent = 0 );
     virtual ~SvnSSLTrustDialog();
 
     void setCertInfos( const QString& hostname, const QString& fingerPrint,
                        const QString& validfrom, const QString& validuntil,
                        const QString& issuerName, const QString& realm,
                        const QStringList& failures );
     bool useTemporarily();
 private slots:
-    void temporarilyClicked();
-    void permanentlyClicked();
+    void buttonClicked(QAbstractButton *button);
 private:
     class SvnSSLTrustDialogPrivate *d;
+    QDialogButtonBox *buttonBox;
 };
 
 #endif
diff --git a/plugins/subversion/tests/svnrecursiveadd.cpp b/plugins/subversion/tests/svnrecursiveadd.cpp
index 9672ca3ec0..947f0e6023 100644
--- a/plugins/subversion/tests/svnrecursiveadd.cpp
+++ b/plugins/subversion/tests/svnrecursiveadd.cpp
@@ -1,158 +1,160 @@
 /***************************************************************************
 *   This file is part of KDevelop                                         *
 *   Copyright 2009 Fabian Wiesel <fabian.wiesel@googlemail.com>           *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Library 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 Library 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 "svnrecursiveadd.h"
-#include <QtTest/QtTest>
+
+#include <QDebug>
 #include <QTemporaryDir>
+#include <QtTest>
+
 #include <KProcess>
-#include <kparts/part.h>
-#include <QDebug>
+
 #include <interfaces/iplugincontroller.h>
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 #include <vcs/interfaces/icentralizedversioncontrol.h>
 #include <vcs/vcsjob.h>
 
 #define PATHETIC    // A little motivator to make things work right :)
 #if defined(PATHETIC)
 const QString vcsTestDir0("testdir0");
 const QString vcsTestDir1("testdir1");
 const QString vcsTest_FileName0("foo");
 const QString vcsTest_FileName1("bar");
 const QString keywordText("text");
 #else
 const QString vcsTestDir0("dvcs\t testdir");   // Directory containing whitespaces
 const QString vcsTestDir1("--help");           // Starting with hyphen for command-line tools
 const QString vcsTest_FileName0("foo\t bar");
 const QString vcsTest_FileName1("--help");
 const QString keywordText("Author:\nDate:\nCommit:\n------------------------------------------------------------------------\nr999999 | ehrman | 1989-11-09 18:53:00 +0100 (Thu, 09 Nov 1989) | 1 lines\nthe line\n");  // Text containing keywords of the various vcs-programs
 #endif
 
 const QString simpleText("It's foo!\n");
 const QString simpleAltText("No, foo()! It's bar()!\n");
 
 #define VERBOSE
 #if defined(VERBOSE)
 #define TRACE(X) qDebug() << X
 #else
 #define TRACE(X) { line = line; }
 #endif
 
 using namespace KDevelop;
 
 void validatingExecJob(VcsJob* j, VcsJob::JobStatus status = VcsJob::JobSucceeded)
 {
     QVERIFY(j);
     // Print the commands in full, for easier bug location
 #if 0
     if (QLatin1String(j->metaObject()->className()) == "DVcsJob") {
         qDebug() << "Command: \"" << ((DVcsJob*)j)->getChildproc()->program() << ((DVcsJob*)j)->getChildproc()->workingDirectory();
         qDebug() << "Output: \"" << ((DVcsJob*)j)->output();
     }
 #endif
 
     if (!j->exec()) {
         qDebug() << "ooops, no exec";
         qDebug() << j->errorString();
         // On error, wait for key in order to allow manual state inspection
 #if 0
         char c;
         std::cin.read(&c, 1);
 #endif
     }
 
     QCOMPARE(j->status(), status);
 }
 
 void verifiedWrite(QUrl const & url, QString const & contents)
 {
     QFile f(url.path());
     QVERIFY(f.open(QIODevice::WriteOnly));
     QTextStream filecontents(&f);
     filecontents << contents;
     filecontents.flush();
     f.flush();
 }
 
 
 void fillWorkingDirectory(QString const & dirname)
 {
     QDir dir(dirname);
     //we start it after repoInit, so we still have empty dvcs repo
     QVERIFY(dir.mkdir(vcsTestDir0));
     QVERIFY(dir.cd(vcsTestDir0));
     QUrl file0 = QUrl::fromLocalFile(dir.absoluteFilePath(vcsTest_FileName0));
     QVERIFY(dir.mkdir(vcsTestDir1));
     QVERIFY(dir.cd(vcsTestDir1));
     QUrl file1 = QUrl::fromLocalFile(dir.absoluteFilePath(vcsTest_FileName1));
     verifiedWrite(file0, simpleText);
     verifiedWrite(file1, keywordText);
 }
 
 void SvnRecursiveAdd::initTestCase()
 {
     AutoTestShell::init();
     TestCore::initialize();
 }
 
 void SvnRecursiveAdd::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 void SvnRecursiveAdd::test()
 {
     QTemporaryDir reposDir;
     KProcess cmd;
     cmd.setWorkingDirectory(reposDir.path());
     cmd << "svnadmin" << "create" << reposDir.path();
     QCOMPARE(cmd.execute(10000), 0);
     QList<IPlugin*> plugins = Core::self()->pluginController()->allPluginsForExtension("org.kdevelop.IBasicVersionControl");
     IBasicVersionControl* vcs = NULL;
     foreach(IPlugin* p,  plugins) {
         qDebug() << "checking plugin" << p;
         ICentralizedVersionControl* icentr = p->extension<ICentralizedVersionControl>();
         if (!icentr)
             continue;
         if (icentr->name() == "Subversion") {
             vcs = icentr;
             break;
         }
     }
     qDebug() << "ok, got vcs" << vcs;
     QVERIFY(vcs);
     VcsLocation reposLoc;
     reposLoc.setRepositoryServer("file://" + reposDir.path());
     QTemporaryDir checkoutDir;
     QUrl checkoutLoc = QUrl::fromLocalFile(checkoutDir.path());
     qDebug() << "Checking out from " << reposLoc.repositoryServer() << " to " << checkoutLoc;
     qDebug() << "creating job";
     VcsJob* job = vcs->createWorkingCopy( reposLoc, checkoutLoc );
     validatingExecJob(job);
     qDebug() << "filling wc";
     fillWorkingDirectory(checkoutDir.path());
     QUrl addUrl = QUrl::fromLocalFile( checkoutDir.path() + '/' + vcsTestDir0 );
     qDebug() << "Recursively adding files at " << addUrl;
     validatingExecJob(vcs->add({addUrl}, IBasicVersionControl::Recursive));
     qDebug() << "Recursively reverting changes at " << addUrl;
     validatingExecJob(vcs->revert({addUrl}, IBasicVersionControl::Recursive));
 }
 
 QTEST_MAIN(SvnRecursiveAdd)