diff --git a/src/crypto/gui/decryptverifyfilesdialog.cpp b/src/crypto/gui/decryptverifyfilesdialog.cpp
index 6698e9b9d..97da92d44 100644
--- a/src/crypto/gui/decryptverifyfilesdialog.cpp
+++ b/src/crypto/gui/decryptverifyfilesdialog.cpp
@@ -1,260 +1,268 @@
 /* crypto/gui/decryptverifyfilesdialog.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2007 Klarälvdalens Datakonsult AB
     Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     Kleopatra 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.
 
     Kleopatra 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
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #include "decryptverifyfilesdialog.h"
 
 #include "kleopatra_debug.h"
 
 #include "crypto/taskcollection.h"
 #include "crypto/decryptverifytask.h"
 #include "crypto/gui/resultpage.h"
 #include "crypto/gui/resultlistwidget.h"
 
 #include <Libkleo/FileNameRequester>
 
+#include <QWindow>
 #include <QVBoxLayout>
 #include <QProgressBar>
 #include <QLabel>
 #include <QDialogButtonBox>
 #include <QPushButton>
 
 #include <vector>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KConfigGroup>
 #include <KSharedConfig>
+#include <KWindowConfig>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 DecryptVerifyFilesDialog::DecryptVerifyFilesDialog(const std::shared_ptr<TaskCollection> &coll, QWidget *parent)
     : QDialog(parent), m_tasks(coll), m_saveButton(QDialogButtonBox::NoButton), m_buttonBox(new QDialogButtonBox)
 {
     readConfig();
     auto vLay = new QVBoxLayout(this);
     auto labels = new QWidget;
     auto outputLayout = new QHBoxLayout;
 
     m_outputLocationFNR = new FileNameRequester;
     auto outLabel = new QLabel(i18n("&Output folder:"));
     outLabel->setBuddy(m_outputLocationFNR);
     outputLayout->addWidget(outLabel);
     outputLayout->addWidget(m_outputLocationFNR);
     m_outputLocationFNR->setFilter(QDir::Dirs);
 
     vLay->addLayout(outputLayout);
 
     m_progressLabelLayout = new QVBoxLayout(labels);
     vLay->addWidget(labels);
     m_progressBar = new QProgressBar;
     vLay->addWidget(m_progressBar);
     m_resultList = new ResultListWidget;
     vLay->addWidget(m_resultList);
 
     m_tasks = coll;
     Q_ASSERT(m_tasks);
     m_resultList->setTaskCollection(coll);
     connect(m_tasks.get(), &TaskCollection::progress, this, &DecryptVerifyFilesDialog::progress);
     connect(m_tasks.get(), &TaskCollection::done, this, &DecryptVerifyFilesDialog::allDone);
     connect(m_tasks.get(), &TaskCollection::result, this, &DecryptVerifyFilesDialog::result);
     connect(m_tasks.get(), &TaskCollection::started, this, &DecryptVerifyFilesDialog::started);
 
     connect(m_buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
     connect(m_buttonBox, &QDialogButtonBox::clicked, this, &DecryptVerifyFilesDialog::btnClicked);
 
     layout()->addWidget(m_buttonBox);
 
     bool hasOutputs = false;
     for (const auto &t: coll->tasks()) {
         if (!qobject_cast<VerifyDetachedTask *>(t.get())) {
             hasOutputs = true;
             break;
         }
     }
     if (hasOutputs) {
         setWindowTitle(i18nc("@title:window", "Decrypt/Verify Files"));
         m_saveButton = QDialogButtonBox::SaveAll;
         m_buttonBox->addButton(QDialogButtonBox::Discard);
         connect(m_buttonBox, &QDialogButtonBox::accepted, this, &DecryptVerifyFilesDialog::checkAccept);
     } else {
         outLabel->setVisible(false);
         m_outputLocationFNR->setVisible(false);
         setWindowTitle(i18nc("@title:window", "Verify Files"));
         m_buttonBox->addButton(QDialogButtonBox::Close);
         connect(m_buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
     }
     if (m_saveButton) {
         m_buttonBox->addButton(m_saveButton);
         m_buttonBox->button(m_saveButton)->setEnabled(false);
     }
 }
 
 DecryptVerifyFilesDialog::~DecryptVerifyFilesDialog()
 {
     qCDebug(KLEOPATRA_LOG);
     writeConfig();
 }
 
 void DecryptVerifyFilesDialog::allDone()
 {
     qCDebug(KLEOPATRA_LOG) << "All done";
     Q_ASSERT(m_tasks);
     m_progressBar->setRange(0, 100);
     m_progressBar->setValue(100);
     for (const auto &i: m_progressLabelByTag.keys()) {
         if (!i.isEmpty()) {
             m_progressLabelByTag.value(i)->setText(i18n("%1: All operations completed.", i));
         } else {
             m_progressLabelByTag.value(i)->setText(i18n("All operations completed."));
         }
     }
 
     if (m_tasks->allTasksHaveErrors()) {
         return;
     }
     if (m_saveButton != QDialogButtonBox::NoButton) {
         m_buttonBox->button(m_saveButton)->setEnabled(true);
     } else {
         m_buttonBox->removeButton(m_buttonBox->button(QDialogButtonBox::Close));
         m_buttonBox->addButton(QDialogButtonBox::Ok);
     }
 }
 
 void DecryptVerifyFilesDialog::started(const std::shared_ptr<Task> &task)
 {
     Q_ASSERT(task);
     const auto tag = task->tag();
     auto label = labelForTag(tag);
     Q_ASSERT(label);
     if (tag.isEmpty()) {
         label->setText(i18nc("number, operation description", "Operation %1: %2", m_tasks->numberOfCompletedTasks() + 1, task->label()));
     } else {
         label->setText(i18nc("tag( \"OpenPGP\" or \"CMS\"),  operation description", "%1: %2", tag, task->label()));
     }
     if (m_saveButton != QDialogButtonBox::NoButton) {
         m_buttonBox->button(m_saveButton)->setEnabled(false);
     } else if (m_buttonBox->button(QDialogButtonBox::Ok)) {
         m_buttonBox->removeButton(m_buttonBox->button(QDialogButtonBox::Ok));
         m_buttonBox->addButton(QDialogButtonBox::Close);
     }
 }
 
 QLabel *DecryptVerifyFilesDialog::labelForTag(const QString &tag)
 {
     if (QLabel *const label = m_progressLabelByTag.value(tag)) {
         return label;
     }
     auto label = new QLabel;
     label->setTextFormat(Qt::RichText);
     label->setWordWrap(true);
     m_progressLabelLayout->addWidget(label);
     m_progressLabelByTag.insert(tag, label);
     return label;
 }
 
 void DecryptVerifyFilesDialog::progress(const QString &msg, int progress, int total)
 {
     Q_UNUSED(msg);
     Q_ASSERT(progress >= 0);
     Q_ASSERT(total >= 0);
     m_progressBar->setRange(0, total);
     m_progressBar->setValue(progress);
 }
 
 void DecryptVerifyFilesDialog::setOutputLocation(const QString &dir)
 {
     m_outputLocationFNR->setFileName(dir);
 }
 
 QString DecryptVerifyFilesDialog::outputLocation() const
 {
     return m_outputLocationFNR->fileName();
 }
 
 void DecryptVerifyFilesDialog::btnClicked(QAbstractButton *btn)
 {
     if (m_buttonBox->buttonRole(btn) == QDialogButtonBox::DestructiveRole) {
         close();
     }
 }
 
 void DecryptVerifyFilesDialog::checkAccept() {
     const auto outLoc = outputLocation();
     if (outLoc.isEmpty()) {
         KMessageBox::information(this, i18n("Please select an output folder."),
                                  i18n("No output folder."));
         return;
     }
     const QFileInfo fi(outLoc);
 
     if (fi.exists() && fi.isDir() && fi.isWritable()) {
         accept();
         return;
     }
 
     if (!fi.exists()) {
         qCDebug(KLEOPATRA_LOG) << "Output dir does not exist. Trying to create.";
         const QDir dir(outLoc);
         if (!dir.mkdir(outLoc)) {
             KMessageBox::information(this, i18n("Please select a different output folder."),
                                      i18n("Failed to create output folder."));
             return;
         } else {
             accept();
             return;
         }
     }
 
     KMessageBox::information(this, i18n("Please select a different output folder."),
                              i18n("Invalid output folder."));
 }
 
 void DecryptVerifyFilesDialog::readConfig()
 {
+    winId(); // ensure there's a window created
+
+    // set default window size
+    windowHandle()->resize(640, 480);
+
+    // restore size from config file
     KConfigGroup cfgGroup(KSharedConfig::openConfig(), "DecryptVerifyFilesDialog");
-    const QByteArray geom = cfgGroup.readEntry("geometry", QByteArray());
-    if (!geom.isEmpty()) {
-        restoreGeometry(geom);
-        return;
-    }
-    resize(QSize(640, 480));
+    KWindowConfig::restoreWindowSize(windowHandle(), cfgGroup);
+
+    // NOTICE: QWindow::setGeometry() does NOT impact the backing QWidget geometry even if the platform
+    // window was created -> QTBUG-40584. We therefore copy the size here.
+    // TODO: remove once this was resolved in QWidget QPA
+    resize(windowHandle()->size());
 }
 
 void DecryptVerifyFilesDialog::writeConfig()
 {
     KConfigGroup cfgGroup(KSharedConfig::openConfig(), "DecryptVerifyFilesDialog");
-    cfgGroup.writeEntry("geometry", saveGeometry());
+    KWindowConfig::saveWindowSize(windowHandle(), cfgGroup);
     cfgGroup.sync();
 }
diff --git a/src/crypto/gui/signencryptfileswizard.cpp b/src/crypto/gui/signencryptfileswizard.cpp
index 9fd1c5231..7938fc078 100644
--- a/src/crypto/gui/signencryptfileswizard.cpp
+++ b/src/crypto/gui/signencryptfileswizard.cpp
@@ -1,521 +1,541 @@
 /*  crypto/gui/signencryptfileswizard.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2009 Klarälvdalens Datakonsult AB
     2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     Kleopatra 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.
 
     Kleopatra 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
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #include <config-kleopatra.h>
 
 #include "signencryptfileswizard.h"
 #include "signencryptwidget.h"
 
 #include "newresultpage.h"
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <KColorScheme>
 #include <KConfigGroup>
+#include <KWindowConfig>
 
 #include <KMessageBox>
 
 #include "kleopatra_debug.h"
 #include <utils/gnupg-helper.h>
 
 #include <Libkleo/FileNameRequester>
+#include <QWindow>
 #include <QVBoxLayout>
 #include <QWizardPage>
 #include <QGroupBox>
 #include <QLabel>
 #include <QIcon>
 #include <QCheckBox>
 
 
 #include <gpgme++/key.h>
 
 
 using namespace GpgME;
 using namespace Kleo;
 using namespace Kleo::Crypto::Gui;
 
 enum Page {
     SigEncPageId,
     ResultPageId,
 
     NumPages
 };
 
 class SigEncPage: public QWizardPage
 {
     Q_OBJECT
 
 public:
     explicit SigEncPage(QWidget *parent = nullptr)
         : QWizardPage(parent),
           mParent((SignEncryptFilesWizard *) parent),
           mWidget(new SignEncryptWidget),
           mOutLayout(new QVBoxLayout),
           mArchive(false),
           mUseOutputDir(false)
     {
         setTitle(i18nc("@title", "Sign / Encrypt Files"));
         auto vLay = new QVBoxLayout(this);
         vLay->setContentsMargins(0, 0, 0, 0);
         vLay->addWidget(mWidget);
         connect(mWidget, &SignEncryptWidget::operationChanged, this,
                 &SigEncPage::updateCommitButton);
         connect(mWidget, &SignEncryptWidget::keysChanged, this,
                 &SigEncPage::updateFileWidgets);
         updateCommitButton(mWidget->currentOp());
 
         auto outputGrp = new QGroupBox(i18n("Output"));
         outputGrp->setLayout(mOutLayout);
 
         mPlaceholderWidget = new QLabel(i18n("Please select an action."));
         mOutLayout->addWidget(mPlaceholderWidget);
 
         mUseOutputDirChk = new QCheckBox(i18n("Encrypt / Sign each file separately."));
         mUseOutputDirChk->setToolTip(i18nc("@info",
                                             "Keep each file separate instead of creating an archive for all."));
 
         mOutLayout->addWidget(mUseOutputDirChk);
         connect (mUseOutputDirChk, &QCheckBox::toggled, this, [this] (bool state) {
                     mUseOutputDir = state;
                     mArchive = !mUseOutputDir;
                     updateFileWidgets();
                 });
 
         vLay->addWidget(outputGrp);
         setMinimumHeight(300);
     }
 
     void setEncryptionPreset(bool value)
     {
         mWidget->setEncryptionChecked(value);
     }
 
     void setSigningPreset(bool value)
     {
         mWidget->setSigningChecked(value);
     }
 
     bool isComplete() const override
     {
         return !mWidget->currentOp().isNull();
     }
 
     int nextId() const override
     {
         return ResultPageId;
     }
 
     void initializePage() override
     {
         setCommitPage(true);
     }
 
     void setArchiveForced(bool archive)
     {
         mArchive = archive;
         setArchiveMutable(!archive);
     }
 
     void setArchiveMutable(bool archive)
     {
         mUseOutputDirChk->setVisible(archive);
         if (archive) {
             const KConfigGroup archCfg(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
             mUseOutputDirChk->setChecked(archCfg.readEntry("LastUseOutputDir", false));
         } else {
             mUseOutputDirChk->setChecked(false);
         }
     }
 
     bool validatePage() override
     {
         bool sign = !mWidget->signKey().isNull();
         bool encrypt = !mWidget->selfKey().isNull() || !mWidget->recipients().empty();
         if (!mWidget->validate()) {
             return false;
         }
         mWidget->saveOwnKeys();
         if (mUseOutputDirChk->isVisible()) {
             KConfigGroup archCfg(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
             archCfg.writeEntry("LastUseOutputDir", mUseOutputDir);
         }
 
         if (sign && !encrypt && mArchive) {
             return KMessageBox::warningContinueCancel(this,
             xi18nc("@info",
             "<para>Archiving in combination with sign-only currently requires what are known as opaque signatures - "
             "unlike detached ones, these embed the content in the signature.</para>"
             "<para>This format is rather unusual. You might want to archive the files separately, "
             "and then sign the archive as one file with Kleopatra.</para>"
             "<para>Future versions of Kleopatra are expected to also support detached signatures in this case.</para>"),
             i18nc("@title:window", "Unusual Signature Warning"),
             KStandardGuiItem::cont(), KStandardGuiItem::cancel(),
             QStringLiteral("signencryptfileswizard-archive+sign-only-warning"))
             == KMessageBox::Continue;
         } else if (sign && !encrypt) {
             return true;
         }
 
         if (!mWidget->selfKey().isNull()) {
             return true;
         }
         bool hasSecret = false;
         Q_FOREACH (const Key k, mWidget->recipients()) {
             if (k.hasSecret()) {
                 hasSecret = true;
                 break;
             }
         }
         if (!hasSecret && !mWidget->encryptSymmetric()) {
             if (KMessageBox::warningContinueCancel(this,
             xi18nc("@info",
             "<para>None of the recipients you are encrypting to seems to be your own.</para>"
             "<para>This means that you will not be able to decrypt the data anymore, once encrypted.</para>"
             "<para>Do you want to continue, or cancel to change the recipient selection?</para>"),
             i18nc("@title:window", "Encrypt-To-Self Warning"),
             KStandardGuiItem::cont(),
             KStandardGuiItem::cancel(),
             QStringLiteral("warn-encrypt-to-non-self"), KMessageBox::Notify | KMessageBox::Dangerous)
             == KMessageBox::Cancel) {
                 return false;
             }
         }
         return true;
     }
 
     QVector<Key> recipients() const
     {
         return mWidget->recipients();
     }
 
     /* In the future we might find a usecase for multiple
      * signers */
     QVector<Key> signers() const
     {
         QVector<Key> ret;
         const Key k = mWidget->signKey();
         if (!k.isNull()) {
             ret << k;
         }
         return ret;
     }
 
 private:
     QWidget *createRequester(int forKind, QBoxLayout *lay) {
         static const QMap <int, QString> icons = {
             { SignEncryptFilesWizard::SignatureCMS, QStringLiteral("document-sign") },
             { SignEncryptFilesWizard::SignaturePGP, QStringLiteral("document-sign") },
             { SignEncryptFilesWizard::CombinedPGP,  QStringLiteral("document-edit-sign-encrypt") },
             { SignEncryptFilesWizard::EncryptedPGP, QStringLiteral("document-encrypt") },
             { SignEncryptFilesWizard::EncryptedCMS, QStringLiteral("document-encrypt") },
             { SignEncryptFilesWizard::Directory,    QStringLiteral("folder") }
         };
         static const QMap <int, QString> toolTips = {
             { SignEncryptFilesWizard::SignatureCMS, i18n("The S/MIME signature.") },
             { SignEncryptFilesWizard::SignaturePGP, i18n("The signature.") },
             { SignEncryptFilesWizard::CombinedPGP,  i18n("The signed and encrypted file.") },
             { SignEncryptFilesWizard::EncryptedPGP, i18n("The encrypted file.") },
             { SignEncryptFilesWizard::EncryptedCMS, i18n("The S/MIME encrypted file.") },
             { SignEncryptFilesWizard::Directory,    i18n("Output directory.") }
         };
 
         FileNameRequester *req = new FileNameRequester(forKind == SignEncryptFilesWizard::Directory ?
                                                        QDir::Dirs : QDir::Files, this);
         req->setFileName(mOutNames[forKind]);
         QHBoxLayout *hLay = new QHBoxLayout;
         QLabel *iconLabel = new QLabel;
         QWidget *ret = new QWidget;
         iconLabel->setPixmap(QIcon::fromTheme(icons[forKind]).pixmap(32,32));
         hLay->addWidget(iconLabel);
         iconLabel->setToolTip(toolTips[forKind]);
         req->setToolTip(toolTips[forKind]);
         hLay->addWidget(req);
         ret->setLayout(hLay);
         lay->addWidget(ret);
 
         connect (req, &FileNameRequester::fileNameChanged, this,
                  [this, forKind](const QString &newName) {
                     mOutNames[forKind] = newName;
                  });
         return ret;
     }
 
 public:
     void setOutputNames(const QMap<int, QString> &names) {
         Q_ASSERT(mOutNames.isEmpty());
         mOutNames = names;
         Q_FOREACH (int i, mOutNames.keys()) {
             mRequester[i] = createRequester(i, mOutLayout);
         }
         updateFileWidgets();
     }
 
     QMap <int, QString> outputNames() const {
         if (!mUseOutputDir) {
             auto ret = mOutNames;
             ret.remove(SignEncryptFilesWizard::Directory);
             return ret;
         }
         return mOutNames;
     }
 
     bool encryptSymmetric() const
     {
         return mWidget->encryptSymmetric();
     }
 
 private Q_SLOTS:
     void updateCommitButton(const QString &label)
     {
         auto btn = mParent->button(QWizard::CommitButton);
         if (!label.isEmpty()) {
             btn->setText(label);
             if (Kleo::gpgComplianceP("de-vs")) {
                 bool de_vs = mWidget->isDeVsAndValid();
                 btn->setIcon(QIcon::fromTheme(de_vs
                                              ? QStringLiteral("security-high")
                                              : QStringLiteral("security-medium")));
                 btn->setStyleSheet(QStringLiteral("background-color: ") + (de_vs
                                    ? KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::PositiveBackground).color().name()
                                    : KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::NegativeBackground).color().name()));
                 mParent->setLabelText(de_vs
                                       ? i18nc("VS-NfD-conforming is a German standard for restricted documents for which special restrictions about algorithms apply.  The string states that all cryptographic operations necessary for the communication are compliant with that.",
                                               "VS-NfD-compliant communication possible.")
                                       : i18nc("VS-NfD-conforming is a German standard for restricted documents for which special restrictions about algorithms apply.  The string states that all cryptographic operations necessary for the communication are compliant with that.",
                                               "VS-NfD-compliant communication not possible."));
             }
         } else {
             btn->setText(i18n("Next"));
             btn->setIcon(QIcon());
             btn->setStyleSheet(QString());
         }
         Q_EMIT completeChanged();
     }
 
     void updateFileWidgets()
     {
         if (mRequester.isEmpty()) {
             return;
         }
         const QVector<Key> recipients = mWidget->recipients();
         const Key sigKey = mWidget->signKey();
         bool pgp = mWidget->encryptSymmetric();
         bool cms = false;
 
         for (const Key &k : recipients) {
             if (pgp && cms) {
                 break;
             }
             if (k.protocol() == Protocol::OpenPGP) {
                 pgp = true;
             } else {
                 cms = true;
             }
         }
         mOutLayout->setEnabled(false);
         mPlaceholderWidget->setVisible(!cms && !pgp && sigKey.isNull());
         mRequester[SignEncryptFilesWizard::SignatureCMS]->setVisible(!mUseOutputDir && sigKey.protocol() == Protocol::CMS);
         mRequester[SignEncryptFilesWizard::EncryptedCMS]->setVisible(!mUseOutputDir && cms);
         mRequester[SignEncryptFilesWizard::CombinedPGP]->setVisible(!mUseOutputDir && sigKey.protocol() == Protocol::OpenPGP && pgp);
         mRequester[SignEncryptFilesWizard::EncryptedPGP]->setVisible(!mUseOutputDir && pgp && sigKey.protocol() != Protocol::OpenPGP);
         mRequester[SignEncryptFilesWizard::SignaturePGP]->setVisible(!mUseOutputDir && sigKey.protocol() == Protocol::OpenPGP && !pgp);
         mRequester[SignEncryptFilesWizard::Directory]->setVisible(mUseOutputDir && !mPlaceholderWidget->isVisible());
         mOutLayout->setEnabled(true);
     }
 
 private:
     SignEncryptFilesWizard *mParent;
     SignEncryptWidget *mWidget;
     QMap <int, QString> mOutNames;
     QMap <int, QWidget *> mRequester;
     QVBoxLayout *mOutLayout;
     QWidget *mPlaceholderWidget;
     QCheckBox *mUseOutputDirChk;
     bool mArchive;
     bool mUseOutputDir;
 };
 
 class ResultPage : public NewResultPage
 {
     Q_OBJECT
 
 public:
     explicit ResultPage(QWidget *parent = nullptr)
         : NewResultPage(parent),
           mParent((SignEncryptFilesWizard *) parent)
     {
         setTitle(i18nc("@title", "Results"));
         setSubTitle(i18nc("@title",
                           "Status and progress of the crypto operations is shown here."));
     }
 
     void initializePage() override
     {
         mParent->setLabelText(QString());
     }
 
 private:
     SignEncryptFilesWizard *mParent;
 };
 
 SignEncryptFilesWizard::SignEncryptFilesWizard(QWidget *parent, Qt::WindowFlags f)
     : QWizard(parent, f)
     , mSigningUserMutable(true)
     , mEncryptionUserMutable(true)
 {
+    readConfig();
+
     bool de_vs = Kleo::gpgComplianceP("de-vs");
 #ifdef Q_OS_WIN
     // Enforce modern style to avoid vista style ugliness.
     setWizardStyle(QWizard::ModernStyle);
 #endif
     mSigEncPage = new SigEncPage(this);
     mResultPage = new ResultPage(this);
 
     connect(this, &QWizard::currentIdChanged, this,
             &SignEncryptFilesWizard::slotCurrentIdChanged);
     setPage(SigEncPageId, mSigEncPage);
     setPage(ResultPageId, mResultPage);
     setOptions(QWizard::IndependentPages |
                (de_vs ? QWizard::HaveCustomButton1 : (QWizard::WizardOption) 0) |
                QWizard::NoBackButtonOnLastPage |
                QWizard::NoBackButtonOnStartPage);
 
     if (de_vs) {
         /* We use a custom button to display a label next to the
            buttons.  */
         mLabel = button(QWizard::CustomButton1);
         /* We style the button so that it looks and acts like a
            label.  */
         mLabel->setStyleSheet(QStringLiteral("border: none"));
         mLabel->setFocusPolicy(Qt::NoFocus);
     } else {
         mLabel = nullptr;
     }
-
-    KConfigGroup cfgGroup(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
-    const QByteArray geom = cfgGroup.readEntry("geometry", QByteArray());
-    if (!geom.isEmpty()) {
-        restoreGeometry(geom);
-        return;
-    }
 }
 
 void SignEncryptFilesWizard::setLabelText(const QString &label) const
 {
     if (mLabel) {
         mLabel->setText(label);
     }
 }
 
 void SignEncryptFilesWizard::slotCurrentIdChanged(int id)
 {
     if (id == ResultPageId) {
         Q_EMIT operationPrepared();
     }
 }
 
 SignEncryptFilesWizard::~SignEncryptFilesWizard()
 {
     qCDebug(KLEOPATRA_LOG);
-    KConfigGroup cfgGroup(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
-    cfgGroup.writeEntry("geometry", saveGeometry());
-    cfgGroup.sync();
+    writeConfig();
 }
 
 void SignEncryptFilesWizard::setSigningPreset(bool preset)
 {
     mSigEncPage->setSigningPreset(preset);
 }
 
 void SignEncryptFilesWizard::setSigningUserMutable(bool mut)
 {
     if (mut == mSigningUserMutable) {
         return;
     }
     mSigningUserMutable = mut;
 }
 
 void SignEncryptFilesWizard::setEncryptionPreset(bool preset)
 {
     mSigEncPage->setEncryptionPreset(preset);
 }
 
 void SignEncryptFilesWizard::setEncryptionUserMutable(bool mut)
 {
     if (mut == mEncryptionUserMutable) {
         return;
     }
     mEncryptionUserMutable = mut;
 }
 
 void SignEncryptFilesWizard::setArchiveForced(bool archive)
 {
     mSigEncPage->setArchiveForced(archive);
 }
 
 void SignEncryptFilesWizard::setArchiveMutable(bool archive)
 {
     mSigEncPage->setArchiveMutable(archive);
 }
 
 QVector<Key> SignEncryptFilesWizard::resolvedRecipients() const
 {
     return mSigEncPage->recipients();
 }
 
 QVector<Key> SignEncryptFilesWizard::resolvedSigners() const
 {
     return mSigEncPage->signers();
 }
 
 void SignEncryptFilesWizard::setTaskCollection(const std::shared_ptr<Kleo::Crypto::TaskCollection> &coll)
 {
     mResultPage->setTaskCollection(coll);
 }
 
 void SignEncryptFilesWizard::setOutputNames(const QMap<int, QString> &map) const
 {
     mSigEncPage->setOutputNames(map);
 }
 
 QMap<int, QString> SignEncryptFilesWizard::outputNames() const
 {
     return mSigEncPage->outputNames();
 }
 
 bool SignEncryptFilesWizard::encryptSymmetric() const
 {
     return mSigEncPage->encryptSymmetric();
 }
 
+void SignEncryptFilesWizard::readConfig()
+{
+    winId(); // ensure there's a window created
+
+    // set default window size
+    windowHandle()->resize(640, 480);
+
+    // restore size from config file
+    KConfigGroup cfgGroup(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
+    KWindowConfig::restoreWindowSize(windowHandle(), cfgGroup);
+
+    // NOTICE: QWindow::setGeometry() does NOT impact the backing QWidget geometry even if the platform
+    // window was created -> QTBUG-40584. We therefore copy the size here.
+    // TODO: remove once this was resolved in QWidget QPA
+    resize(windowHandle()->size());
+}
+
+void SignEncryptFilesWizard::writeConfig()
+{
+    KConfigGroup cfgGroup(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
+    KWindowConfig::saveWindowSize(windowHandle(), cfgGroup);
+    cfgGroup.sync();
+}
+
+
 #include "signencryptfileswizard.moc"
diff --git a/src/crypto/gui/signencryptfileswizard.h b/src/crypto/gui/signencryptfileswizard.h
index ecc7f7171..bddf7f870 100644
--- a/src/crypto/gui/signencryptfileswizard.h
+++ b/src/crypto/gui/signencryptfileswizard.h
@@ -1,123 +1,127 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/signencryptfileswizard.h
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2009 Klarälvdalens Datakonsult AB
     2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     Kleopatra 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.
 
     Kleopatra 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
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #ifndef __KLEOPATRA_CRYPTO_GUI_SIGNENCRYPTFILESWIZARD_H__
 #define __KLEOPATRA_CRYPTO_GUI_SIGNENCRYPTFILESWIZARD_H__
 
 #include <utils/pimpl_ptr.h>
 
 #include <gpgme++/global.h>
 
 #include <QWizard>
 
 #include <QVector>
 #include <QMap>
 
 #include <memory>
 
 
 namespace GpgME
 {
 class Key;
 }
 
 namespace Kleo
 {
 namespace Crypto
 {
 class TaskCollection;
 }
 }
 
 class ResultPage;
 class SigEncPage;
 
 namespace Kleo
 {
 
 class SignEncryptFilesWizard : public QWizard
 {
     Q_OBJECT
 public:
     enum KindNames{
         SignatureCMS,
         CombinedPGP,
         EncryptedPGP,
         EncryptedCMS,
         SignaturePGP,
         Directory
     };
 
     explicit SignEncryptFilesWizard(QWidget *parent = nullptr, Qt::WindowFlags f = {});
     ~SignEncryptFilesWizard();
 
     // Inputs
     void setSigningPreset(bool preset);
     void setSigningUserMutable(bool mut);
 
     void setEncryptionPreset(bool preset);
     void setEncryptionUserMutable(bool mut);
 
     void setArchiveForced(bool archive);
     void setArchiveMutable(bool archive);
 
     void setOutputNames(const QMap<int, QString> &nameMap) const;
     QMap<int, QString> outputNames() const;
 
     void setTaskCollection(const std::shared_ptr<Kleo::Crypto::TaskCollection> &coll);
 
     // Outputs
     QVector<GpgME::Key> resolvedRecipients() const;
     QVector<GpgME::Key> resolvedSigners() const;
     bool encryptSymmetric() const;
 
     void setLabelText(const QString &label) const;
 
+protected:
+    void readConfig();
+    void writeConfig();
+
 Q_SIGNALS:
     void operationPrepared();
 
 private Q_SLOTS:
     void slotCurrentIdChanged(int);
 
 private:
     SigEncPage *mSigEncPage;
     ResultPage *mResultPage;
     QAbstractButton *mLabel;
     bool mSigningUserMutable,
          mEncryptionUserMutable;
 };
 
 }
 
 #endif /* __KLEOPATRA_CRYPTO_GUI_SIGNENCRYPTFILESWIZARD_H__ */
diff --git a/src/kleopatraapplication.cpp b/src/kleopatraapplication.cpp
index 463c7c646..989f14b42 100644
--- a/src/kleopatraapplication.cpp
+++ b/src/kleopatraapplication.cpp
@@ -1,661 +1,665 @@
 /*
     kleopatraapplication.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2008 Klarälvdalens Datakonsult AB
     2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     Kleopatra 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.
 
     Kleopatra 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
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #include <config-kleopatra.h>
 
 #include "kleopatraapplication.h"
 
 #include "mainwindow.h"
 #include "kleopatra_options.h"
 #include "systrayicon.h"
 #include <smartcard/readerstatus.h>
 #include <conf/configuredialog.h>
 
 #include <utils/gnupg-helper.h>
 #include <utils/kdpipeiodevice.h>
 #include <utils/log.h>
 
 #include <gpgme++/key.h>
 
 #include <Libkleo/FileSystemWatcher>
 #include <Libkleo/KeyCache>
 #include <Libkleo/Classify>
 
 #ifdef HAVE_USABLE_ASSUAN
 # include <uiserver/uiserver.h>
 #endif
 
 #include "commands/signencryptfilescommand.h"
 #include "commands/decryptverifyfilescommand.h"
 #include "commands/lookupcertificatescommand.h"
 #include "commands/checksumcreatefilescommand.h"
 #include "commands/checksumverifyfilescommand.h"
 #include "commands/detailscommand.h"
 #include "commands/newcertificatecommand.h"
 
 #include "dialogs/updatenotification.h"
 
 #include <KIconLoader>
 #include <KLocalizedString>
 #include "kleopatra_debug.h"
 #include <KMessageBox>
 #include <KWindowSystem>
 
 #include <QFile>
 #include <QDir>
 #include <QPointer>
 
 #include <memory>
 #include <KSharedConfig>
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 
 static void add_resources()
 {
     KIconLoader::global()->addAppDir(QStringLiteral("libkleopatra"));
     KIconLoader::global()->addAppDir(QStringLiteral("kwatchgnupg"));
 }
 
 static QList<QByteArray> default_logging_options()
 {
     QList<QByteArray> result;
     result.push_back("io");
     return result;
 }
 
 class KleopatraApplication::Private
 {
     friend class ::KleopatraApplication;
     KleopatraApplication *const q;
 public:
     explicit Private(KleopatraApplication *qq)
         : q(qq),
           ignoreNewInstance(true),
           firstNewInstance(true),
           sysTray(nullptr)
     {
     }
     ~Private() {
 #ifndef QT_NO_SYSTEMTRAYICON
         delete sysTray;
 #endif
     }
     void init()
     {
         KDAB_SET_OBJECT_NAME(readerStatus);
 #ifndef QT_NO_SYSTEMTRAYICON
         sysTray = new SysTrayIcon();
         sysTray->setAnyCardHasNullPin(readerStatus.anyCardHasNullPin());
         sysTray->setAnyCardCanLearnKeys(readerStatus.anyCardCanLearnKeys());
 
         connect(&readerStatus, &SmartCard::ReaderStatus::anyCardHasNullPinChanged,
                 sysTray, &SysTrayIcon::setAnyCardHasNullPin);
         connect(&readerStatus, &SmartCard::ReaderStatus::anyCardCanLearnKeysChanged,
                 sysTray, &SysTrayIcon::setAnyCardCanLearnKeys);
 #endif
     }
 
 private:
     void connectConfigureDialog()
     {
         if (configureDialog && q->mainWindow()) {
             connect(configureDialog, SIGNAL(configCommitted()), q->mainWindow(), SLOT(slotConfigCommitted()));
         }
     }
     void disconnectConfigureDialog()
     {
         if (configureDialog && q->mainWindow()) {
             disconnect(configureDialog, SIGNAL(configCommitted()), q->mainWindow(), SLOT(slotConfigCommitted()));
         }
     }
 
 public:
     bool ignoreNewInstance;
     bool firstNewInstance;
     QPointer<ConfigureDialog> configureDialog;
     QPointer<MainWindow> mainWindow;
     SmartCard::ReaderStatus readerStatus;
 #ifndef QT_NO_SYSTEMTRAYICON
     SysTrayIcon *sysTray;
 #endif
     std::shared_ptr<KeyCache> keyCache;
     std::shared_ptr<Log> log;
     std::shared_ptr<FileSystemWatcher> watcher;
 
 public:
     void setupKeyCache()
     {
         keyCache = KeyCache::mutableInstance();
         watcher.reset(new FileSystemWatcher);
 
         watcher->whitelistFiles(gnupgFileWhitelist());
         watcher->addPath(gnupgHomeDirectory());
         watcher->setDelay(1000);
         keyCache->addFileSystemWatcher(watcher);
     }
 
     void setupLogging()
     {
         log = Log::mutableInstance();
 
         const QByteArray envOptions = qgetenv("KLEOPATRA_LOGOPTIONS");
         const bool logAll = envOptions.trimmed() == "all";
         const QList<QByteArray> options = envOptions.isEmpty() ? default_logging_options() : envOptions.split(',');
 
         const QByteArray dirNative = qgetenv("KLEOPATRA_LOGDIR");
         if (dirNative.isEmpty()) {
             return;
         }
         const QString dir = QFile::decodeName(dirNative);
         const QString logFileName = QDir(dir).absoluteFilePath(QStringLiteral("kleopatra.log.%1").arg(QCoreApplication::applicationPid()));
         std::unique_ptr<QFile> logFile(new QFile(logFileName));
         if (!logFile->open(QIODevice::WriteOnly | QIODevice::Append)) {
             qCDebug(KLEOPATRA_LOG) << "Could not open file for logging: " << logFileName << "\nLogging disabled";
             return;
         }
 
         log->setOutputDirectory(dir);
         if (logAll || options.contains("io")) {
             log->setIOLoggingEnabled(true);
         }
         qInstallMessageHandler(Log::messageHandler);
 
 #ifdef HAVE_USABLE_ASSUAN
         if (logAll || options.contains("pipeio")) {
             KDPipeIODevice::setDebugLevel(KDPipeIODevice::Debug);
         }
         UiServer::setLogStream(log->logFile());
 #endif
 
     }
 };
 
 KleopatraApplication::KleopatraApplication(int &argc, char *argv[])
     : QApplication(argc, argv), d(new Private(this))
 {
 }
 
 void KleopatraApplication::init()
 {
     d->init();
     add_resources();
     d->setupKeyCache();
     d->setupLogging();
 #ifndef QT_NO_SYSTEMTRAYICON
     d->sysTray->show();
 #endif
     setQuitOnLastWindowClosed(false);
     KWindowSystem::allowExternalProcessWindowActivation();
 }
 
 KleopatraApplication::~KleopatraApplication()
 {
+    // main window doesn't receive "close" signal and cannot
+    // save settings before app exit
+    delete d->mainWindow;
+
     // work around kdelibs bug https://bugs.kde.org/show_bug.cgi?id=162514
     KSharedConfig::openConfig()->sync();
 }
 
 namespace
 {
 typedef void (KleopatraApplication::*Func)(const QStringList &, GpgME::Protocol);
 }
 
 void KleopatraApplication::slotActivateRequested(const QStringList &arguments,
         const QString &workingDirectory)
 {
     QCommandLineParser parser;
 
     kleopatra_options(&parser);
     QString err;
     if (!arguments.isEmpty() && !parser.parse(arguments)) {
         err = parser.errorText();
     } else if (arguments.isEmpty()) {
         // KDBusServices omits the application name if no other
         // arguments are provided. In that case the parser prints
         // a warning.
         parser.parse(QStringList() << QCoreApplication::applicationFilePath());
     }
 
     if (err.isEmpty()) {
         err = newInstance(parser, workingDirectory);
     }
 
     if (!err.isEmpty()) {
         KMessageBox::sorry(nullptr, err.toHtmlEscaped(), i18n("Failed to execute command"));
         Q_EMIT setExitValue(1);
         return;
     }
     Q_EMIT setExitValue(0);
 }
 
 QString KleopatraApplication::newInstance(const QCommandLineParser &parser,
         const QString &workingDirectory)
 {
     if (d->ignoreNewInstance) {
         qCDebug(KLEOPATRA_LOG) << "New instance ignored because of ignoreNewInstance";
         return QString();
     }
 
     QStringList files;
     const QDir cwd = QDir(workingDirectory);
     Q_FOREACH (const QString &file, parser.positionalArguments()) {
         // We do not check that file exists here. Better handle
         // these errors in the UI.
         if (QFileInfo(file).isAbsolute()) {
             files << file;
         } else {
             files << cwd.absoluteFilePath(file);
         }
     }
 
     GpgME::Protocol protocol = GpgME::UnknownProtocol;
 
     if (parser.isSet(QStringLiteral("openpgp"))) {
         qCDebug(KLEOPATRA_LOG) << "found OpenPGP";
         protocol = GpgME::OpenPGP;
     }
 
     if (parser.isSet(QStringLiteral("cms"))) {
         qCDebug(KLEOPATRA_LOG) << "found CMS";
         if (protocol == GpgME::OpenPGP) {
             return i18n("Ambiguous protocol: --openpgp and --cms");
         }
         protocol = GpgME::CMS;
     }
 
     // Check for Parent Window id
     WId parentId = 0;
     if (parser.isSet(QStringLiteral("parent-windowid"))) {
 #ifdef Q_OS_WIN
         // WId is not a portable type as it is a pointer type on Windows.
         // casting it from an integer is ok though as the values are guaranteed to
         // be compatible in the documentation.
         parentId = reinterpret_cast<WId>(parser.value(QStringLiteral("parent-windowid")).toUInt());
 #else
         parentId = parser.value(QStringLiteral("parent-windowid")).toUInt();
 #endif
     }
 
     // Handle openpgp4fpr URI scheme
     QString needle;
     if (parser.isSet(QStringLiteral("search"))) {
         needle = parser.value(QStringLiteral("search"));
     } else if (parser.isSet(QStringLiteral("query"))) {
         needle = parser.value(QStringLiteral("query"));
     }
     if (needle.startsWith(QLatin1String("openpgp4fpr:"))) {
         needle.remove(0, 12);
     }
 
     // Check for --search command.
     if (parser.isSet(QStringLiteral("search"))) {
         // This is an extra command instead of a combination with the
         // similar query to avoid changing the older query commands behavior
         // and query's "show details if a certificate exist or search on a
         // keyserver" logic is hard to explain and use consistently.
         if (needle.isEmpty()) {
             return i18n("No search string specified for --search");
         }
         LookupCertificatesCommand *const cmd = new LookupCertificatesCommand(needle, nullptr);
         cmd->setParentWId(parentId);
         cmd->start();
         return QString();
     }
 
     // Check for --query command
     if (parser.isSet(QStringLiteral("query"))) {
         if (needle.isEmpty()) {
             return i18n("No fingerprint argument specified for --query");
         }
         auto cmd = Command::commandForQuery(needle);
         cmd->setParentWId(parentId);
         cmd->start();
         return QString();
     }
 
     // Check for --gen-key command
     if (parser.isSet(QStringLiteral("gen-key"))) {
         auto cmd = new NewCertificateCommand(nullptr);
         cmd->setParentWId(parentId);
         cmd->setProtocol(protocol);
         cmd->start();
         return QString();
     }
 
     // Check for --config command
     if (parser.isSet(QStringLiteral("config"))) {
         openConfigDialogWithForeignParent(parentId);
         return QString();
     }
 
     static const QMap<QString, Func> funcMap {
         { QStringLiteral("import-certificate"), &KleopatraApplication::importCertificatesFromFile },
         { QStringLiteral("encrypt"), &KleopatraApplication::encryptFiles },
         { QStringLiteral("sign"), &KleopatraApplication::signFiles },
         { QStringLiteral("encrypt-sign"), &KleopatraApplication::signEncryptFiles },
         { QStringLiteral("sign-encrypt"), &KleopatraApplication::signEncryptFiles },
         { QStringLiteral("decrypt"), &KleopatraApplication::decryptFiles },
         { QStringLiteral("verify"), &KleopatraApplication::verifyFiles },
         { QStringLiteral("decrypt-verify"), &KleopatraApplication::decryptVerifyFiles },
         { QStringLiteral("checksum"), &KleopatraApplication::checksumFiles },
     };
 
     QString found;
     Q_FOREACH (const QString &opt, funcMap.keys()) {
         if (parser.isSet(opt) && found.isEmpty()) {
             found = opt;
         } else if (parser.isSet(opt)) {
             return i18n("Ambiguous commands \"%1\" and \"%2\"", found, opt);
         }
     }
 
     QStringList errors;
     if (!found.isEmpty()) {
         if (files.empty()) {
             return i18n("No files specified for \"%1\" command", found);
         }
         qCDebug(KLEOPATRA_LOG) << "found" << found;
         (this->*funcMap.value(found))(files, protocol);
     } else {
         if (files.empty()) {
             if (!(d->firstNewInstance && isSessionRestored())) {
                 qCDebug(KLEOPATRA_LOG) << "openOrRaiseMainWindow";
                 openOrRaiseMainWindow();
             }
         } else {
             Q_FOREACH (const QString& fileName, files) {
                 QFileInfo fi(fileName);
                 if (!fi.isReadable()) {
                     errors << i18n("Cannot read \"%1\"", fileName);
                 }
             }
             Q_FOREACH (Command *cmd, Command::commandsForFiles(files)) {
                 if (parentId) {
                     cmd->setParentWId(parentId);
                 } else {
                     MainWindow *mw = mainWindow();
                     if (!mw) {
                         mw = new MainWindow;
                         mw->setAttribute(Qt::WA_DeleteOnClose);
                         setMainWindow(mw);
                         d->connectConfigureDialog();
                     }
                     cmd->setParentWidget(mw);
                 }
                 cmd->start();
             }
         }
     }
     d->firstNewInstance = false;
 
 #ifdef Q_OS_WIN
     // On Windows we might be started from the
     // explorer in any working directory. E.g.
     // a double click on a file. To avoid preventing
     // the folder from deletion we set the
     // working directory to the users homedir.
     QDir::setCurrent(QDir::homePath());
 #endif
 
     return errors.join(QLatin1Char('\n'));
 }
 
 #ifndef QT_NO_SYSTEMTRAYICON
 const SysTrayIcon *KleopatraApplication::sysTrayIcon() const
 {
     return d->sysTray;
 }
 
 SysTrayIcon *KleopatraApplication::sysTrayIcon()
 {
     return d->sysTray;
 }
 #endif
 
 const MainWindow *KleopatraApplication::mainWindow() const
 {
     return d->mainWindow;
 }
 
 MainWindow *KleopatraApplication::mainWindow()
 {
     return d->mainWindow;
 }
 
 void KleopatraApplication::setMainWindow(MainWindow *mainWindow)
 {
     if (mainWindow == d->mainWindow) {
         return;
     }
 
     d->disconnectConfigureDialog();
 
     d->mainWindow = mainWindow;
 #ifndef QT_NO_SYSTEMTRAYICON
     d->sysTray->setMainWindow(mainWindow);
 #endif
 
     d->connectConfigureDialog();
 }
 
 static void open_or_raise(QWidget *w)
 {
     if (w->isMinimized()) {
         KWindowSystem::unminimizeWindow(w->winId());
         w->raise();
     } else if (w->isVisible()) {
         w->raise();
     } else {
         w->show();
     }
 }
 
 void KleopatraApplication::toggleMainWindowVisibility()
 {
     if (mainWindow()) {
         mainWindow()->setVisible(!mainWindow()->isVisible());
     } else {
         openOrRaiseMainWindow();
     }
 }
 
 void KleopatraApplication::restoreMainWindow()
 {
     qCDebug(KLEOPATRA_LOG) << "restoring main window";
 
     // Sanity checks
     if (!isSessionRestored()) {
         qCDebug(KLEOPATRA_LOG) << "Not in session restore";
         return;
     }
 
     if (mainWindow()) {
         qCDebug(KLEOPATRA_LOG) << "Already have main window";
         return;
     }
 
     MainWindow *mw = new MainWindow;
     if (KMainWindow::canBeRestored(1)) {
         // restore to hidden state, Mainwindow::readProperties() will
         // restore saved visibility.
         mw->restore(1, false);
     }
 
     mw->setAttribute(Qt::WA_DeleteOnClose);
     setMainWindow(mw);
     d->connectConfigureDialog();
 
 }
 
 void KleopatraApplication::openOrRaiseMainWindow()
 {
     MainWindow *mw = mainWindow();
     if (!mw) {
         mw = new MainWindow;
         mw->setAttribute(Qt::WA_DeleteOnClose);
         setMainWindow(mw);
         d->connectConfigureDialog();
     }
     open_or_raise(mw);
     UpdateNotification::checkUpdate(mw);
 }
 
 void KleopatraApplication::openConfigDialogWithForeignParent(WId parentWId)
 {
     if (!d->configureDialog) {
         d->configureDialog = new ConfigureDialog;
         d->configureDialog->setAttribute(Qt::WA_DeleteOnClose);
         d->connectConfigureDialog();
     }
 
     // This is similar to what the commands do.
     if (parentWId) {
         if (QWidget *pw = QWidget::find(parentWId)) {
             d->configureDialog->setParent(pw, d->configureDialog->windowFlags());
         } else {
             d->configureDialog->setAttribute(Qt::WA_NativeWindow, true);
             KWindowSystem::setMainWindow(d->configureDialog->windowHandle(), parentWId);
         }
     }
 
     open_or_raise(d->configureDialog);
 
     // If we have a parent we want to raise over it.
     if (parentWId) {
         d->configureDialog->raise();
     }
 }
 
 void KleopatraApplication::openOrRaiseConfigDialog()
 {
     openConfigDialogWithForeignParent(0);
 }
 
 #ifndef QT_NO_SYSTEMTRAYICON
 void KleopatraApplication::startMonitoringSmartCard()
 {
     d->readerStatus.startMonitoring();
 }
 #endif // QT_NO_SYSTEMTRAYICON
 
 void KleopatraApplication::importCertificatesFromFile(const QStringList &files, GpgME::Protocol /*proto*/)
 {
     openOrRaiseMainWindow();
     if (!files.empty()) {
         mainWindow()->importCertificatesFromFile(files);
     }
 }
 
 void KleopatraApplication::encryptFiles(const QStringList &files, GpgME::Protocol proto)
 {
     SignEncryptFilesCommand *const cmd = new SignEncryptFilesCommand(files, nullptr);
     cmd->setEncryptionPolicy(Force);
     cmd->setSigningPolicy(Allow);
     if (proto != GpgME::UnknownProtocol) {
         cmd->setProtocol(proto);
     }
     cmd->start();
 }
 
 void KleopatraApplication::signFiles(const QStringList &files, GpgME::Protocol proto)
 {
     SignEncryptFilesCommand *const cmd = new SignEncryptFilesCommand(files, nullptr);
     cmd->setSigningPolicy(Force);
     cmd->setEncryptionPolicy(Deny);
     if (proto != GpgME::UnknownProtocol) {
         cmd->setProtocol(proto);
     }
     cmd->start();
 }
 
 void KleopatraApplication::signEncryptFiles(const QStringList &files, GpgME::Protocol proto)
 {
     SignEncryptFilesCommand *const cmd = new SignEncryptFilesCommand(files, nullptr);
     if (proto != GpgME::UnknownProtocol) {
         cmd->setProtocol(proto);
     }
     cmd->start();
 }
 
 void KleopatraApplication::decryptFiles(const QStringList &files, GpgME::Protocol /*proto*/)
 {
     DecryptVerifyFilesCommand *const cmd = new DecryptVerifyFilesCommand(files, nullptr);
     cmd->setOperation(Decrypt);
     cmd->start();
 }
 
 void KleopatraApplication::verifyFiles(const QStringList &files, GpgME::Protocol /*proto*/)
 {
     DecryptVerifyFilesCommand *const cmd = new DecryptVerifyFilesCommand(files, nullptr);
     cmd->setOperation(Verify);
     cmd->start();
 }
 
 void KleopatraApplication::decryptVerifyFiles(const QStringList &files, GpgME::Protocol /*proto*/)
 {
     DecryptVerifyFilesCommand *const cmd = new DecryptVerifyFilesCommand(files, nullptr);
     cmd->start();
 }
 
 void KleopatraApplication::checksumFiles(const QStringList &files, GpgME::Protocol /*proto*/)
 {
     QStringList verifyFiles, createFiles;
 
     for (const QString &file : files) {
         if (isChecksumFile(file)) {
             verifyFiles << file;
         } else {
             createFiles << file;
         }
     }
 
     if (!verifyFiles.isEmpty()) {
         auto *const cmd = new ChecksumVerifyFilesCommand(verifyFiles, nullptr);
         cmd->start();
     }
     if (!createFiles.isEmpty()) {
         auto *const cmd = new ChecksumCreateFilesCommand(createFiles, nullptr);
         cmd->start();
     }
 }
 
 void KleopatraApplication::setIgnoreNewInstance(bool ignore)
 {
     d->ignoreNewInstance = ignore;
 }
 
 bool KleopatraApplication::ignoreNewInstance() const
 {
     return d->ignoreNewInstance;
 }
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index ad15589f5..858164612 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -1,707 +1,697 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     mainwindow.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2007 Klarälvdalens Datakonsult AB
 
     Kleopatra 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.
 
     Kleopatra 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
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #include <config-kleopatra.h>
 
 #include "mainwindow.h"
 #include "aboutdata.h"
 
 #include "view/padwidget.h"
 #include "view/searchbar.h"
 #include "view/tabwidget.h"
 #include "view/keylistcontroller.h"
 #include "view/keycacheoverlay.h"
 #include "view/smartcardwidget.h"
 #include "view/welcomewidget.h"
 
 #include "commands/selftestcommand.h"
 #include "commands/importcrlcommand.h"
 #include "commands/importcertificatefromfilecommand.h"
 #include "commands/decryptverifyfilescommand.h"
 #include "commands/signencryptfilescommand.h"
 
 #include "utils/detail_p.h"
 #include "utils/gnupg-helper.h"
 #include "utils/action_data.h"
 #include "utils/filedialog.h"
 #include "utils/clipboardmenu.h"
 
 #include "dialogs/updatenotification.h"
 
 #include <KXMLGUIFactory>
 #include <QApplication>
+#include <QSize>
 #include <QLineEdit>
 #include <KActionMenu>
 #include <KActionCollection>
 #include <KLocalizedString>
 #include <KStandardAction>
 #include <QAction>
 #include <KAboutData>
 #include <KMessageBox>
 #include <KStandardGuiItem>
 #include <KShortcutsDialog>
 #include <KEditToolBar>
 #include "kleopatra_debug.h"
 #include <KConfigGroup>
 
 #include <QAbstractItemView>
 #include <QCloseEvent>
 #include <QMenu>
 #include <QTimer>
 #include <QProcess>
 #include <QVBoxLayout>
 #include <QMimeData>
 #include <QDesktopServices>
 #include <QDir>
 #include <QStackedWidget>
 #include <QStatusBar>
 #include <QLabel>
 
 #include <Libkleo/Formatting>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/KeyListSortFilterProxyModel>
 #include <Libkleo/CryptoConfigDialog>
 #include <Libkleo/Stl_Util>
 #include <Libkleo/Classify>
 #include <Libkleo/KeyCache>
 #include <QGpgME/CryptoConfig>
 #include <QGpgME/Protocol>
 
 #include <vector>
 #include <KSharedConfig>
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace GpgME;
 
 static KGuiItem KStandardGuiItem_quit()
 {
     static const QString app = KAboutData::applicationData().componentName();
     KGuiItem item = KStandardGuiItem::quit();
     item.setText(i18nc("Quit [ApplicationName]", "&Quit %1", app));
     return item;
 }
 
 static KGuiItem KStandardGuiItem_close()
 {
     KGuiItem item = KStandardGuiItem::close();
     item.setText(i18n("Only &Close Window"));
     return item;
 }
 
 static bool isQuitting = false;
 
 class MainWindow::Private
 {
     friend class ::MainWindow;
     MainWindow *const q;
 
 public:
     explicit Private(MainWindow *qq);
     ~Private();
 
     template <typename T>
     void createAndStart()
     {
         (new T(this->currentView(), &this->controller))->start();
     }
     template <typename T>
     void createAndStart(QAbstractItemView *view)
     {
         (new T(view, &this->controller))->start();
     }
     template <typename T>
     void createAndStart(const QStringList &a)
     {
         (new T(a, this->currentView(), &this->controller))->start();
     }
     template <typename T>
     void createAndStart(const QStringList &a, QAbstractItemView *view)
     {
         (new T(a, view, &this->controller))->start();
     }
 
     void closeAndQuit()
     {
         const QString app = KAboutData::applicationData().componentName();
         const int rc = KMessageBox::questionYesNoCancel(q,
                        i18n("%1 may be used by other applications as a service.\n"
                             "You may instead want to close this window without exiting %1.", app),
                        i18n("Really Quit?"), KStandardGuiItem_close(), KStandardGuiItem_quit(), KStandardGuiItem::cancel(),
                        QLatin1String("really-quit-") + app.toLower());
         if (rc == KMessageBox::Cancel) {
             return;
         }
         isQuitting = true;
         if (!q->close()) {
             return;
         }
         // WARNING: 'this' might be deleted at this point!
         if (rc == KMessageBox::No) {
             qApp->quit();
         }
     }
     void configureToolbars()
     {
         KEditToolBar dlg(q->factory());
         dlg.exec();
     }
     void editKeybindings()
     {
         KShortcutsDialog::configure(q->actionCollection(), KShortcutsEditor::LetterShortcutsAllowed);
         updateSearchBarClickMessage();
     }
 
     void updateSearchBarClickMessage()
     {
         const QString shortcutStr = focusToClickSearchAction->shortcut().toString();
         ui.searchBar->updateClickMessage(shortcutStr);
     }
 
     void updateStatusBar()
     {
         const auto complianceMode = Formatting::complianceMode();
         if (!complianceMode.isEmpty()) {
             auto statusBar = new QStatusBar;
             q->setStatusBar(statusBar);
             auto statusLbl = new QLabel(i18nc("Compliance means that GnuPG is running in a more restricted mode e.g. to handle restricted documents.",
                                         // The germans want some extra sausage
                                         "Compliance: %1", complianceMode == QLatin1String("de-vs") ? QStringLiteral ("VS-NfD") : complianceMode));
             statusBar->insertPermanentWidget(0, statusLbl);
 
         } else {
             q->setStatusBar(nullptr);
         }
     }
 
     void selfTest()
     {
         createAndStart<SelfTestCommand>();
     }
     void configureBackend();
 
     void showHandbook();
 
     void gnupgLogViewer()
     {
         if (!QProcess::startDetached(QStringLiteral("kwatchgnupg"), QStringList()))
             KMessageBox::error(q, i18n("Could not start the GnuPG Log Viewer (kwatchgnupg). "
                                        "Please check your installation."),
                                i18n("Error Starting KWatchGnuPG"));
     }
 
     void forceUpdateCheck()
     {
         UpdateNotification::forceUpdateCheck(q);
     }
 
     void openCompendium()
     {
         QDir datadir(QCoreApplication::applicationDirPath() + QStringLiteral("/../share/gpg4win"));
         const auto path = datadir.filePath(i18nc("The Gpg4win compendium is only available"
                                                  "at this point (24.7.2017) in german and english."
                                                  "Please check with Gpg4win before translating this filename.",
                                                  "gpg4win-compendium-en.pdf"));
         qCDebug(KLEOPATRA_LOG) << "Opening Compendium at:" << path;
         // The compendium is always installed. So this should work. Otherwise
         // we have debug output.
         QDesktopServices::openUrl(QUrl::fromLocalFile(path));
     }
 
     void slotConfigCommitted();
     void slotContextMenuRequested(QAbstractItemView *, const QPoint &p)
     {
         if (QMenu *const menu = qobject_cast<QMenu *>(q->factory()->container(QStringLiteral("listview_popup"), q))) {
             menu->exec(p);
         } else {
             qCDebug(KLEOPATRA_LOG) << "no \"listview_popup\" <Menu> in kleopatra's ui.rc file";
         }
     }
 
     void slotFocusQuickSearch()
     {
         ui.searchBar->lineEdit()->setFocus();
     }
 
     void toggleSmartcardView()
     {
         const auto coll = q->actionCollection();
         if (coll) {
             auto act = coll->action(QStringLiteral("pad_view"));
             if (act) {
                 act->setChecked(false);
             }
         }
         if (ui.stackWidget->currentWidget() == ui.scWidget) {
             ui.stackWidget->setCurrentWidget(ui.searchTab);
             checkWelcomePage();
             return;
         }
         ui.stackWidget->setCurrentWidget(ui.scWidget);
     }
 
     void togglePadView()
     {
         const auto coll = q->actionCollection();
         if (coll) {
             auto act = coll->action(QStringLiteral("manage_smartcard"));
             if (act) {
                 act->setChecked(false);
             }
         }
         if (ui.stackWidget->currentWidget() == ui.padWidget) {
             ui.stackWidget->setCurrentWidget(ui.searchTab);
             checkWelcomePage();
             return;
         }
         if (!ui.padWidget) {
             ui.padWidget = new PadWidget;
             ui.stackWidget->addWidget(ui.padWidget);
         }
         ui.stackWidget->setCurrentWidget(ui.padWidget);
         ui.stackWidget->resize(ui.padWidget->sizeHint());
     }
 
 private:
     void setupActions();
 
     QAbstractItemView *currentView() const
     {
         return ui.tabWidget.currentView();
     }
 
     void checkWelcomePage()
     {
         const auto curWidget = ui.stackWidget->currentWidget();
         if (curWidget == ui.scWidget || curWidget == ui.padWidget) {
            return;
         }
         if (KeyCache::instance()->keys().empty()) {
             ui.stackWidget->setCurrentWidget(ui.welcomeWidget);
         } else {
             ui.stackWidget->setCurrentWidget(ui.searchTab);
         }
     }
 
 private:
     Kleo::KeyListController controller;
     bool firstShow : 1;
     struct UI {
         QWidget *searchTab;
         TabWidget tabWidget;
         SearchBar *searchBar;
         PadWidget *padWidget;
         SmartCardWidget *scWidget;
         WelcomeWidget *welcomeWidget;
         QStackedWidget *stackWidget;
         explicit UI(MainWindow *q);
     } ui;
     QAction *focusToClickSearchAction;
     ClipboardMenu *clipboadMenu;
 };
 
 MainWindow::Private::UI::UI(MainWindow *q)
     : tabWidget(q), padWidget(nullptr)
 {
     KDAB_SET_OBJECT_NAME(tabWidget);
 
     searchTab = new QWidget;
     QVBoxLayout *vbox = new QVBoxLayout(searchTab);
     vbox->setSpacing(0);
     searchBar = new SearchBar;
     vbox->addWidget(searchBar);
     tabWidget.connectSearchBar(searchBar);
     vbox->addWidget(&tabWidget);
 
     QWidget *mainWidget = new QWidget;
     auto mainLayout = new QVBoxLayout(mainWidget);
     stackWidget = new QStackedWidget;
 
     mainLayout->addWidget(stackWidget);
 
     stackWidget->addWidget(searchTab);
 
     new KeyCacheOverlay(mainWidget, q);
 
     scWidget = new SmartCardWidget();
     stackWidget->addWidget(scWidget);
 
     welcomeWidget = new WelcomeWidget();
     stackWidget->addWidget(welcomeWidget);
 
     q->setCentralWidget(mainWidget);
 }
 
 MainWindow::Private::Private(MainWindow *qq)
     : q(qq),
       controller(q),
       firstShow(true),
       ui(q)
 {
     KDAB_SET_OBJECT_NAME(controller);
 
     AbstractKeyListModel *flatModel = AbstractKeyListModel::createFlatKeyListModel(q);
     AbstractKeyListModel *hierarchicalModel = AbstractKeyListModel::createHierarchicalKeyListModel(q);
 
     KDAB_SET_OBJECT_NAME(flatModel);
     KDAB_SET_OBJECT_NAME(hierarchicalModel);
 
     controller.setFlatModel(flatModel);
     controller.setHierarchicalModel(hierarchicalModel);
     controller.setTabWidget(&ui.tabWidget);
 
     ui.tabWidget.setFlatModel(flatModel);
     ui.tabWidget.setHierarchicalModel(hierarchicalModel);
 
     ui.stackWidget->setCurrentWidget(ui.searchTab);
 
     setupActions();
 
     connect(&controller, SIGNAL(contextMenuRequested(QAbstractItemView*,QPoint)), q, SLOT(slotContextMenuRequested(QAbstractItemView*,QPoint)));
     connect(ui.scWidget, &SmartCardWidget::backRequested, q, [this]() {
             auto action = q->actionCollection()->action(QStringLiteral("manage_smartcard"));
             Q_ASSERT(action);
             action->setChecked(false);
         });
     connect(KeyCache::instance().get(), &KeyCache::keyListingDone, q, [this] () {checkWelcomePage();});
 
     q->createGUI(QStringLiteral("kleopatra.rc"));
 
     q->setAcceptDrops(true);
 
+    // set default window size
+    q->resize(QSize(1024, 500));
     q->setAutoSaveSettings();
+
     updateSearchBarClickMessage();
     updateStatusBar();
 }
 
 MainWindow::Private::~Private() {}
 
 MainWindow::MainWindow(QWidget *parent, Qt::WindowFlags flags)
     : KXmlGuiWindow(parent, flags), d(new Private(this))
-{
-    resize(1024, 500);
-}
+{}
 
 MainWindow::~MainWindow() {}
 
 void MainWindow::Private::setupActions()
 {
 
     KActionCollection *const coll = q->actionCollection();
 
     const action_data action_data[] = {
         // most have been MOVED TO keylistcontroller.cpp
         // Tools menu
 #ifndef Q_OS_WIN
         {
             "tools_start_kwatchgnupg", i18n("GnuPG Log Viewer"), QString(),
             "kwatchgnupg", q, SLOT(gnupgLogViewer()), QString(), false, true
         },
 #endif
 #ifdef Q_OS_WIN
         {
             "help_check_updates", i18n("Check for updates"), QString(),
             "gpg4win-compact", q, SLOT(forceUpdateCheck()), QString(), false, true
         },
         {
             "help_show_compendium", i18n("Gpg4win Compendium"), QString(),
             "gpg4win-compact", q, SLOT(openCompendium()), QString(), false, true
         },
 #endif
         {
             "pad_view", i18nc("Title for a generic data input / output area supporting text actions.", "Notepad"),
             i18n("Switch to Pad view."), "edittext", q, SLOT(togglePadView()), QString(), true, true
         },
         // most have been MOVED TO keylistcontroller.cpp
 #if 0
         {
             "configure_backend", i18n("Configure GnuPG Backend..."), QString(),
             0, q, SLOT(configureBackend()), QString(), false, true
         },
 #endif
         // Settings menu
         {
             "settings_self_test", i18n("Perform Self-Test"), QString(),
             nullptr, q, SLOT(selfTest()), QString(), false, true
         },
         {
             "manage_smartcard", i18n("Manage Smartcards"),
             i18n("Edit or initialize a crypto hardware token."), "secure-card", q, SLOT(toggleSmartcardView()), QString(), true, true
         }
 
         // most have been MOVED TO keylistcontroller.cpp
     };
 
     make_actions_from_data(action_data, /*sizeof action_data / sizeof *action_data,*/ coll);
 
     if (QAction *action = coll->action(QStringLiteral("configure_backend"))) {
         action->setMenuRole(QAction::NoRole);    //prevent Qt OS X heuristics for config* actions
     }
 
     KStandardAction::close(q, SLOT(close()), coll);
     KStandardAction::quit(q, SLOT(closeAndQuit()), coll);
     KStandardAction::configureToolbars(q, SLOT(configureToolbars()), coll);
     KStandardAction::keyBindings(q, SLOT(editKeybindings()), coll);
     KStandardAction::preferences(qApp, SLOT(openOrRaiseConfigDialog()), coll);
 
     focusToClickSearchAction = new QAction(i18n("Set Focus to Quick Search"), q);
     coll->addAction(QStringLiteral("focus_to_quickseach"), focusToClickSearchAction);
     coll->setDefaultShortcut(focusToClickSearchAction, QKeySequence(Qt::ALT + Qt::Key_Q));
     connect(focusToClickSearchAction, SIGNAL(triggered(bool)), q, SLOT(slotFocusQuickSearch()));
     clipboadMenu = new ClipboardMenu(q);
     clipboadMenu->setMainWindow(q);
     clipboadMenu->clipboardMenu()->setIcon(QIcon::fromTheme(QStringLiteral("edit-paste")));
     clipboadMenu->clipboardMenu()->setDelayed(false);
     coll->addAction(QStringLiteral("clipboard_menu"), clipboadMenu->clipboardMenu());
 
     q->setStandardToolBarMenuEnabled(true);
 
     controller.createActions(coll);
 
     ui.tabWidget.createActions(coll);
 }
 
 void MainWindow::Private::configureBackend()
 {
     QGpgME::CryptoConfig *const config = QGpgME::cryptoConfig();
     if (!config) {
         KMessageBox::error(q, i18n("Could not configure the cryptography backend (gpgconf tool not found)"), i18n("Configuration Error"));
         return;
     }
 
     Kleo::CryptoConfigDialog dlg(config);
 
     const int result = dlg.exec();
 
     // Forget all data parsed from gpgconf, so that we show updated information
     // when reopening the configuration dialog.
     config->clear();
 
     if (result == QDialog::Accepted) {
 #if 0
         // Tell other apps (e.g. kmail) that the gpgconf data might have changed
         QDBusMessage message =
             QDBusMessage::createSignal(QString(), "org.kde.kleo.CryptoConfig", "changed");
         QDBusConnection::sessionBus().send(message);
 #endif
     }
 }
 
 void MainWindow::Private::slotConfigCommitted()
 {
     controller.updateConfig();
     updateStatusBar();
 }
 
 void MainWindow::closeEvent(QCloseEvent *e)
 {
     // KMainWindow::closeEvent() insists on quitting the application,
     // so do not let it touch the event...
     qCDebug(KLEOPATRA_LOG);
     if (d->controller.hasRunningCommands()) {
         if (d->controller.shutdownWarningRequired()) {
             const int ret = KMessageBox::warningContinueCancel(this, i18n("There are still some background operations ongoing. "
                             "These will be terminated when closing the window. "
                             "Proceed?"),
                             i18n("Ongoing Background Tasks"));
             if (ret != KMessageBox::Continue) {
                 e->ignore();
                 return;
             }
         }
         d->controller.cancelCommands();
         if (d->controller.hasRunningCommands()) {
             // wait for them to be finished:
             setEnabled(false);
             QEventLoop ev;
             QTimer::singleShot(100, &ev, &QEventLoop::quit);
             connect(&d->controller, &KeyListController::commandsExecuting, &ev, &QEventLoop::quit);
             ev.exec();
             if (d->controller.hasRunningCommands())
                 qCWarning(KLEOPATRA_LOG)
                         << "controller still has commands running, this may crash now...";
             setEnabled(true);
         }
     }
     if (isQuitting || qApp->isSavingSession()) {
         d->ui.tabWidget.saveViews(KSharedConfig::openConfig().data());
         KConfigGroup grp(KConfigGroup(KSharedConfig::openConfig(), autoSaveGroup()));
         saveMainWindowSettings(grp);
         e->accept();
     } else {
         e->ignore();
         hide();
     }
 }
 
 void MainWindow::showEvent(QShowEvent *e)
 {
     KXmlGuiWindow::showEvent(e);
     if (d->firstShow) {
         d->ui.tabWidget.loadViews(KSharedConfig::openConfig().data());
         d->firstShow = false;
     }
 
     if (!savedGeometry.isEmpty()) {
         restoreGeometry(savedGeometry);
     }
 
 }
 
 void MainWindow::hideEvent(QHideEvent *e)
 {
     savedGeometry = saveGeometry();
     KXmlGuiWindow::hideEvent(e);
 }
 
 void MainWindow::importCertificatesFromFile(const QStringList &files)
 {
     if (!files.empty()) {
         d->createAndStart<ImportCertificateFromFileCommand>(files);
     }
 }
 
 static QStringList extract_local_files(const QMimeData *data)
 {
     const QList<QUrl> urls = data->urls();
     // begin workaround KDE/Qt misinterpretation of text/uri-list
     QList<QUrl>::const_iterator end = urls.end();
     if (urls.size() > 1 && !urls.back().isValid()) {
         --end;
     }
     // end workaround
     QStringList result;
     std::transform(urls.begin(), end,
                    std::back_inserter(result),
                    std::mem_fn(&QUrl::toLocalFile));
     result.erase(std::remove_if(result.begin(), result.end(),
                                 std::mem_fn(&QString::isEmpty)), result.end());
     return result;
 }
 
 static bool can_decode_local_files(const QMimeData *data)
 {
     if (!data) {
         return false;
     }
     return !extract_local_files(data).empty();
 }
 
 void MainWindow::dragEnterEvent(QDragEnterEvent *e)
 {
     qCDebug(KLEOPATRA_LOG);
 
     if (can_decode_local_files(e->mimeData())) {
         e->acceptProposedAction();
     }
 }
 
 void MainWindow::dropEvent(QDropEvent *e)
 {
     qCDebug(KLEOPATRA_LOG);
 
     if (!can_decode_local_files(e->mimeData())) {
         return;
     }
 
     e->setDropAction(Qt::CopyAction);
 
     const QStringList files = extract_local_files(e->mimeData());
 
     const unsigned int classification = classify(files);
 
     QMenu menu;
 
     QAction *const signEncrypt = menu.addAction(i18n("Sign/Encrypt..."));
     QAction *const decryptVerify = mayBeAnyMessageType(classification) ? menu.addAction(i18n("Decrypt/Verify...")) : nullptr;
     if (signEncrypt || decryptVerify) {
         menu.addSeparator();
     }
 
     QAction *const importCerts = mayBeAnyCertStoreType(classification) ? menu.addAction(i18n("Import Certificates")) : nullptr;
     QAction *const importCRLs  = mayBeCertificateRevocationList(classification) ? menu.addAction(i18n("Import CRLs")) : nullptr;
     if (importCerts || importCRLs) {
         menu.addSeparator();
     }
 
     if (!signEncrypt && !decryptVerify && !importCerts && !importCRLs) {
         return;
     }
 
     menu.addAction(i18n("Cancel"));
 
     const QAction *const chosen = menu.exec(mapToGlobal(e->pos()));
 
     if (!chosen) {
         return;
     }
 
     if (chosen == signEncrypt) {
         d->createAndStart<SignEncryptFilesCommand>(files);
     } else if (chosen == decryptVerify) {
         d->createAndStart<DecryptVerifyFilesCommand>(files);
     } else if (chosen == importCerts) {
         d->createAndStart<ImportCertificateFromFileCommand>(files);
     } else if (chosen == importCRLs) {
         d->createAndStart<ImportCrlCommand>(files);
     }
 
     e->accept();
 }
 
 void MainWindow::readProperties(const KConfigGroup &cg)
 {
     qCDebug(KLEOPATRA_LOG);
     KXmlGuiWindow::readProperties(cg);
-    savedGeometry = cg.readEntry("savedGeometry", QByteArray());
-    if (!savedGeometry.isEmpty()) {
-        restoreGeometry(savedGeometry);
-    }
-
-    if (! cg.readEntry<bool>("hidden", false)) {
-        show();
-    }
+    setHidden(cg.readEntry("hidden", false));
 }
 
 void MainWindow::saveProperties(KConfigGroup &cg)
 {
     qCDebug(KLEOPATRA_LOG);
     KXmlGuiWindow::saveProperties(cg);
     cg.writeEntry("hidden", isHidden());
-    if (isHidden()) {
-        cg.writeEntry("savedGeometry", savedGeometry);
-    } else {
-        cg.writeEntry("savedGeometry", saveGeometry());
-    }
 }
 
 #include "moc_mainwindow.cpp"