diff --git a/src/kmkernel.cpp b/src/kmkernel.cpp
index aafb9ee5d..dcf44406f 100644
--- a/src/kmkernel.cpp
+++ b/src/kmkernel.cpp
@@ -1,1917 +1,1930 @@
 /*   */
 
 #include "kmkernel.h"
 
 #include "settings/kmailsettings.h"
 #include "libkdepim/broadcaststatus.h"
 #include "job/opencomposerjob.h"
 #include "job/newmessagejob.h"
 #include "job/opencomposerhiddenjob.h"
 #include "job/fillcomposerjob.h"
 #include <AkonadiSearch/PIM/indexeditems.h>
 #include <LibkdepimAkonadi/ProgressManagerAkonadi>
 using KPIM::BroadcastStatus;
 #include "kmstartup.h"
 #include "kmmainwin.h"
 #include "editor/composer.h"
 #include "kmreadermainwin.h"
 #include "undostack.h"
 #include "kmmainwidget.h"
 
 #include "search/checkindexingmanager.h"
 #include "libkdepim/recentaddresses.h"
 using KPIM::RecentAddresses;
 #include "configuredialog/configuredialog.h"
 #include "kmcommands.h"
 #include "unityservicemanager.h"
 #include <MessageCore/StringUtil>
 #include "mailcommon/mailutil.h"
 #include "pop3settings.h"
 #include "MailCommon/FolderTreeView"
 #include "MailCommon/KMFilterDialog"
 #include "mailcommonsettings_base.h"
 #include "mailfilteragentinterface.h"
 #include "PimCommon/PimUtil"
 #include "folderarchive/folderarchivemanager.h"
 #include "sieveimapinterface/kmailsieveimapinstanceinterface.h"
 // kdepim includes
 #include "kmail-version.h"
 
 // kdepimlibs includes
 #include <KIdentityManagement/kidentitymanagement/identity.h>
 #include <KIdentityManagement/kidentitymanagement/identitymanager.h>
 #include <mailtransport/transport.h>
 #include <mailtransport/transportmanager.h>
 #include <mailtransportakonadi/dispatcherinterface.h>
 #include <AkonadiCore/servermanager.h>
 
 #include <KSieveUi/SieveImapInstanceInterfaceManager>
 #include "mailserviceimpl.h"
 using KMail::MailServiceImpl;
 #include "mailcommon/jobscheduler.h"
 
 #include <MessageCore/MessageCoreSettings>
 #include "messagelistsettings.h"
 #include "gravatarsettings.h"
 #include "messagelist/messagelistutil.h"
 #include "messageviewer/messageviewersettings.h"
 #include "MessageComposer/AkonadiSender"
 #include "messagecomposer/messagecomposersettings.h"
 #include "MessageComposer/MessageHelper"
 #include "MessageComposer/MessageComposerSettings"
 #include "PimCommon/PimCommonSettings"
 #include "PimCommon/AutoCorrection"
 #include <PimCommon/NetworkManager>
 
 #include "globalsettings_templateparser.h"
 #include "TemplateParser/TemplatesUtil"
 
 #include "mailcommon/foldersettings.h"
 #include "editor/codec/codecmanager.h"
 
 #include <kmessagebox.h>
 #include <knotification.h>
 #include <libkdepim/progressmanager.h>
 
 #include <kconfig.h>
 #include <kpassivepopup.h>
 #include <kconfiggroup.h>
 #include "kmail_debug.h"
 #include <kio/jobuidelegate.h>
 #include <kprocess.h>
 #include <KCrash>
 
 #include <kmime/kmime_message.h>
 #include <kmime/kmime_headers.h>
 #include <AkonadiCore/Collection>
 #include <AkonadiCore/CollectionFetchJob>
 #include <AkonadiCore/ChangeRecorder>
 #include <AkonadiCore/ItemFetchScope>
 #include <AkonadiCore/AgentManager>
 #include <AkonadiCore/ItemFetchJob>
 #include <AkonadiCore/AttributeFactory>
 #include <AkonadiCore/Session>
 #include <AkonadiCore/EntityTreeModel>
 #include <AkonadiCore/entitymimetypefiltermodel.h>
 #include <AkonadiCore/CollectionStatisticsJob>
 
 #include <QNetworkConfigurationManager>
 #include <QDir>
 #include <QWidget>
 #include <QFileInfo>
 #include <QtDBus/QtDBus>
 
 #include <MailCommon/ResourceReadConfigFile>
 
 #include <kstartupinfo.h>
 #include <kmailadaptor.h>
 #include <KLocalizedString>
 #include <QStandardPaths>
 #include "kmailinterface.h"
 #include "mailcommon/foldercollectionmonitor.h"
 #include "imapresourcesettings.h"
 #include "util.h"
 #include "MailCommon/MailKernel"
 
 #include "searchdialog/searchdescriptionattribute.h"
 #include "kmail_options.h"
 
 using namespace MailCommon;
 
 static KMKernel *mySelf = nullptr;
 static bool s_askingToGoOnline = false;
 /********************************************************************/
 /*                     Constructor and destructor                   */
 /********************************************************************/
 KMKernel::KMKernel(QObject *parent)
     : QObject(parent)
 {
     //Initialize kmail sieveimap interface
     KSieveUi::SieveImapInstanceInterfaceManager::self()->setSieveImapInstanceInterface(new KMailSieveImapInstanceInterface);
     mDebug = !qEnvironmentVariableIsEmpty("KDEPIM_DEBUGGING");
 
     mSystemNetworkStatus = PimCommon::NetworkManager::self()->networkConfigureManager()->isOnline();
 
     Akonadi::AttributeFactory::registerAttribute<Akonadi::SearchDescriptionAttribute>();
     QDBusConnection::sessionBus().registerService(QStringLiteral("org.kde.kmail"));
     qCDebug(KMAIL_LOG) << "Starting up...";
 
     mySelf = this;
     the_firstInstance = true;
 
     the_undoStack = nullptr;
     the_msgSender = nullptr;
     mFilterEditDialog = nullptr;
     // make sure that we check for config updates before doing anything else
     KMKernel::config();
     // this shares the kmailrc parsing too (via KSharedConfig), and reads values from it
     // so better do it here, than in some code where changing the group of config()
     // would be unexpected
     KMailSettings::self();
 
     mJobScheduler = new JobScheduler(this);
 
     mAutoCorrection = new PimCommon::AutoCorrection();
     KMime::setUseOutlookAttachmentEncoding(MessageComposer::MessageComposerSettings::self()->outlookCompatibleAttachments());
 
     // cberzan: this crap moved to CodecManager ======================
     mNetCodec = QTextCodec::codecForLocale();
 
     // In the case of Japan. Japanese locale name is "eucjp" but
     // The Japanese mail systems normally used "iso-2022-jp" of locale name.
     // We want to change locale name from eucjp to iso-2022-jp at KMail only.
 
     // (Introduction to i18n, 6.6 Limit of Locale technology):
     // EUC-JP is the de-facto standard for UNIX systems, ISO 2022-JP
     // is the standard for Internet, and Shift-JIS is the encoding
     // for Windows and Macintosh.
     const QByteArray netCodecLower = mNetCodec->name().toLower();
     if (netCodecLower == "eucjp"
 #if defined Q_OS_WIN || defined Q_OS_MACX
         || netCodecLower == "shift-jis"     // OK?
 #endif
         ) {
         mNetCodec = QTextCodec::codecForName("jis7");
     }
     // until here ================================================
 
     Akonadi::Session *session = new Akonadi::Session("KMail Kernel ETM", this);
 
     mFolderCollectionMonitor = new FolderCollectionMonitor(session, this);
 
     connect(mFolderCollectionMonitor->monitor(), &Akonadi::Monitor::collectionRemoved, this, &KMKernel::slotCollectionRemoved);
 
     mEntityTreeModel = new Akonadi::EntityTreeModel(folderCollectionMonitor(), this);
     mEntityTreeModel->setListFilter(Akonadi::CollectionFetchScope::Enabled);
     mEntityTreeModel->setItemPopulationStrategy(Akonadi::EntityTreeModel::LazyPopulation);
 
     mCollectionModel = new Akonadi::EntityMimeTypeFilterModel(this);
     mCollectionModel->setSourceModel(mEntityTreeModel);
     mCollectionModel->addMimeTypeInclusionFilter(Akonadi::Collection::mimeType());
     mCollectionModel->setHeaderGroup(Akonadi::EntityTreeModel::CollectionTreeHeaders);
     mCollectionModel->setDynamicSortFilter(true);
     mCollectionModel->setSortCaseSensitivity(Qt::CaseInsensitive);
 
     connect(folderCollectionMonitor(), QOverload<const Akonadi::Collection &, const QSet<QByteArray> &>::of(&Akonadi::ChangeRecorder::collectionChanged), this,
             &KMKernel::slotCollectionChanged);
 
     connect(MailTransport::TransportManager::self(), &MailTransport::TransportManager::transportRemoved, this, &KMKernel::transportRemoved);
     connect(MailTransport::TransportManager::self(), &MailTransport::TransportManager::transportRenamed, this, &KMKernel::transportRenamed);
 
     QDBusConnection::sessionBus().connect(QString(), QStringLiteral("/MailDispatcherAgent"), QStringLiteral("org.freedesktop.Akonadi.MailDispatcherAgent"), QStringLiteral(
                                               "itemDispatchStarted"), this, SLOT(itemDispatchStarted()));
     connect(Akonadi::AgentManager::self(), &Akonadi::AgentManager::instanceStatusChanged, this, &KMKernel::instanceStatusChanged);
 
     connect(Akonadi::AgentManager::self(), &Akonadi::AgentManager::instanceError, this, &KMKernel::slotInstanceError);
 
     connect(Akonadi::AgentManager::self(), &Akonadi::AgentManager::instanceWarning, this, &KMKernel::slotInstanceWarning);
 
     connect(Akonadi::AgentManager::self(), &Akonadi::AgentManager::instanceRemoved, this, &KMKernel::slotInstanceRemoved);
 
+    connect(Akonadi::AgentManager::self(), &Akonadi::AgentManager::instanceAdded, this, &KMKernel::slotInstanceAdded);
+
     connect(PimCommon::NetworkManager::self()->networkConfigureManager(), &QNetworkConfigurationManager::onlineStateChanged,
             this, &KMKernel::slotSystemNetworkStatusChanged);
 
     connect(KPIM::ProgressManager::instance(), &KPIM::ProgressManager::progressItemCompleted,
             this, &KMKernel::slotProgressItemCompletedOrCanceled);
     connect(KPIM::ProgressManager::instance(), &KPIM::ProgressManager::progressItemCanceled,
             this, &KMKernel::slotProgressItemCompletedOrCanceled);
     connect(identityManager(), &KIdentityManagement::IdentityManager::deleted, this, &KMKernel::slotDeleteIdentity);
     CommonKernel->registerKernelIf(this);
     CommonKernel->registerSettingsIf(this);
     CommonKernel->registerFilterIf(this);
     mFolderArchiveManager = new FolderArchiveManager(this);
     mIndexedItems = new Akonadi::Search::PIM::IndexedItems(this);
     mCheckIndexingManager = new CheckIndexingManager(mIndexedItems, this);
     mUnityServiceManager = new KMail::UnityServiceManager(this);
 }
 
 KMKernel::~KMKernel()
 {
     delete mMailService;
     mMailService = nullptr;
 
     stopAgentInstance();
     slotSyncConfig();
 
     delete mAutoCorrection;
     delete mMailCommonSettings;
     mySelf = nullptr;
 }
 
 Akonadi::ChangeRecorder *KMKernel::folderCollectionMonitor() const
 {
     return mFolderCollectionMonitor->monitor();
 }
 
 Akonadi::EntityTreeModel *KMKernel::entityTreeModel() const
 {
     return mEntityTreeModel;
 }
 
 Akonadi::EntityMimeTypeFilterModel *KMKernel::collectionModel() const
 {
     return mCollectionModel;
 }
 
 void KMKernel::setupDBus()
 {
     (void)new KmailAdaptor(this);
     QDBusConnection::sessionBus().registerObject(QStringLiteral("/KMail"), this);
     mMailService = new MailServiceImpl();
 }
 
 static QUrl makeAbsoluteUrl(const QString &str, const QString &cwd)
 {
     return QUrl::fromUserInput(str, cwd, QUrl::AssumeLocalFile);
 }
 
 bool KMKernel::handleCommandLine(bool noArgsOpensReader, const QStringList &args, const QString &workingDir)
 {
     QString to, cc, bcc, subj, body, inReplyTo, replyTo;
     QStringList customHeaders;
     QUrl messageFile;
     QList<QUrl> attachURLs;
     QString identity;
     bool mailto = false;
     bool checkMail = false;
     bool viewOnly = false;
     bool calledWithSession = false; // for ignoring '-session foo'
 
     // process args:
     QCommandLineParser parser;
     kmail_options(&parser);
     QStringList newargs;
     bool addAttachmentAttribute = false;
     for (const QString &argument : qAsConst(args)) {
         if (argument == QLatin1String("--attach")) {
             addAttachmentAttribute = true;
         } else {
             if (argument.startsWith(QLatin1String("--"))) {
                 addAttachmentAttribute = false;
             }
             if (argument.contains(QLatin1Char('@')) || argument.startsWith(QLatin1String("mailto:"))) { //address mustn't be trade as a attachment
                 addAttachmentAttribute = false;
             }
             if (addAttachmentAttribute) {
                 newargs.append(QStringLiteral("--attach"));
                 newargs.append(argument);
             } else {
                 newargs.append(argument);
             }
         }
     }
 
     parser.process(newargs);
     if (parser.isSet(QStringLiteral("subject"))) {
         subj = parser.value(QStringLiteral("subject"));
         // if kmail is called with 'kmail -session abc' then this doesn't mean
         // that the user wants to send a message with subject "ession" but
         // (most likely) that the user clicked on KMail's system tray applet
         // which results in KMKernel::raise() calling "kmail kmail newInstance"
         // via D-Bus which apparently executes the application with the original
         // command line arguments and those include "-session ..." if
         // kmail/kontact was restored by session management
         if (subj == QLatin1String("ession")) {
             subj.clear();
             calledWithSession = true;
         } else {
             mailto = true;
         }
     }
 
     if (parser.isSet(QStringLiteral("cc"))) {
         mailto = true;
         cc = parser.value(QStringLiteral("cc"));
     }
 
     if (parser.isSet(QStringLiteral("bcc"))) {
         mailto = true;
         bcc = parser.value(QStringLiteral("bcc"));
     }
 
     if (parser.isSet(QStringLiteral("replyTo"))) {
         mailto = true;
         replyTo = parser.value(QStringLiteral("replyTo"));
     }
 
     if (parser.isSet(QStringLiteral("msg"))) {
         mailto = true;
         const QString file = parser.value(QStringLiteral("msg"));
         messageFile = makeAbsoluteUrl(file, workingDir);
     }
 
     if (parser.isSet(QStringLiteral("body"))) {
         mailto = true;
         body = parser.value(QStringLiteral("body"));
     }
 
     const QStringList attachList = parser.values(QStringLiteral("attach"));
     if (!attachList.isEmpty()) {
         mailto = true;
         QStringList::ConstIterator end = attachList.constEnd();
         for (QStringList::ConstIterator it = attachList.constBegin();
              it != end; ++it) {
             if (!(*it).isEmpty()) {
                 if ((*it) != QLatin1String("--")) {
                     attachURLs.append(makeAbsoluteUrl(*it, workingDir));
                 }
             }
         }
     }
 
     customHeaders = parser.values(QStringLiteral("header"));
 
     if (parser.isSet(QStringLiteral("composer"))) {
         mailto = true;
     }
 
     if (parser.isSet(QStringLiteral("check"))) {
         checkMail = true;
     }
 
     if (parser.isSet(QStringLiteral("identity"))) {
         identity = parser.value(QStringLiteral("identity"));
     }
 
     if (parser.isSet(QStringLiteral("view"))) {
         viewOnly = true;
         const QString filename
             = parser.value(QStringLiteral("view"));
         messageFile = QUrl::fromUserInput(filename, workingDir);
     }
 
     if (!calledWithSession) {
         // only read additional command line arguments if kmail/kontact is
         // not called with "-session foo"
         for (const QString &arg : parser.positionalArguments()) {
             if (arg.startsWith(QLatin1String("mailto:"), Qt::CaseInsensitive)) {
                 const QUrl urlDecoded(QUrl::fromPercentEncoding(arg.toUtf8()));
                 QMap<QString, QString> values = MessageCore::StringUtil::parseMailtoUrl(urlDecoded);
                 QString previousKey;
                 for (auto it = values.cbegin(), end = values.cend(); it != end; ++it) {
                     const QString key = it.key().toLower();
                     if (key == QLatin1Literal("to")) {
                         if (!it->isEmpty()) {
                             to += *it + QStringLiteral(", ");
                         }
                         previousKey.clear();
                     } else if (key == QLatin1Literal("cc")) {
                         if (!it->isEmpty()) {
                             cc += *it + QStringLiteral(", ");
                         }
                         previousKey.clear();
                     } else if (key == QLatin1Literal("bcc")) {
                         if (!it->isEmpty()) {
                             bcc += *it + QStringLiteral(", ");
                         }
                         previousKey.clear();
                     } else if (key == QLatin1Literal("subject")) {
                         subj = it.value();
                         previousKey.clear();
                     } else if (key == QLatin1Literal("body")) {
                         body = it.value();
                         previousKey = key;
                     } else if (key == QLatin1Literal("in-reply-to")) {
                         inReplyTo = it.value();
                         previousKey.clear();
                     } else if (key == QLatin1Literal("attachment") || key == QLatin1Literal("attach")) {
                         if (!it->isEmpty()) {
                             attachURLs << makeAbsoluteUrl(*it, workingDir);
                         }
                         previousKey.clear();
                     } else {
                         qCWarning(KMAIL_LOG) << "unknown key" << key;
                         //Workaround: https://bugs.kde.org/show_bug.cgi?id=390939
                         //QMap<QString, QString> parseMailtoUrl(const QUrl &url) parses correctly url
                         //But if we have a "&" unknown key we lost it.
                         if (previousKey == QLatin1Literal("body")) {
                             body += QLatin1Char('&') + key + QLatin1Char('=') + it.value();
                         }
                         previousKey.clear();
                     }
                 }
             } else {
                 QUrl url(arg);
                 if (url.isValid() && !url.scheme().isEmpty()) {
                     attachURLs += url;
                 } else {
                     to += arg + QStringLiteral(", ");
                 }
             }
             mailto = true;
         }
         if (!to.isEmpty()) {
             // cut off the superfluous trailing ", "
             to.truncate(to.length() - 2);
         }
     }
 
     if (!noArgsOpensReader && !mailto && !checkMail && !viewOnly) {
         return false;
     }
 
     if (viewOnly) {
         viewMessage(messageFile);
     } else {
         action(mailto, checkMail, to, cc, bcc, subj, body, messageFile,
                attachURLs, customHeaders, replyTo, inReplyTo, identity);
     }
     return true;
 }
 
 /********************************************************************/
 /*             D-Bus-callable, and command line actions              */
 /********************************************************************/
 void KMKernel::checkMail()  //might create a new reader but won't show!!
 {
     if (!kmkernel->askToGoOnline()) {
         return;
     }
 
     const QString resourceGroupPattern(QStringLiteral("Resource %1"));
 
     const Akonadi::AgentInstance::List lst = MailCommon::Util::agentInstances();
     for (Akonadi::AgentInstance type : lst) {
         const QString id = type.identifier();
         KConfigGroup group(KMKernel::config(), resourceGroupPattern.arg(id));
         if (group.readEntry("IncludeInManualChecks", true)) {
             if (!type.isOnline()) {
                 type.setIsOnline(true);
             }
             if (mResourcesBeingChecked.isEmpty()) {
                 qCDebug(KMAIL_LOG) << "Starting manual mail check";
                 Q_EMIT startCheckMail();
             }
 
             if (!mResourcesBeingChecked.contains(id)) {
                 mResourcesBeingChecked.append(id);
             }
             type.synchronize();
         }
     }
 }
 
 void KMKernel::openReader()
 {
     openReader(false);
 }
 
 QStringList KMKernel::accounts() const
 {
     QStringList accountLst;
     const Akonadi::AgentInstance::List lst = MailCommon::Util::agentInstances();
     accountLst.reserve(lst.count());
     for (const Akonadi::AgentInstance &type : lst) {
         // Explicitly make a copy, as we're not changing values of the list but only
         // the local copy which is passed to action.
         accountLst << type.identifier();
     }
     return accountLst;
 }
 
 void KMKernel::checkAccount(const QString &account)   //might create a new reader but won't show!!
 {
     if (account.isEmpty()) {
         checkMail();
     } else {
         Akonadi::AgentInstance agent = Akonadi::AgentManager::self()->instance(account);
         if (agent.isValid()) {
             agent.synchronize();
         } else {
             qCDebug(KMAIL_LOG) << "- account with name '" << account << "' not found";
         }
     }
 }
 
 void KMKernel::openReader(bool onlyCheck)
 {
     KMainWindow *ktmw = nullptr;
 
     foreach (KMainWindow *window, KMainWindow::memberList()) {
         if (::qobject_cast<KMMainWin *>(window)) {
             ktmw = window;
             break;
         }
     }
 
     bool activate;
     if (ktmw) {
         KMMainWin *win = static_cast<KMMainWin *>(ktmw);
         activate = !onlyCheck; // existing window: only activate if not --check
         if (activate) {
             win->show();
         }
     } else {
         KMMainWin *win = new KMMainWin;
         win->show();
         activate = false; // new window: no explicit activation (#73591)
     }
 }
 
 void KMKernel::openComposer(const QString &to, const QString &cc, const QString &bcc, const QString &subject, const QString &body, bool hidden, const QString &messageFile,
                             const QStringList &attachmentPaths, const QStringList &customHeaders, const QString &replyTo, const QString &inReplyTo, const QString &identity)
 {
     const OpenComposerSettings settings(to, cc,
                                         bcc, subject,
                                         body, hidden,
                                         messageFile,
                                         attachmentPaths,
                                         customHeaders,
                                         replyTo, inReplyTo, identity);
     OpenComposerJob *job = new OpenComposerJob(this);
     job->setOpenComposerSettings(settings);
     job->start();
 }
 
 void KMKernel::openComposer(const QString &to, const QString &cc, const QString &bcc, const QString &subject, const QString &body, bool hidden, const QString &attachName, const QByteArray &attachCte,
                             const QByteArray &attachData, const QByteArray &attachType, const QByteArray &attachSubType, const QByteArray &attachParamAttr, const QString &attachParamValue,
                             const QByteArray &attachContDisp, const QByteArray &attachCharset, unsigned int identity)
 {
     fillComposer(hidden, to, cc, bcc,
                  subject, body,
                  attachName, attachCte, attachData,
                  attachType, attachSubType, attachParamAttr, attachParamValue,
                  attachContDisp, attachCharset, identity, false);
 }
 
 void KMKernel::openComposer(const QString &to, const QString &cc, const QString &bcc, const QString &subject, const QString &body, const QString &attachName, const QByteArray &attachCte,
                             const QByteArray &attachData, const QByteArray &attachType, const QByteArray &attachSubType, const QByteArray &attachParamAttr, const QString &attachParamValue,
                             const QByteArray &attachContDisp, const QByteArray &attachCharset, unsigned int identity)
 {
     fillComposer(false, to, cc, bcc,
                  subject, body,
                  attachName, attachCte, attachData,
                  attachType, attachSubType, attachParamAttr, attachParamValue,
                  attachContDisp, attachCharset, identity, true);
 }
 
 void KMKernel::fillComposer(bool hidden, const QString &to, const QString &cc, const QString &bcc, const QString &subject, const QString &body, const QString &attachName, const QByteArray &attachCte,
                             const QByteArray &attachData, const QByteArray &attachType, const QByteArray &attachSubType, const QByteArray &attachParamAttr, const QString &attachParamValue,
                             const QByteArray &attachContDisp, const QByteArray &attachCharset, unsigned int identity, bool forceShowWindow)
 {
     const FillComposerJobSettings settings(hidden,
                                            to,
                                            cc,
                                            bcc,
                                            subject,
                                            body,
                                            attachName,
                                            attachCte,
                                            attachData,
                                            attachType,
                                            attachSubType,
                                            attachParamAttr,
                                            attachParamValue,
                                            attachContDisp,
                                            attachCharset,
                                            identity,
                                            forceShowWindow);
     FillComposerJob *job = new FillComposerJob;
     job->setSettings(settings);
     job->start();
 }
 
 void KMKernel::openComposer(const QString &to, const QString &cc, const QString &bcc, const QString &subject, const QString &body, bool hidden)
 {
     const OpenComposerHiddenJobSettings settings(to, cc,
                                                  bcc,
                                                  subject,
                                                  body, hidden);
     OpenComposerHiddenJob *job = new OpenComposerHiddenJob(this);
     job->setSettings(settings);
     job->start();
 }
 
 void KMKernel::newMessage(const QString &to, const QString &cc, const QString &bcc, bool hidden, bool useFolderId, const QString & /*messageFile*/, const QString &_attachURL)
 {
     QSharedPointer<FolderSettings> folder;
     Akonadi::Collection col;
     uint id = 0;
     if (useFolderId) {
         //create message with required folder identity
         folder = currentFolderCollection();
         id = folder ? folder->identity() : 0;
         col = currentCollection();
     }
 
     const NewMessageJobSettings settings(to,
                                          cc,
                                          bcc,
                                          hidden,
                                          _attachURL,
                                          folder,
                                          id,
                                          col);
 
     NewMessageJob *job = new NewMessageJob(this);
     job->setNewMessageJobSettings(settings);
     job->start();
 }
 
 void KMKernel::viewMessage(const QUrl &url)
 {
     KMOpenMsgCommand *openCommand = new KMOpenMsgCommand(nullptr, url);
 
     openCommand->start();
 }
 
 int KMKernel::viewMessage(const QString &messageFile)
 {
     KMOpenMsgCommand *openCommand = new KMOpenMsgCommand(nullptr, QUrl::fromLocalFile(messageFile));
 
     openCommand->start();
     return 1;
 }
 
 void KMKernel::raise()
 {
     QDBusInterface iface(QStringLiteral("org.kde.kmail"), QStringLiteral("/MainApplication"),
                          QStringLiteral("org.kde.PIMUniqueApplication"),
                          QDBusConnection::sessionBus());
     QDBusReply<int> reply;
     if (!iface.isValid() || !(reply = iface.call(QStringLiteral("newInstance"))).isValid()) {
         QDBusError err = iface.lastError();
         qCritical() << "Communication problem with KMail. "
                     << "Error message was:" << err.name() << ": \"" << err.message() << "\"";
     }
 }
 
 bool KMKernel::showMail(qint64 serialNumber)
 {
     KMMainWidget *mainWidget = nullptr;
 
     // First look for a KMainWindow.
     foreach (KMainWindow *window, KMainWindow::memberList()) {
         // Then look for a KMMainWidget.
         QList<KMMainWidget *> l = window->findChildren<KMMainWidget *>();
         if (!l.isEmpty() && l.first()) {
             mainWidget = l.first();
             if (window->isActiveWindow()) {
                 break;
             }
         }
     }
     if (mainWidget) {
         Akonadi::ItemFetchJob *job = new Akonadi::ItemFetchJob(Akonadi::Item(serialNumber), this);
         job->fetchScope().fetchFullPayload();
         job->fetchScope().setAncestorRetrieval(Akonadi::ItemFetchScope::Parent);
         if (job->exec()) {
             if (job->items().count() >= 1) {
                 KMReaderMainWin *win = new KMReaderMainWin(MessageViewer::Viewer::UseGlobalSetting, false);
                 const auto item = job->items().at(0);
                 win->showMessage(MessageCore::MessageCoreSettings::self()->overrideCharacterEncoding(),
                                  item, item.parentCollection());
                 win->show();
                 return true;
             }
         }
     }
     return false;
 }
 
 void KMKernel::pauseBackgroundJobs()
 {
     mBackgroundTasksTimer->stop();
     mJobScheduler->pause();
 }
 
 void KMKernel::resumeBackgroundJobs()
 {
     mJobScheduler->resume();
     mBackgroundTasksTimer->start(4 * 60 * 60 * 1000);
 }
 
 void KMKernel::stopNetworkJobs()
 {
     if (KMailSettings::self()->networkState() == KMailSettings::EnumNetworkState::Offline) {
         return;
     }
 
     setAccountStatus(false);
 
     KMailSettings::setNetworkState(KMailSettings::EnumNetworkState::Offline);
     BroadcastStatus::instance()->setStatusMsg(i18n("KMail is set to be offline; all network jobs are suspended"));
     Q_EMIT onlineStatusChanged((KMailSettings::EnumNetworkState::type)KMailSettings::networkState());
 }
 
 void KMKernel::setAccountStatus(bool goOnline)
 {
     const Akonadi::AgentInstance::List lst = MailCommon::Util::agentInstances(false);
     for (Akonadi::AgentInstance type : lst) {
         const QString identifier(type.identifier());
         if (PimCommon::Util::isImapResource(identifier)
             || identifier.contains(POP3_RESOURCE_IDENTIFIER)
             || identifier.contains(QLatin1String("akonadi_maildispatcher_agent"))
             || type.type().capabilities().contains(QLatin1String("NeedsNetwork"))) {
             type.setIsOnline(goOnline);
         }
     }
     if (goOnline && MessageComposer::MessageComposerSettings::self()->sendImmediate()) {
         const auto col = CommonKernel->collectionFromId(CommonKernel->outboxCollectionFolder().id());
         const qint64 nbMsgOutboxCollection = col.statistics().count();
         if (nbMsgOutboxCollection > 0) {
             if (!kmkernel->msgSender()->sendQueued()) {
                 KMessageBox::error(KMKernel::self()->mainWin(), i18n("Impossible to send email"), i18n("Send Email"));
             }
         }
     }
 }
 
 const QString KMKernel::xmlGuiInstanceName() const
 {
     return mXmlGuiInstance;
 }
 
 void KMKernel::setXmlGuiInstanceName(const QString &instance)
 {
     mXmlGuiInstance = instance;
 }
 
 KMail::UndoStack *KMKernel::undoStack() const
 {
     return the_undoStack;
 }
 
 void KMKernel::resumeNetworkJobs()
 {
     if (KMailSettings::self()->networkState() == KMailSettings::EnumNetworkState::Online) {
         return;
     }
 
     if (mSystemNetworkStatus) {
         setAccountStatus(true);
         BroadcastStatus::instance()->setStatusMsg(i18n("KMail is set to be online; all network jobs resumed"));
     } else {
         BroadcastStatus::instance()->setStatusMsg(i18n("KMail is set to be online; all network jobs will resume when a network connection is detected"));
     }
     KMailSettings::setNetworkState(KMailSettings::EnumNetworkState::Online);
     Q_EMIT onlineStatusChanged((KMailSettings::EnumNetworkState::type)KMailSettings::networkState());
     KMMainWidget *widget = getKMMainWidget();
     if (widget) {
         widget->refreshMessageListSelection();
     }
 }
 
 bool KMKernel::isOffline()
 {
     if ((KMailSettings::self()->networkState() == KMailSettings::EnumNetworkState::Offline)
         || !PimCommon::NetworkManager::self()->networkConfigureManager()->isOnline()) {
         return true;
     } else {
         return false;
     }
 }
 
 void KMKernel::verifyAccount()
 {
     const QString resourceGroupPattern(QStringLiteral("Resource %1"));
 
     const Akonadi::AgentInstance::List lst = MailCommon::Util::agentInstances();
     for (Akonadi::AgentInstance type : lst) {
         KConfigGroup group(KMKernel::config(), resourceGroupPattern.arg(type.identifier()));
         if (group.readEntry("CheckOnStartup", false)) {
             if (!type.isOnline()) {
                 type.setIsOnline(true);
             }
             type.synchronize();
         }
 
         // "false" is also hardcoded in ConfigureDialog, don't forget to change there.
         if (group.readEntry("OfflineOnShutdown", false)) {
             if (!type.isOnline()) {
                 type.setIsOnline(true);
             }
         }
     }
 }
 
 void KMKernel::slotCheckAccount(Akonadi::ServerManager::State state)
 {
     if (state == Akonadi::ServerManager::Running) {
         disconnect(Akonadi::ServerManager::self(), SIGNAL(stateChanged(Akonadi::ServerManager::State)));
         verifyAccount();
     }
 }
 
 void KMKernel::checkMailOnStartup()
 {
     if (!kmkernel->askToGoOnline()) {
         return;
     }
 
     if (Akonadi::ServerManager::state() != Akonadi::ServerManager::Running) {
         connect(Akonadi::ServerManager::self(), &Akonadi::ServerManager::stateChanged, this, &KMKernel::slotCheckAccount);
     } else {
         verifyAccount();
     }
 }
 
 bool KMKernel::askToGoOnline()
 {
     // already asking means we are offline and need to wait anyhow
     if (s_askingToGoOnline) {
         return false;
     }
 
     if (KMailSettings::self()->networkState() == KMailSettings::EnumNetworkState::Offline) {
         s_askingToGoOnline = true;
         int rc
             = KMessageBox::questionYesNo(KMKernel::self()->mainWin(),
                                          i18n("KMail is currently in offline mode. "
                                               "How do you want to proceed?"),
                                          i18n("Online/Offline"),
                                          KGuiItem(i18n("Work Online")),
                                          KGuiItem(i18n("Work Offline")));
 
         s_askingToGoOnline = false;
         if (rc == KMessageBox::No) {
             return false;
         } else {
             kmkernel->resumeNetworkJobs();
         }
     }
     if (kmkernel->isOffline()) {
         return false;
     }
 
     return true;
 }
 
 void KMKernel::slotSystemNetworkStatusChanged(bool isOnline)
 {
     mSystemNetworkStatus = isOnline;
     if (KMailSettings::self()->networkState() == KMailSettings::EnumNetworkState::Offline) {
         return;
     }
 
     if (isOnline) {
         BroadcastStatus::instance()->setStatusMsg(i18n(
                                                       "Network connection detected, all network jobs resumed"));
         kmkernel->setAccountStatus(true);
     } else {
         BroadcastStatus::instance()->setStatusMsg(i18n(
                                                       "No network connection detected, all network jobs are suspended"));
         kmkernel->setAccountStatus(false);
     }
 }
 
 /********************************************************************/
 /*                        Kernel methods                            */
 /********************************************************************/
 
 void KMKernel::quit()
 {
     // Called when all windows are closed. Will take care of compacting,
     // sending... should handle session management too!!
 }
 
 /* TODO later:
    Asuming that:
      - msgsender is nonblocking
        (our own, QSocketNotifier based. Pops up errors and sends signal
         senderFinished when done)
 
    o If we are getting mail, stop it (but don't lose something!)
          [Done already, see mailCheckAborted]
    o If we are sending mail, go on UNLESS this was called by SM,
        in which case stop ASAP that too (can we warn? should we continue
        on next start?)
    o If we are compacting, or expunging, go on UNLESS this was SM call.
        In that case stop compacting ASAP and continue on next start, before
        touching any folders. [Not needed anymore with CompactionJob]
 
    KMKernel::quit ()
    {
      SM call?
        if compacting, stop;
        if sending, stop;
        if receiving, stop;
        Windows will take care of themselves (composer should dump
         its messages, if any but not in deadMail)
        declare us ready for the End of the Session
 
      No, normal quit call
        All windows are off. Anything to do, should compact or sender sends?
          Yes, maybe put an icon in panel as a sign of life
          if sender sending, connect us to his finished slot, declare us ready
                             for quit and wait for senderFinished
          if not, Folder manager, go compact sent-mail and outbox
 }                (= call slotFinished())
 
 void KMKernel::slotSenderFinished()
 {
   good, Folder manager go compact sent-mail and outbox
   clean up stage1 (release folders and config, unregister from dcop)
     -- another kmail may start now ---
   qApp->quit();
 }
 */
 
 /********************************************************************/
 /*            Init, Exit, and handler  methods                      */
 /********************************************************************/
 
 //-----------------------------------------------------------------------------
 // Open a composer for each message found in the dead.letter folder
 void KMKernel::recoverDeadLetters()
 {
     const QString pathName = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1String("/kmail2/");
     QDir dir(pathName);
     if (!dir.exists(QStringLiteral("autosave"))) {
         return;
     }
 
     dir.cd(pathName + QLatin1String("autosave"));
     const QFileInfoList autoSaveFiles = dir.entryInfoList();
     for (const QFileInfo &file : autoSaveFiles) {
         // Disregard the '.' and '..' folders
         const QString filename = file.fileName();
         if (filename == QLatin1String(".")
             || filename == QLatin1String("..")
             || file.isDir()) {
             continue;
         }
         qCDebug(KMAIL_LOG) << "Opening autosave file:" << file.absoluteFilePath();
         QFile autoSaveFile(file.absoluteFilePath());
         if (autoSaveFile.open(QIODevice::ReadOnly)) {
             const KMime::Message::Ptr autoSaveMessage(new KMime::Message());
             const QByteArray msgData = autoSaveFile.readAll();
             autoSaveMessage->setContent(msgData);
             autoSaveMessage->parse();
 
             // Show the a new composer dialog for the message
             KMail::Composer *autoSaveWin = KMail::makeComposer();
             autoSaveWin->setMessage(autoSaveMessage, false, false, false);
             autoSaveWin->setAutoSaveFileName(filename);
             autoSaveWin->show();
             autoSaveFile.close();
         } else {
             KMessageBox::sorry(nullptr, i18n("Failed to open autosave file at %1.\nReason: %2",
                                              file.absoluteFilePath(), autoSaveFile.errorString()),
                                i18n("Opening Autosave File Failed"));
         }
     }
 }
 
 void KMKernel::akonadiStateChanged(Akonadi::ServerManager::State state)
 {
     qCDebug(KMAIL_LOG) << "KMKernel has akonadi state changed to:" << int(state);
 
     if (state == Akonadi::ServerManager::Running) {
         CommonKernel->initFolders();
     }
 }
 
 static void kmCrashHandler(int sigId)
 {
     fprintf(stderr, "*** KMail got signal %d (Exiting)\n", sigId);
     // try to cleanup all windows
     if (kmkernel) {
         kmkernel->dumpDeadLetters();
         fprintf(stderr, "*** Dead letters dumped.\n");
         kmkernel->stopAgentInstance();
         kmkernel->cleanupTemporaryFiles();
     }
 }
 
 void KMKernel::init()
 {
     the_shuttingDown = false;
 
     the_firstStart = KMailSettings::self()->firstStart();
     KMailSettings::self()->setFirstStart(false);
 
     the_undoStack = new KMail::UndoStack(20);
 
     the_msgSender = new MessageComposer::AkonadiSender;
     // filterMgr->dump();
 
     mBackgroundTasksTimer = new QTimer(this);
     mBackgroundTasksTimer->setSingleShot(true);
     connect(mBackgroundTasksTimer, &QTimer::timeout, this, &KMKernel::slotRunBackgroundTasks);
 #ifdef DEBUG_SCHEDULER // for debugging, see jobscheduler.h
     mBackgroundTasksTimer->start(10000);   // 10s, singleshot
 #else
     mBackgroundTasksTimer->start(5 * 60000);   // 5 minutes, singleshot
 #endif
 
     KCrash::setEmergencySaveFunction(kmCrashHandler);
 
     qCDebug(KMAIL_LOG) << "KMail init with akonadi server state:" << int(Akonadi::ServerManager::state());
     if (Akonadi::ServerManager::state() == Akonadi::ServerManager::Running) {
         CommonKernel->initFolders();
     }
 
     connect(Akonadi::ServerManager::self(), &Akonadi::ServerManager::stateChanged, this, &KMKernel::akonadiStateChanged);
 }
 
 bool KMKernel::doSessionManagement()
 {
     // Do session management
     if (qApp->isSessionRestored()) {
         int n = 1;
         while (KMMainWin::canBeRestored(n)) {
             //only restore main windows! (Matthias);
             if (KMMainWin::classNameOfToplevel(n) == QLatin1String("KMMainWin")) {
                 (new KMMainWin)->restoreDockedState(n);
             }
             ++n;
         }
         return true; // we were restored by SM
     }
     return false;  // no, we were not restored
 }
 
 bool KMKernel::firstInstance() const
 {
     return the_firstInstance;
 }
 
 void KMKernel::setFirstInstance(bool value)
 {
     the_firstInstance = value;
 }
 
 void KMKernel::closeAllKMailWindows()
 {
     foreach (KMainWindow *window, KMainWindow::memberList()) {
         if (::qobject_cast<KMMainWin *>(window)
             || ::qobject_cast<KMail::SecondaryWindow *>(window)) {
             // close and delete the window
             window->setAttribute(Qt::WA_DeleteOnClose);
             window->close();
         }
     }
 }
 
 void KMKernel::cleanup()
 {
     disconnect(Akonadi::AgentManager::self(), SIGNAL(instanceStatusChanged(Akonadi::AgentInstance)));
     disconnect(Akonadi::AgentManager::self(), SIGNAL(instanceError(Akonadi::AgentInstance,QString)));
     disconnect(Akonadi::AgentManager::self(), SIGNAL(instanceWarning(Akonadi::AgentInstance,QString)));
     disconnect(Akonadi::AgentManager::self(), SIGNAL(instanceRemoved(Akonadi::AgentInstance)));
     disconnect(KPIM::ProgressManager::instance(), SIGNAL(progressItemCompleted(KPIM::ProgressItem*)));
     disconnect(KPIM::ProgressManager::instance(), SIGNAL(progressItemCanceled(KPIM::ProgressItem*)));
 
     dumpDeadLetters();
     the_shuttingDown = true;
     closeAllKMailWindows();
 
     // Flush the cache of foldercollection objects. This results
     // in configuration writes, so we need to do it early enough.
     MailCommon::FolderSettings::clearCache();
 
     // Write the config while all other managers are alive
     delete the_msgSender;
     the_msgSender = nullptr;
     delete the_undoStack;
     the_undoStack = nullptr;
     delete mConfigureDialog;
     mConfigureDialog = nullptr;
 
     KSharedConfig::Ptr config = KMKernel::config();
     if (RecentAddresses::exists()) {
         RecentAddresses::self(config.data())->save(config.data());
     }
 
     Akonadi::Collection trashCollection = CommonKernel->trashCollectionFolder();
     if (trashCollection.isValid()) {
         if (KMailSettings::self()->emptyTrashOnExit()) {
             OrgFreedesktopAkonadiMailFilterAgentInterface mailFilterInterface(QStringLiteral("org.freedesktop.Akonadi.MailFilterAgent"), QStringLiteral(
                                                                                   "/MailFilterAgent"), QDBusConnection::sessionBus(), this);
             if (mailFilterInterface.isValid()) {
                 mailFilterInterface.expunge(static_cast<qlonglong>(trashCollection.id()));
             } else {
                 qCWarning(KMAIL_LOG) << "Mailfilter is not active";
             }
         }
     }
 }
 
 void KMKernel::dumpDeadLetters()
 {
     if (shuttingDown()) {
         return;    //All documents should be saved before shutting down is set!
     }
 
     // make all composer windows autosave their contents
     foreach (KMainWindow *window, KMainWindow::memberList()) {
         if (KMail::Composer *win = ::qobject_cast<KMail::Composer *>(window)) {
             win->autoSaveMessage(true);
 
             while (win->isComposing()) {
                 qCWarning(KMAIL_LOG) << "Danger, using an event loop, this should no longer be happening!";
                 qApp->processEvents();
             }
         }
     }
 }
 
 void KMKernel::action(bool mailto, bool check, const QString &to, const QString &cc, const QString &bcc, const QString &subj, const QString &body, const QUrl &messageFile,
                       const QList<QUrl> &attachURLs, const QStringList &customHeaders, const QString &replyTo, const QString &inReplyTo, const QString &identity)
 {
     if (mailto) {
         openComposer(to, cc, bcc, subj, body, 0,
                      messageFile.toLocalFile(), QUrl::toStringList(attachURLs),
                      customHeaders, replyTo, inReplyTo, identity);
     } else {
         openReader(check);
     }
 
     if (check) {
         checkMail();
     }
     //Anything else?
 }
 
 void KMKernel::slotRequestConfigSync()
 {
     // ### FIXME: delay as promised in the kdoc of this function ;-)
     slotSyncConfig();
 }
 
 void KMKernel::slotSyncConfig()
 {
     PimCommon::PimCommonSettings::self()->save();
     MessageCore::MessageCoreSettings::self()->save();
     MessageViewer::MessageViewerSettings::self()->save();
     MessageComposer::MessageComposerSettings::self()->save();
     TemplateParser::TemplateParserSettings::self()->save();
     MessageList::MessageListSettings::self()->save();
     mMailCommonSettings->save();
     Gravatar::GravatarSettings::self()->save();
     KMailSettings::self()->save();
     KMKernel::config()->sync();
     //Laurent investigate why we need to reload them.
     PimCommon::PimCommonSettings::self()->load();
     MessageCore::MessageCoreSettings::self()->load();
     MessageViewer::MessageViewerSettings::self()->load();
     MessageComposer::MessageComposerSettings::self()->load();
     TemplateParser::TemplateParserSettings::self()->load();
     MessageList::MessageListSettings::self()->load();
     mMailCommonSettings->load();
     Gravatar::GravatarSettings::self()->load();
     KMailSettings::self()->load();
     KMKernel::config()->reparseConfiguration();
 }
 
 void KMKernel::updateConfig()
 {
     slotConfigChanged();
 }
 
 void KMKernel::slotShowConfigurationDialog()
 {
     if (KMKernel::getKMMainWidget() == nullptr) {
         // ensure that there is a main widget available
         // as parts of the configure dialog (identity) rely on this
         // and this slot can be called when there is only a KMComposeWin showing
         KMMainWin *win = new KMMainWin;
         win->show();
     }
 
     if (!mConfigureDialog) {
         mConfigureDialog = new ConfigureDialog(nullptr, false);
         mConfigureDialog->setObjectName(QStringLiteral("configure"));
         connect(mConfigureDialog, &ConfigureDialog::configChanged, this, &KMKernel::slotConfigChanged);
     }
 
     // Save all current settings.
     if (getKMMainWidget()) {
         getKMMainWidget()->writeReaderConfig();
     }
 
     if (mConfigureDialog->isHidden()) {
         mConfigureDialog->show();
     } else {
         mConfigureDialog->raise();
     }
 }
 
 void KMKernel::slotConfigChanged()
 {
     CodecManager::self()->updatePreferredCharsets();
     Q_EMIT configChanged();
 }
 
 //-------------------------------------------------------------------------------
 
 bool KMKernel::haveSystemTrayApplet() const
 {
     return mUnityServiceManager->haveSystemTrayApplet();
 }
 
 QTextCodec *KMKernel::networkCodec() const
 {
     return mNetCodec;
 }
 
 void KMKernel::updateSystemTray()
 {
     if (!the_shuttingDown) {
         mUnityServiceManager->initListOfCollection();
     }
 }
 
 KIdentityManagement::IdentityManager *KMKernel::identityManager()
 {
     return KIdentityManagement::IdentityManager::self();
 }
 
 JobScheduler *KMKernel::jobScheduler() const
 {
     return mJobScheduler;
 }
 
 KMainWindow *KMKernel::mainWin()
 {
     // First look for a KMMainWin.
     foreach (KMainWindow *window, KMainWindow::memberList()) {
         if (::qobject_cast<KMMainWin *>(window)) {
             return window;
         }
     }
 
     // There is no KMMainWin. Use any other KMainWindow instead (e.g. in
     // case we are running inside Kontact) because we anyway only need
     // it for modal message boxes and for KNotify events.
     if (!KMainWindow::memberList().isEmpty()) {
         KMainWindow *kmWin = KMainWindow::memberList().constFirst();
         if (kmWin) {
             return kmWin;
         }
     }
 
     // There's not a single KMainWindow. Create a KMMainWin.
     // This could happen if we want to pop up an error message
     // while we are still doing the startup wizard and no other
     // KMainWindow is running.
     return new KMMainWin;
 }
 
 KMKernel *KMKernel::self()
 {
     return mySelf;
 }
 
 KSharedConfig::Ptr KMKernel::config()
 {
     assert(mySelf);
     if (!mySelf->mConfig) {
         mySelf->mConfig = KSharedConfig::openConfig(QStringLiteral("kmail2rc"));
         // Check that all updates have been run on the config file:
         MessageList::MessageListSettings::self()->setSharedConfig(mySelf->mConfig);
         MessageList::MessageListSettings::self()->load();
         TemplateParser::TemplateParserSettings::self()->setSharedConfig(mySelf->mConfig);
         TemplateParser::TemplateParserSettings::self()->load();
         MessageComposer::MessageComposerSettings::self()->setSharedConfig(mySelf->mConfig);
         MessageComposer::MessageComposerSettings::self()->load();
         MessageCore::MessageCoreSettings::self()->setSharedConfig(mySelf->mConfig);
         MessageCore::MessageCoreSettings::self()->load();
         MessageViewer::MessageViewerSettings::self()->setSharedConfig(mySelf->mConfig);
         MessageViewer::MessageViewerSettings::self()->load();
         mMailCommonSettings = new MailCommon::MailCommonSettings;
 
         mMailCommonSettings->setSharedConfig(mySelf->mConfig);
         mMailCommonSettings->load();
         PimCommon::PimCommonSettings::self()->setSharedConfig(mySelf->mConfig);
         PimCommon::PimCommonSettings::self()->load();
         Gravatar::GravatarSettings::self()->setSharedConfig(mySelf->mConfig);
         Gravatar::GravatarSettings::self()->load();
     }
     return mySelf->mConfig;
 }
 
 void KMKernel::syncConfig()
 {
     slotRequestConfigSync();
 }
 
 void KMKernel::selectCollectionFromId(Akonadi::Collection::Id id)
 {
     KMMainWidget *widget = getKMMainWidget();
     Q_ASSERT(widget);
     if (!widget) {
         return;
     }
 
     Akonadi::Collection colFolder = CommonKernel->collectionFromId(id);
 
     if (colFolder.isValid()) {
         widget->slotSelectCollectionFolder(colFolder);
     }
 }
 
 bool KMKernel::selectFolder(const QString &folder)
 {
     KMMainWidget *widget = getKMMainWidget();
     Q_ASSERT(widget);
     if (!widget) {
         return false;
     }
 
     const Akonadi::Collection colFolder = CommonKernel->collectionFromId(folder.toLongLong());
 
     if (colFolder.isValid()) {
         widget->slotSelectCollectionFolder(colFolder);
         return true;
     }
     return false;
 }
 
 KMMainWidget *KMKernel::getKMMainWidget()
 {
     //This could definitely use a speadup
     const QWidgetList l = QApplication::topLevelWidgets();
 
     for (QWidget *wid : l) {
         QList<KMMainWidget *> l2 = wid->window()->findChildren<KMMainWidget *>();
         if (!l2.isEmpty() && l2.first()) {
             return l2.first();
         }
     }
     return nullptr;
 }
 
 void KMKernel::slotRunBackgroundTasks() // called regularly by timer
 {
     // Hidden KConfig keys. Not meant to be used, but a nice fallback in case
     // a stable kmail release goes out with a nasty bug in CompactionJob...
     if (KMailSettings::self()->autoExpiring()) {
         mFolderCollectionMonitor->expireAllFolders(false /*scheduled, not immediate*/, entityTreeModel());
     }
     if (KMailSettings::self()->checkCollectionsIndexing()) {
         mCheckIndexingManager->start(entityTreeModel());
     }
 #ifdef DEBUG_SCHEDULER // for debugging, see jobscheduler.h
     mBackgroundTasksTimer->start(60 * 1000);   // check again in 1 minute
 #else
     mBackgroundTasksTimer->start(4 * 60 * 60 * 1000);   // check again in 4 hours
 #endif
 }
 
 static Akonadi::Collection::List collect_collections(const QAbstractItemModel *model, const QModelIndex &parent)
 {
     Akonadi::Collection::List collections;
     QStack<QModelIndex> stack;
     stack.push(parent);
     while (!stack.isEmpty()) {
         const auto idx = stack.pop();
         if (idx.isValid()) {
             collections << model->data(idx, Akonadi::EntityTreeModel::CollectionRole).value<Akonadi::Collection>();
             for (int i = model->rowCount(idx) - 1; i >= 0; --i) {
                 stack.push(idx.child(i, 0));
             }
         }
     }
 
     return collections;
 }
 
 Akonadi::Collection::List KMKernel::allFolders() const
 {
     return collect_collections(collectionModel(), QModelIndex());
 }
 
 Akonadi::Collection::List KMKernel::subfolders(const Akonadi::Collection &col) const
 {
     const auto idx = collectionModel()->match({}, Akonadi::EntityTreeModel::CollectionRole,
                                               QVariant::fromValue(col), 1, Qt::MatchExactly);
     if (!idx.isEmpty()) {
         return collect_collections(collectionModel(), idx[0]);
     }
 
     return {};
 }
 
 void KMKernel::expireAllFoldersNow() // called by the GUI
 {
     mFolderCollectionMonitor->expireAllFolders(true /*immediate*/, entityTreeModel());
 }
 
 bool KMKernel::canQueryClose()
 {
     if (KMMainWidget::mainWidgetList()
         && KMMainWidget::mainWidgetList()->count() > 1) {
         return true;
     }
     return mUnityServiceManager->canQueryClose();
 }
 
 Akonadi::Collection KMKernel::currentCollection()
 {
     KMMainWidget *widget = getKMMainWidget();
     Akonadi::Collection col;
     if (widget) {
         col = widget->currentCollection();
     }
     return col;
 }
 
 QSharedPointer<FolderSettings> KMKernel::currentFolderCollection()
 {
     KMMainWidget *widget = getKMMainWidget();
     QSharedPointer<FolderSettings> folder;
     if (widget) {
         folder = widget->currentFolder();
     }
     return folder;
 }
 
 MailCommon::MailCommonSettings *KMKernel::mailCommonSettings() const
 {
     return mMailCommonSettings;
 }
 
 Akonadi::Search::PIM::IndexedItems *KMKernel::indexedItems() const
 {
     return mIndexedItems;
 }
 
 // can't be inline, since KMSender isn't known to implement
 // KMail::MessageSender outside this .cpp file
 MessageComposer::MessageSender *KMKernel::msgSender()
 {
     return the_msgSender;
 }
 
 void KMKernel::transportRemoved(int id, const QString &name)
 {
     Q_UNUSED(id);
 
     // reset all identities using the deleted transport
     QStringList changedIdents;
     KIdentityManagement::IdentityManager *im = identityManager();
     KIdentityManagement::IdentityManager::Iterator end = im->modifyEnd();
     for (KIdentityManagement::IdentityManager::Iterator it = im->modifyBegin(); it != end; ++it) {
         if (name == (*it).transport()) {
             (*it).setTransport(QString());
             changedIdents += (*it).identityName();
         }
     }
 
     // if the deleted transport is the currently used transport reset it to default
     const QString &currentTransport = KMailSettings::self()->currentTransport();
     if (name == currentTransport) {
         KMailSettings::self()->setCurrentTransport(QString());
     }
 
     if (!changedIdents.isEmpty()) {
         QString information = i18np("This identity has been changed to use the default transport:",
                                     "These %1 identities have been changed to use the default transport:",
                                     changedIdents.count());
         //Don't set parent otherwise we will swith to current KMail and we configure it. So not good
         KMessageBox::informationList(nullptr, information, changedIdents);
         im->commit();
     }
 }
 
 void KMKernel::transportRenamed(int id, const QString &oldName, const QString &newName)
 {
     Q_UNUSED(id);
 
     QStringList changedIdents;
     KIdentityManagement::IdentityManager *im = identityManager();
     KIdentityManagement::IdentityManager::Iterator end = im->modifyEnd();
     for (KIdentityManagement::IdentityManager::Iterator it = im->modifyBegin(); it != end; ++it) {
         if (oldName == (*it).transport()) {
             (*it).setTransport(newName);
             changedIdents << (*it).identityName();
         }
     }
 
     if (!changedIdents.isEmpty()) {
         const QString information
             = i18np("This identity has been changed to use the modified transport:",
                     "These %1 identities have been changed to use the modified transport:",
                     changedIdents.count());
         //Don't set parent otherwise we will swith to current KMail and we configure it. So not good
         KMessageBox::informationList(nullptr, information, changedIdents);
         im->commit();
     }
 }
 
 void KMKernel::itemDispatchStarted()
 {
     // Watch progress of the MDA.
     KPIM::ProgressManagerAkonadi::createProgressItem(nullptr,
                                                      MailTransport::DispatcherInterface().dispatcherInstance(),
                                                      QStringLiteral("Sender"),
                                                      i18n("Sending messages"),
                                                      i18n("Initiating sending process..."),
                                                      true, KPIM::ProgressItem::Unknown);
 }
 
 void KMKernel::instanceStatusChanged(const Akonadi::AgentInstance &instance)
 {
     if (instance.identifier() == QLatin1String("akonadi_mailfilter_agent")) {
         // Creating a progress item twice is ok, it will simply return the already existing
         // item
         KPIM::ProgressItem *progress = KPIM::ProgressManagerAkonadi::createProgressItem(nullptr, instance,
                                                                                         instance.identifier(), instance.name(), instance.statusMessage(),
                                                                                         false, KPIM::ProgressItem::Encrypted);
         progress->setProperty("AgentIdentifier", instance.identifier());
         return;
     }
     if (MailCommon::Util::agentInstances(true).contains(instance)) {
         if (instance.status() == Akonadi::AgentInstance::Running) {
             if (mResourcesBeingChecked.isEmpty()) {
                 qCDebug(KMAIL_LOG) << "A Resource started to synchronize, starting a mail check.";
                 Q_EMIT startCheckMail();
             }
 
             const QString identifier(instance.identifier());
             if (!mResourcesBeingChecked.contains(identifier)) {
                 mResourcesBeingChecked.append(identifier);
             }
 
             KPIM::ProgressItem::CryptoStatus cryptoStatus = KPIM::ProgressItem::Unencrypted;
             if (mResourceCryptoSettingCache.contains(identifier)) {
                 cryptoStatus = mResourceCryptoSettingCache.value(identifier);
             } else {
                 if (PimCommon::Util::isImapResource(identifier)) {
                     MailCommon::ResourceReadConfigFile resourceFile(identifier);
                     const KConfigGroup grp = resourceFile.group(QStringLiteral("network"));
                     if (grp.isValid()) {
                         const QString imapSafety = grp.readEntry(QStringLiteral("Safety"));
                         if (imapSafety == QLatin1String("None")) {
                             cryptoStatus = KPIM::ProgressItem::Unencrypted;
                         } else {
                             cryptoStatus = KPIM::ProgressItem::Encrypted;
                         }
 
                         mResourceCryptoSettingCache.insert(identifier, cryptoStatus);
                     }
                 } else if (identifier.contains(POP3_RESOURCE_IDENTIFIER)) {
                     MailCommon::ResourceReadConfigFile resourceFile(identifier);
                     const KConfigGroup grp = resourceFile.group(QStringLiteral("General"));
                     if (grp.isValid()) {
                         if (grp.readEntry(QStringLiteral("useSSL"), false) || grp.readEntry(QStringLiteral("useTLS"), false)) {
                             cryptoStatus = KPIM::ProgressItem::Encrypted;
                         }
                         mResourceCryptoSettingCache.insert(identifier, cryptoStatus);
                     }
                 }
             }
 
             // Creating a progress item twice is ok, it will simply return the already existing
             // item
             KPIM::ProgressItem *progress = KPIM::ProgressManagerAkonadi::createProgressItem(nullptr, instance,
                                                                                             instance.identifier(), instance.name(), instance.statusMessage(),
                                                                                             true, cryptoStatus);
             progress->setProperty("AgentIdentifier", instance.identifier());
         } else if (instance.status() == Akonadi::AgentInstance::Broken) {
             agentInstanceBroken(instance);
         }
     }
 }
 
 void KMKernel::agentInstanceBroken(const Akonadi::AgentInstance &instance)
 {
     const QString summary = i18n("Resource %1 is broken.", instance.name());
     KNotification::event(QStringLiteral("akonadi-resource-broken"),
                          summary,
                          QPixmap(),
                          nullptr,
                          KNotification::CloseOnTimeout);
 }
 
 void KMKernel::slotProgressItemCompletedOrCanceled(KPIM::ProgressItem *item)
 {
     const QString identifier = item->property("AgentIdentifier").toString();
     const Akonadi::AgentInstance agent = Akonadi::AgentManager::self()->instance(identifier);
     if (agent.isValid()) {
         mResourcesBeingChecked.removeAll(identifier);
         if (mResourcesBeingChecked.isEmpty()) {
             qCDebug(KMAIL_LOG) << "Last resource finished syncing, mail check done";
             Q_EMIT endCheckMail();
         }
     }
 }
 
 void KMKernel::updatedTemplates()
 {
     Q_EMIT customTemplatesChanged();
 }
 
 void KMKernel::cleanupTemporaryFiles()
 {
     QDir dir(QDir::tempPath());
     const QStringList lst = dir.entryList(QStringList{QStringLiteral("messageviewer_*")});
     qCDebug(KMAIL_LOG) << " list file to delete " << lst;
     for (const QString &file : lst) {
         QDir tempDir(QDir::tempPath() + QLatin1Char('/') + file);
         if (!tempDir.removeRecursively()) {
             fprintf(stderr, "%s was not removed .\n", qPrintable(tempDir.absolutePath()));
         } else {
             fprintf(stderr, "%s was removed .\n", qPrintable(tempDir.absolutePath()));
         }
     }
 }
 
 void KMKernel::stopAgentInstance()
 {
     const QString resourceGroupPattern(QStringLiteral("Resource %1"));
 
     const Akonadi::AgentInstance::List lst = MailCommon::Util::agentInstances();
     for (Akonadi::AgentInstance type : lst) {
         const QString identifier = type.identifier();
         KConfigGroup group(KMKernel::config(), resourceGroupPattern.arg(identifier));
 
         // Keep sync in ConfigureDialog, don't forget to change there.
         if (group.readEntry("OfflineOnShutdown", identifier.startsWith(QLatin1String("akonadi_pop3_resource")) ? true : false)) {
             type.setIsOnline(false);
         }
     }
 }
 
 void KMKernel::slotCollectionRemoved(const Akonadi::Collection &col)
 {
     KConfigGroup group(KMKernel::config(), MailCommon::FolderSettings::configGroupName(col));
     group.deleteGroup();
     group.sync();
     const QString colStr = QString::number(col.id());
     TemplateParser::Util::deleteTemplate(colStr);
     MessageList::Util::deleteConfig(colStr);
 }
 
 void KMKernel::slotDeleteIdentity(uint identity)
 {
     TemplateParser::Util::deleteTemplate(QStringLiteral("IDENTITY_%1").arg(identity));
 }
 
 bool KMKernel::showPopupAfterDnD()
 {
     return KMailSettings::self()->showPopupAfterDnD();
 }
 
 bool KMKernel::excludeImportantMailFromExpiry()
 {
     return KMailSettings::self()->excludeImportantMailFromExpiry();
 }
 
 qreal KMKernel::closeToQuotaThreshold()
 {
     return KMailSettings::self()->closeToQuotaThreshold();
 }
 
 Akonadi::Collection::Id KMKernel::lastSelectedFolder()
 {
     return KMailSettings::self()->lastSelectedFolder();
 }
 
 void KMKernel::setLastSelectedFolder(Akonadi::Collection::Id col)
 {
     KMailSettings::self()->setLastSelectedFolder(col);
 }
 
 QStringList KMKernel::customTemplates()
 {
     return GlobalSettingsBase::self()->customTemplates();
 }
 
 void KMKernel::openFilterDialog(bool createDummyFilter)
 {
     if (!mFilterEditDialog) {
         mFilterEditDialog = new MailCommon::KMFilterDialog(getKMMainWidget()->actionCollections(), nullptr, createDummyFilter);
         mFilterEditDialog->setObjectName(QStringLiteral("filterdialog"));
     }
     mFilterEditDialog->show();
     mFilterEditDialog->raise();
     mFilterEditDialog->activateWindow();
 }
 
 void KMKernel::createFilter(const QByteArray &field, const QString &value)
 {
     mFilterEditDialog->createFilter(field, value);
 }
 
 void KMKernel::checkFolderFromResources(const Akonadi::Collection::List &collectionList)
 {
     const Akonadi::AgentInstance::List lst = MailCommon::Util::agentInstances();
     for (const Akonadi::AgentInstance &type : lst) {
         if (type.status() == Akonadi::AgentInstance::Broken) {
             continue;
         }
         const QString typeIdentifier(type.identifier());
         if (PimCommon::Util::isImapResource(typeIdentifier)) {
             OrgKdeAkonadiImapSettingsInterface *iface = PimCommon::Util::createImapSettingsInterface(typeIdentifier);
             if (iface && iface->isValid()) {
                 const Akonadi::Collection::Id imapTrashId = iface->trashCollection();
                 for (const Akonadi::Collection &collection : collectionList) {
                     const Akonadi::Collection::Id collectionId = collection.id();
                     if (imapTrashId == collectionId) {
                         //Use default trash
                         iface->setTrashCollection(CommonKernel->trashCollectionFolder().id());
                         iface->save();
                         break;
                     }
                 }
             }
             delete iface;
         } else if (typeIdentifier.contains(POP3_RESOURCE_IDENTIFIER)) {
             OrgKdeAkonadiPOP3SettingsInterface *iface = MailCommon::Util::createPop3SettingsInterface(typeIdentifier);
             if (iface->isValid()) {
                 for (const Akonadi::Collection &collection : qAsConst(collectionList)) {
                     const Akonadi::Collection::Id collectionId = collection.id();
                     if (iface->targetCollection() == collectionId) {
                         //Use default inbox
                         iface->setTargetCollection(CommonKernel->inboxCollectionFolder().id());
                         iface->save();
                         break;
                     }
                 }
             }
             delete iface;
         }
     }
 }
 
 const QAbstractItemModel *KMKernel::treeviewModelSelection()
 {
     if (getKMMainWidget()) {
         return getKMMainWidget()->folderTreeView()->selectionModel()->model();
     } else {
         return entityTreeModel();
     }
 }
 
 void KMKernel::slotInstanceWarning(const Akonadi::AgentInstance &instance, const QString &message)
 {
     const QString summary = i18nc("<source>: <error message>", "%1: %2", instance.name(), message);
     KNotification::event(QStringLiteral("akonadi-instance-warning"),
                          summary,
                          QPixmap(),
                          nullptr,
                          KNotification::CloseOnTimeout);
 }
 
 void KMKernel::slotInstanceError(const Akonadi::AgentInstance &instance, const QString &message)
 {
     const QString summary = i18nc("<source>: <error message>", "%1: %2", instance.name(), message);
     KNotification::event(QStringLiteral("akonadi-instance-error"),
                          summary,
                          QPixmap(),
                          nullptr,
                          KNotification::CloseOnTimeout);
 }
 
 void KMKernel::slotInstanceRemoved(const Akonadi::AgentInstance &instance)
 {
     const QString identifier(instance.identifier());
     const QString resourceGroup = QStringLiteral("Resource %1").arg(identifier);
     if (KMKernel::config()->hasGroup(resourceGroup)) {
         KConfigGroup group(KMKernel::config(), resourceGroup);
         group.deleteGroup();
         group.sync();
     }
     if (mResourceCryptoSettingCache.contains(identifier)) {
         mResourceCryptoSettingCache.remove(identifier);
     }
     mFolderArchiveManager->slotInstanceRemoved(instance);
+
+    if (MailCommon::Util::isMailAgent(instance)) {
+        Q_EMIT incomingAccountsChanged();
+    }
+}
+
+void KMKernel::slotInstanceAdded(const Akonadi::AgentInstance &instance)
+{
+    if (MailCommon::Util::isMailAgent(instance)) {
+        Q_EMIT incomingAccountsChanged();
+    }
 }
 
 void KMKernel::savePaneSelection()
 {
     KMMainWidget *widget = getKMMainWidget();
     if (widget) {
         widget->savePaneSelection();
     }
 }
 
 void KMKernel::updatePaneTagComboBox()
 {
     KMMainWidget *widget = getKMMainWidget();
     if (widget) {
         widget->updatePaneTagComboBox();
     }
 }
 
 void KMKernel::resourceGoOnLine()
 {
     KMMainWidget *widget = getKMMainWidget();
     if (widget) {
         if (widget->currentCollection().isValid()) {
             Akonadi::Collection collection = widget->currentCollection();
             Akonadi::AgentInstance instance = Akonadi::AgentManager::self()->instance(collection.resource());
             instance.setIsOnline(true);
             widget->refreshMessageListSelection();
         }
     }
 }
 
 void KMKernel::makeResourceOnline(MessageViewer::Viewer::ResourceOnlineMode mode)
 {
     switch (mode) {
     case MessageViewer::Viewer::AllResources:
         resumeNetworkJobs();
         break;
     case MessageViewer::Viewer::SelectedResource:
         resourceGoOnLine();
         break;
     }
 }
 
 PimCommon::AutoCorrection *KMKernel::composerAutoCorrection()
 {
     return mAutoCorrection;
 }
 
 void KMKernel::toggleSystemTray()
 {
     KMMainWidget *widget = getKMMainWidget();
     if (widget) {
         mUnityServiceManager->toggleSystemTray(widget);
     }
 }
 
 void KMKernel::showFolder(const QString &collectionId)
 {
     if (!collectionId.isEmpty()) {
         const Akonadi::Collection::Id id = collectionId.toLongLong();
         selectCollectionFromId(id);
     }
 }
 
 void KMKernel::reloadFolderArchiveConfig()
 {
     mFolderArchiveManager->reloadConfig();
 }
 
 void KMKernel::slotCollectionChanged(const Akonadi::Collection &, const QSet<QByteArray> &set)
 {
     if (set.contains("newmailnotifierattribute")) {
         mUnityServiceManager->initListOfCollection();
     }
 }
 
 FolderArchiveManager *KMKernel::folderArchiveManager() const
 {
     return mFolderArchiveManager;
 }
 
 bool KMKernel::allowToDebug() const
 {
     return mDebug;
 }
 
 bool KMKernel::firstStart() const
 {
     return the_firstStart;
 }
 
 bool KMKernel::shuttingDown() const
 {
     return the_shuttingDown;
 }
 
 void KMKernel::setShuttingDown(bool flag)
 {
     the_shuttingDown = flag;
 }
 
 void KMKernel::expunge(Akonadi::Collection::Id col, bool sync)
 {
     Q_UNUSED(col);
     Q_UNUSED(sync);
 }
diff --git a/src/kmkernel.h b/src/kmkernel.h
index e7fc07129..4c8a283ec 100644
--- a/src/kmkernel.h
+++ b/src/kmkernel.h
@@ -1,529 +1,530 @@
 //
 
 #ifndef _KMKERNEL_H
 #define _KMKERNEL_H
 
 #include "mailcommon/mailinterfaces.h"
 
 #include <QList>
 #include <QObject>
 #include <QPointer>
 #include <QDBusObjectPath>
 
 #include <qurl.h>
 
 #include "kmail_export.h"
 #include "settings/kmailsettings.h"
 #include <AkonadiCore/servermanager.h>
 #include "messageviewer/viewer.h"
 #include "libkdepim/progressmanager.h"
 
 #define kmkernel KMKernel::self()
 #define kmconfig KMKernel::config()
 
 class QAbstractItemModel;
 namespace Akonadi {
 class Collection;
 class ChangeRecorder;
 class EntityTreeModel;
 class EntityMimeTypeFilterModel;
 }
 
 namespace Akonadi {
 namespace Search {
 namespace PIM {
 class IndexedItems;
 }
 }
 }
 
 namespace KIO {
 class Job;
 }
 
 namespace MessageComposer {
 class MessageSender;
 }
 namespace PimCommon {
 class AutoCorrection;
 }
 
 /** The KMail namespace contains classes used for KMail.
 * This is to keep them out of the way from all the other
 * un-namespaced classes in libs and the rest of PIM.
 */
 namespace KMail {
 class MailServiceImpl;
 class UndoStack;
 class UnityServiceManager;
 }
 namespace MessageComposer {
 class AkonadiSender;
 }
 
 namespace KIdentityManagement {
 class Identity;
 class IdentityManager;
 }
 
 namespace MailCommon {
 class Kernel;
 class FolderSettings;
 class FolderCollectionMonitor;
 class JobScheduler;
 class KMFilterDialog;
 class MailCommonSettings;
 }
 
 class QTimer;
 class KMainWindow;
 class KMMainWidget;
 class ConfigureDialog;
 class FolderArchiveManager;
 class CheckIndexingManager;
 
 /**
  * @short Central point of coordination in KMail
  *
  * The KMKernel class represents the core of KMail, where the different parts
  * come together and are coordinated. It is currently also the class which exports
  * KMail's main D-BUS interfaces.
  *
  * The kernel is responsible for creating various
  * (singleton) objects such as the identity manager and the message sender.
  *
  * The kernel also creates an Akonadi Session, Monitor and EntityTreeModel. These
  * are shared so that other objects in KMail have access to it. Having only one EntityTreeModel
  * instead of many reduces the overall communication with the Akonadi server.
  *
  * The kernel also manages some stuff that should be factored out:
  * - default collection handling, like inboxCollectionFolder()
  * - job handling, like jobScheduler()
  * - handling of some config settings, like wrapCol()
  * - various other stuff
  */
 class KMAIL_EXPORT KMKernel : public QObject, public MailCommon::IKernel, public MailCommon::ISettings, public MailCommon::IFilter
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.kmail.kmail")
 
 public:
     explicit KMKernel(QObject *parent = nullptr);
     ~KMKernel() override;
 
     /**
     * Start of D-Bus callable stuff. The D-Bus methods need to be public slots,
     * otherwise they can't be accessed.
     */
 public Q_SLOTS:
 
     Q_SCRIPTABLE void checkMail();
     Q_SCRIPTABLE void openReader();
 
     /**
     * Pauses all background jobs and does not
     * allow new background jobs to be started.
     */
     Q_SCRIPTABLE void pauseBackgroundJobs();
 
     /**
     * Resumes all background jobs and allows
     * new jobs to be started.
     */
     Q_SCRIPTABLE void resumeBackgroundJobs();
 
     /**
     * Stops all network related jobs and enter offline mode
     * New network jobs cannot be started.
     */
     Q_SCRIPTABLE void stopNetworkJobs();
 
     /**
     * Resumes all network related jobs and enter online mode
     * New network jobs can be started.
     */
     Q_SCRIPTABLE void resumeNetworkJobs();
 
     Q_SCRIPTABLE QStringList accounts() const;
 
     Q_SCRIPTABLE void makeResourceOnline(MessageViewer::Viewer::ResourceOnlineMode mode);
 
     /**
     * Checks the account with the specified name for new mail.
     * If the account name is empty, all accounts not excluded from manual
     * mail check will be checked.
     */
     Q_SCRIPTABLE void checkAccount(const QString &account);
 
     Q_SCRIPTABLE bool selectFolder(const QString &folder);
 
     Q_SCRIPTABLE bool canQueryClose();
 
     Q_SCRIPTABLE bool handleCommandLine(bool noArgsOpensReader, const QStringList &args, const QString &workingDir);
 
     /**
     * Opens a composer window and prefills it with different
     * message parts.
     *
     *
     * @param to A comma separated list of To addresses.
     * @param cc A comma separated list of CC addresses.
     * @param bcc A comma separated list of BCC addresses.
     * @param subject The message subject.
     * @param body The message body.
     * @param hidden Whether the composer window shall initially be hidden.
     * @param messageFile A message file that will be used as message body.
     * @param attachmentPaths A list of files that will be attached to the message.
     * @param customHeaders A list of custom headers.
     */
     Q_SCRIPTABLE void openComposer(const QString &to, const QString &cc, const QString &bcc, const QString &subject, const QString &body, bool hidden, const QString &messageFile,
                                    const QStringList &attachmentPaths, const QStringList &customHeaders, const QString &replyTo = QString(),
                                    const QString &inReplyTo = QString(), const QString &identity = QString());
 
     /**
     * Opens a composer window and prefills it with different
     * message parts.
     *
     * @param to A comma separated list of To addresses.
     * @param cc A comma separated list of CC addresses.
     * @param bcc A comma separated list of BCC addresses.
     * @param subject The message subject.
     * @param body The message body.
     * @param hidden Whether the composer window shall initially be hidden.
     * @param attachName The name of the attachment.
     * @param attachCte The content transfer encoding of the attachment.
     * @param attachData The raw data of the attachment.
     * @param attachType The mime type of the attachment.
     * @param attachSubType The sub mime type of the attachment.
     * @param attachParamAttr The parameter attribute of the attachment.
     * @param attachParamValue The parameter value of the attachment.
     * @param attachContDisp The content display type of the attachment.
     * @param attachCharset The charset of the attachment.
     * @param identity The identity identifier which will be used as sender identity.
     */
     Q_SCRIPTABLE void openComposer(const QString &to, const QString &cc, const QString &bcc, const QString &subject, const QString &body, bool hidden, const QString &attachName,
                                    const QByteArray &attachCte, const QByteArray &attachData, const QByteArray &attachType, const QByteArray &attachSubType, const QByteArray &attachParamAttr,
                                    const QString &attachParamValue, const QByteArray &attachContDisp, const QByteArray &attachCharset, unsigned int identity);
 
     /**
     * Opens a composer window and prefills it with different
     * message parts.
     * @since 5.0
     *
     * @param to A comma separated list of To addresses.
     * @param cc A comma separated list of CC addresses.
     * @param bcc A comma separated list of BCC addresses.
     * @param subject The message subject.
     * @param body The message body.
     * @param attachName The name of the attachment.
     * @param attachCte The content transfer encoding of the attachment.
     * @param attachData The raw data of the attachment.
     * @param attachType The mime type of the attachment.
     * @param attachSubType The sub mime type of the attachment.
     * @param attachParamAttr The parameter attribute of the attachment.
     * @param attachParamValue The parameter value of the attachment.
     * @param attachContDisp The content display type of the attachment.
     * @param attachCharset The charset of the attachment.
     * @param identity The identity identifier which will be used as sender identity.
     */
     Q_SCRIPTABLE void openComposer(const QString &to, const QString &cc, const QString &bcc, const QString &subject, const QString &body, const QString &attachName, const QByteArray &attachCte,
                                    const QByteArray &attachData, const QByteArray &attachType, const QByteArray &attachSubType, const QByteArray &attachParamAttr, const QString &attachParamValue,
                                    const QByteArray &attachContDisp, const QByteArray &attachCharset, unsigned int identity);
 
     /**
     * Opens a composer window and prefills it with different
     * message parts.
     *
     *
     * @param to A comma separated list of To addresses.
     * @param cc A comma separated list of CC addresses.
     * @param bcc A comma separated list of BCC addresses.
     * @param subject The message subject.
     * @param body The message body.
     * @param hidden Whether the composer window shall initially be hidden.
     */
     Q_SCRIPTABLE void openComposer(const QString &to, const QString &cc, const QString &bcc, const QString &subject, const QString &body, bool hidden);
 
     /**
     * Opens a composer window and prefills it with different
     * message parts.
     *
     * @returns The DBus object path for the composer.
     *
     * @param to A comma separated list of To addresses.
     * @param cc A comma separated list of CC addresses.
     * @param bcc A comma separated list of BCC addresses.
     * @param subject The message subject.
     * @param body The message body.
     * @param hidden Whether the composer window shall initially be hidden.
     * @param useFolderId The id of the folder whose associated identity will be used.
     * @param messageFile A message file that will be used as message body.
     * @param attachURL The URL to the file that will be attached to the message.
     */
     Q_SCRIPTABLE void newMessage(const QString &to, const QString &cc, const QString &bcc, bool hidden, bool useFolderId, const QString &messageFile, const QString &attachURL);
 
     Q_SCRIPTABLE bool showMail(qint64 serialNumber);
 
     Q_SCRIPTABLE int viewMessage(const QString &messageFile);
 
     Q_SCRIPTABLE void updateConfig();
 
     Q_SCRIPTABLE void showFolder(const QString &collectionId);
 
     Q_SCRIPTABLE void reloadFolderArchiveConfig();
 
     /**
     * End of D-Bus callable stuff
     */
 
 public:
     void checkMailOnStartup();
 
     /** A static helper function that asks the user
     * if they want to go online.
     * @return true if the user wants to go online
     * @return false if the user wants to stay offline
     */
     static bool askToGoOnline();
 
     /** Checks if the current network state is online or offline
     * @return true if the network state is offline
     * @return false if the network state is online
     */
     static bool isOffline();
 
     /** normal control stuff */
 
     static KMKernel *self();
     KSharedConfig::Ptr config() override;
     void syncConfig() override;
 
     void init();
     void setupDBus();
 
     void expunge(Akonadi::Collection::Id col, bool sync) override;
     Akonadi::ChangeRecorder *folderCollectionMonitor() const override;
 
     /**
     * Returns the main model, which contains all folders and the items of recently opened folders.
     */
     Akonadi::EntityTreeModel *entityTreeModel() const;
 
     /**
     * Returns a model of all folders in KMail. This is basically the same as entityTreeModel(),
     * but with items filtered out, the model contains only collections.
     */
     Akonadi::EntityMimeTypeFilterModel *collectionModel() const override;
 
     void recoverDeadLetters();
     void closeAllKMailWindows();
     void cleanup();
     void quit();
     bool doSessionManagement();
     bool firstInstance() const;
     void setFirstInstance(bool value);
     void action(bool mailto, bool check, const QString &to, const QString &cc, const QString &bcc, const QString &subj, const QString &body, const QUrl &messageFile, const QList<QUrl> &attach,
                 const QStringList &customHeaders, const QString &replyTo, const QString &inReplyTo, const QString &identity);
 
     //sets online status for akonadi accounts. true for online, false for offline
     void setAccountStatus(bool);
 
     const QString xmlGuiInstanceName() const;
     void setXmlGuiInstanceName(const QString &instance);
 
     KMail::UndoStack *undoStack() const;
     MessageComposer::MessageSender *msgSender() override;
 
     void openFilterDialog(bool createDummyFilter = true) override;
     void createFilter(const QByteArray &field, const QString &value) override;
 
     /** return the pointer to the identity manager */
     KIdentityManagement::IdentityManager *identityManager() override;
 
     MailCommon::JobScheduler *jobScheduler() const override;
 
     /** Expire all folders, used for the gui action */
     void expireAllFoldersNow();
 
     bool firstStart() const;
     bool shuttingDown() const;
     void setShuttingDown(bool flag);
 
     /** Returns true if we have a system tray applet. This is needed in order
     *  to know whether the application should be allowed to exit in case the
     *  last visible composer or separate message window is closed.
     */
     bool haveSystemTrayApplet() const;
 
     QTextCodec *networkCodec() const;
 
     /** returns a reference to the first Mainwin or a temporary Mainwin */
     KMainWindow *mainWin();
 
     /** Get first mainwidget */
     KMMainWidget *getKMMainWidget();
 
     /**
     * Returns a list of all currently loaded folders. Since folders are loaded async, this
     * is empty at startup.
     */
     Akonadi::Collection::List allFolders() const;
 
     /**
      * Includes all subfolders of @p col, including the @p col itself.
      */
     Akonadi::Collection::List subfolders(const Akonadi::Collection &col) const;
 
     //
     void selectCollectionFromId(Akonadi::Collection::Id id);
 
     void raise();
 
     void stopAgentInstance();
 
     //ISettings
     bool showPopupAfterDnD() override;
 
     bool excludeImportantMailFromExpiry() override;
 
     qreal closeToQuotaThreshold() override;
 
     Akonadi::Collection::Id lastSelectedFolder() override;
     void setLastSelectedFolder(Akonadi::Collection::Id col) override;
 
     QStringList customTemplates() override;
 
     void checkFolderFromResources(const Akonadi::Collection::List &collectionList);
 
     const QAbstractItemModel *treeviewModelSelection();
 
     void savePaneSelection();
 
     void updatePaneTagComboBox();
 
     PimCommon::AutoCorrection *composerAutoCorrection();
 
     void toggleSystemTray();
     FolderArchiveManager *folderArchiveManager() const;
 
     bool allowToDebug() const;
 
     Akonadi::Search::PIM::IndexedItems *indexedItems() const;
 
     void cleanupTemporaryFiles();
     MailCommon::MailCommonSettings *mailCommonSettings() const;
 
 protected:
     void agentInstanceBroken(const Akonadi::AgentInstance &instance);
 
 public Q_SLOTS:
 
     void updateSystemTray() override;
 
     /** Custom templates have changed, so all windows using them need
       to regenerate their menus */
     void updatedTemplates();
 
     /// Save contents of all open composer widnows to ~/dead.letter
     void dumpDeadLetters();
 
     /** Call this slot instead of directly KConfig::sync() to
       minimize the overall config writes. Calling this slot will
       schedule a sync of the application config file using a timer, so
       that many consecutive calls can be condensed into a single
       sync, which is more efficient. */
     void slotRequestConfigSync();
 
     /**
     * Sync the config immediatley
     */
     void slotSyncConfig();
 
     void slotShowConfigurationDialog();
     void slotRunBackgroundTasks();
 
     void slotConfigChanged();
-
 Q_SIGNALS:
     void configChanged();
     void onlineStatusChanged(KMailSettings::EnumNetworkState::type);
     void customTemplatesChanged();
 
     void startCheckMail();
     void endCheckMail();
 
+    void incomingAccountsChanged();
 private Q_SLOTS:
     /** Updates identities when a transport has been deleted. */
     void transportRemoved(int id, const QString &name);
     /** Updates identities when a transport has been renamed. */
     void transportRenamed(int id, const QString &oldName, const QString &newName);
     void itemDispatchStarted();
     void instanceStatusChanged(const Akonadi::AgentInstance &);
 
     void akonadiStateChanged(Akonadi::ServerManager::State);
     void slotProgressItemCompletedOrCanceled(KPIM::ProgressItem *item);
     void slotInstanceError(const Akonadi::AgentInstance &instance, const QString &message);
     void slotInstanceWarning(const Akonadi::AgentInstance &instance, const QString &message);
     void slotCollectionRemoved(const Akonadi::Collection &col);
     void slotDeleteIdentity(uint identity);
     void slotInstanceRemoved(const Akonadi::AgentInstance &);
+    void slotInstanceAdded(const Akonadi::AgentInstance &);
     void slotSystemNetworkStatusChanged(bool isOnline);
     void slotCollectionChanged(const Akonadi::Collection &, const QSet<QByteArray> &set);
 
     void slotCheckAccount(Akonadi::ServerManager::State state);
 private:
     void viewMessage(const QUrl &url);
     Akonadi::Collection currentCollection();
 
     /*
      * Fills a composer cWin
      *
     */
     void fillComposer(bool hidden, const QString &to, const QString &cc, const QString &bcc, const QString &subject, const QString &body, const QString &attachName, const QByteArray &attachCte,
                       const QByteArray &attachData, const QByteArray &attachType, const QByteArray &attachSubType, const QByteArray &attachParamAttr, const QString &attachParamValue,
                       const QByteArray &attachContDisp, const QByteArray &attachCharset, unsigned int identity, bool forceShowWindow);
 
     void verifyAccount();
     void resourceGoOnLine();
     void openReader(bool onlyCheck);
     QSharedPointer<MailCommon::FolderSettings> currentFolderCollection();
 
     KMail::UndoStack *the_undoStack = nullptr;
     MessageComposer::AkonadiSender *the_msgSender = nullptr;
     /** is this the first start?  read from config */
     bool the_firstStart = false;
     /** are we going down? set from here */
     bool the_shuttingDown = false;
     /** true unles kmail is closed by session management */
     bool the_firstInstance = false;
 
     KSharedConfig::Ptr mConfig;
     QTextCodec *mNetCodec = nullptr;
     QString mXmlGuiInstance;
     ConfigureDialog *mConfigureDialog = nullptr;
 
     QTimer *mBackgroundTasksTimer = nullptr;
     MailCommon::JobScheduler *mJobScheduler = nullptr;
     KMail::MailServiceImpl *mMailService = nullptr;
 
     bool mSystemNetworkStatus = true;
 
     KMail::UnityServiceManager *mUnityServiceManager = nullptr;
     QHash<QString, KPIM::ProgressItem::CryptoStatus> mResourceCryptoSettingCache;
     MailCommon::FolderCollectionMonitor *mFolderCollectionMonitor = nullptr;
     Akonadi::EntityTreeModel *mEntityTreeModel = nullptr;
     Akonadi::EntityMimeTypeFilterModel *mCollectionModel = nullptr;
 
     /// List of Akonadi resources that are currently being checked.
     QStringList mResourcesBeingChecked;
 
     QPointer<MailCommon::KMFilterDialog> mFilterEditDialog;
     PimCommon::AutoCorrection *mAutoCorrection = nullptr;
     FolderArchiveManager *mFolderArchiveManager = nullptr;
     CheckIndexingManager *mCheckIndexingManager = nullptr;
     Akonadi::Search::PIM::IndexedItems *mIndexedItems = nullptr;
     MailCommon::MailCommonSettings *mMailCommonSettings = nullptr;
     bool mDebug = false;
 };
 
 #endif // _KMKERNEL_H
diff --git a/src/kmmainwidget.cpp b/src/kmmainwidget.cpp
index 34333c71c..a3b5ce339 100644
--- a/src/kmmainwidget.cpp
+++ b/src/kmmainwidget.cpp
@@ -1,4702 +1,4755 @@
 /*
   This file is part of KMail, the KDE mail client.
   Copyright (c) 2002 Don Sanders <sanders@kde.org>
   Copyright (c) 2009-2018 Montel Laurent <montel@kde.org>
 
   Based on the work of Stefan Taferner <taferner@kde.org>
 
   KMail is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License, version 2, as
   published by the Free Software Foundation.
 
   KMail 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
 */
 
 // KMail includes
 #include "kmreadermainwin.h"
 #include "job/composenewmessagejob.h"
 #include "editor/composer.h"
 #include "searchdialog/searchwindow.h"
 #include "widgets/vacationscriptindicatorwidget.h"
 #include "undostack.h"
 #include "kmcommands.h"
 #include "kmmainwin.h"
 #include <TemplateParser/CustomTemplatesMenu>
 #include "MailCommon/FolderSelectionDialog"
 #include "MailCommon/FolderTreeWidget"
 #include "PimCommonAkonadi/MailUtil"
 #include "util.h"
 
 #include "mailcommon/mailutil.h"
 #include "mailcommon/mailkernel.h"
 #include "dialog/archivefolderdialog.h"
 #include "settings/kmailsettings.h"
 #include "MailCommon/FolderTreeView"
 #include "tag/tagactionmanager.h"
 #include "foldershortcutactionmanager.h"
 #include "widgets/collectionpane.h"
 #include "manageshowcollectionproperties.h"
 #include "widgets/kactionmenutransport.h"
 #include "widgets/kactionmenuaccount.h"
 #include "mailcommon/searchrulestatus.h"
 #include "plugininterface/kmailplugininterface.h"
 #include "PimCommon/NetworkUtil"
 #include "kpimtextedit/texttospeech.h"
 #include "job/markallmessagesasreadinfolderandsubfolderjob.h"
 #include "job/removeduplicatemessageinfolderandsubfolderjob.h"
 #include "sieveimapinterface/kmsieveimappasswordprovider.h"
 #include <KSieveUi/SieveDebugDialog>
 
 #include <AkonadiWidgets/CollectionMaintenancePage>
 #include "collectionpage/collectionquotapage.h"
 #include "collectionpage/collectiontemplatespage.h"
 #include "collectionpage/collectionshortcutpage.h"
 #include "collectionpage/collectionviewpage.h"
 #include "collectionpage/collectionmailinglistpage.h"
 #include "tag/tagselectdialog.h"
 #include "job/createnewcontactjob.h"
 #include "folderarchive/folderarchiveutil.h"
 #include "folderarchive/folderarchivemanager.h"
 
 #include <PimCommonAkonadi/CollectionAclPage>
 #include "PimCommon/PimUtil"
 #include "MailCommon/CollectionGeneralPage"
 #include "MailCommon/CollectionExpiryPage"
 #include "MailCommon/ExpireCollectionAttribute"
 #include "MailCommon/FilterManager"
 #include "MailCommon/MailFilter"
 #include "MailCommon/FavoriteCollectionWidget"
 #include "MailCommon/FavoriteCollectionOrderProxyModel"
 #include "MailCommon/FolderTreeWidget"
 #include "MailCommon/FolderTreeView"
 #include "mailcommonsettings_base.h"
 #include "kmmainwidget.h"
 
 // Other PIM includes
 #include "kmail-version.h"
 
 #include "messageviewer/messageviewersettings.h"
 #include "messageviewer/viewer.h"
 #include "messageviewer/headerstyleplugin.h"
 #include "messageviewer/headerstyle.h"
 
 #include <MessageViewer/AttachmentStrategy>
 
 #ifndef QT_NO_CURSOR
 #include "Libkdepim/KCursorSaver"
 #endif
 
 #include <MessageComposer/MessageSender>
 #include "MessageComposer/MessageHelper"
 
 #include <MessageCore/MessageCoreSettings>
 #include "MessageCore/MailingList"
 
 #include "dialog/kmknotify.h"
 #include "widgets/displaymessageformatactionmenu.h"
 
 #include "ksieveui/vacationmanager.h"
 #include "kmlaunchexternalcomponent.h"
 
 // LIBKDEPIM includes
 #include "libkdepim/progressmanager.h"
 #include "libkdepim/broadcaststatus.h"
 
 // KDEPIMLIBS includes
 #include <AkonadiCore/AgentManager>
 #include <AkonadiCore/AttributeFactory>
 #include <AkonadiCore/itemfetchjob.h>
 #include <AkonadiCore/collectionattributessynchronizationjob.h>
 #include <AkonadiCore/collectionfetchjob.h>
 #include <AkonadiCore/collectionfetchscope.h>
 #include <Akonadi/Contact/ContactSearchJob>
 #include <AkonadiWidgets/collectionpropertiesdialog.h>
 #include <AkonadiCore/entitydisplayattribute.h>
 #include <AkonadiWidgets/entitylistview.h>
 #include <AkonadiWidgets/etmviewstatesaver.h>
 #include <AkonadiCore/agentinstance.h>
 #include <AkonadiCore/agenttype.h>
 #include <AkonadiCore/changerecorder.h>
 #include <AkonadiCore/session.h>
 #include <AkonadiCore/entitytreemodel.h>
 #include <AkonadiCore/favoritecollectionsmodel.h>
 #include <AkonadiCore/itemfetchscope.h>
 #include <AkonadiCore/itemmodifyjob.h>
 #include <AkonadiWidgets/controlgui.h>
 #include <AkonadiWidgets/collectiondialog.h>
 #include <AkonadiCore/collectionstatistics.h>
 #include <AkonadiCore/EntityMimeTypeFilterModel>
 #include <Akonadi/KMime/MessageFlags>
 #include <AkonadiCore/CachePolicy>
 
 #include <kidentitymanagement/identity.h>
 #include <kidentitymanagement/identitymanager.h>
 #include <KEmailAddress>
 #include <mailtransport/transportmanager.h>
 #include <mailtransport/transport.h>
 #include <kmime/kmime_mdn.h>
 #include <kmime/kmime_header_parsing.h>
 #include <kmime/kmime_message.h>
 #include <ksieveui/managesievescriptsdialog.h>
 #include <ksieveui/util.h>
 
 #include <PimCommon/LogActivitiesManager>
 
 // KDELIBS includes
 #include <kwindowsystem.h>
 #include <kmessagebox.h>
 #include <kactionmenu.h>
 #include <QMenu>
 #include <kacceleratormanager.h>
 #include <kstandardshortcut.h>
 #include <kcharsets.h>
 #include "kmail_debug.h"
 #include <ktip.h>
 
 #include <kstandardaction.h>
 #include <ktoggleaction.h>
 #include <knotification.h>
 #include <knotifyconfigwidget.h>
 #include <kstringhandler.h>
 #include <kconfiggroup.h>
 #include <ktoolinvocation.h>
 #include <kxmlguifactory.h>
 #include <kxmlguiclient.h>
 #include <QStatusBar>
 #include <QAction>
 #include <KRecentFilesAction>
 
 // Qt includes
 #include <QByteArray>
 #include <QHeaderView>
 #include <QList>
 #include <QSplitter>
 #include <QVBoxLayout>
 #include <QShortcut>
 #include <QProcess>
 #include <WebEngineViewer/WebHitTestResult>
 // System includes
 #include <AkonadiWidgets/standardactionmanager.h>
 #include <QStandardPaths>
+#include <QDBusInterface>
+#include <QDBusConnection>
+#include <QDBusReply>
 
 #include "PimCommonAkonadi/ManageServerSideSubscriptionJob"
 #include <job/removeduplicatemailjob.h>
 #include <job/removecollectionjob.h>
 
 using namespace KMime;
 using namespace Akonadi;
 using namespace MailCommon;
 using KPIM::ProgressManager;
 using KPIM::BroadcastStatus;
 using KMail::SearchWindow;
 using KMime::Types::AddrSpecList;
 using MessageViewer::AttachmentStrategy;
 
 Q_GLOBAL_STATIC(KMMainWidget::PtrList, theMainWidgetList)
 
 //-----------------------------------------------------------------------------
 KMMainWidget::KMMainWidget(QWidget *parent, KXMLGUIClient *aGUIClient, KActionCollection *actionCollection, KSharedConfig::Ptr config)
     : QWidget(parent)
     , mManageShowCollectionProperties(new ManageShowCollectionProperties(this, this))
 {
     mLaunchExternalComponent = new KMLaunchExternalComponent(this, this);
     // must be the first line of the constructor:
     mStartupDone = false;
     mWasEverShown = false;
     mReaderWindowActive = true;
     mReaderWindowBelow = true;
     mFolderHtmlLoadExtPreference = false;
     mDestructed = false;
     mActionCollection = actionCollection;
     mTopLayout = new QVBoxLayout(this);
     mTopLayout->setMargin(0);
     mConfig = config;
     mGUIClient = aGUIClient;
     mFolderTreeWidget = nullptr;
     mPreferHtmlLoadExtAction = nullptr;
     Akonadi::ControlGui::widgetNeedsAkonadi(this);
     mFavoritesModel = nullptr;
     mSievePasswordProvider = new KMSieveImapPasswordProvider(winId());
     mVacationManager = new KSieveUi::VacationManager(mSievePasswordProvider, this);
     connect(mVacationManager, &KSieveUi::VacationManager::updateVacationScriptStatus, this, QOverload<bool, const QString &>::of(&KMMainWidget::updateVacationScriptStatus));
 
     mToolbarActionSeparator = new QAction(this);
     mToolbarActionSeparator->setSeparator(true);
 
     KMailPluginInterface::self()->setActionCollection(mActionCollection);
     KMailPluginInterface::self()->initializePlugins();
     KMailPluginInterface::self()->setMainWidget(this);
 
     theMainWidgetList->append(this);
 
     readPreConfig();
     createWidgets();
     setupActions();
 
     readConfig();
 
     if (!kmkernel->isOffline()) {   //kmail is set to online mode, make sure the agents are also online
         kmkernel->setAccountStatus(true);
     }
 
     QTimer::singleShot(0, this, &KMMainWidget::slotShowStartupFolder);
 
     connect(kmkernel, &KMKernel::startCheckMail,
             this, &KMMainWidget::slotStartCheckMail);
 
     connect(kmkernel, &KMKernel::endCheckMail,
             this, &KMMainWidget::slotEndCheckMail);
 
     connect(kmkernel, &KMKernel::configChanged,
             this, &KMMainWidget::slotConfigChanged);
 
     connect(kmkernel, &KMKernel::onlineStatusChanged,
             this, &KMMainWidget::slotUpdateOnlineStatus);
 
     connect(mTagActionManager, &KMail::TagActionManager::tagActionTriggered,
             this, &KMMainWidget::slotUpdateMessageTagList);
 
     connect(mTagActionManager, &KMail::TagActionManager::tagMoreActionClicked,
             this, &KMMainWidget::slotSelectMoreMessageTagList);
 
     kmkernel->toggleSystemTray();
 
     {
         // make sure the pages are registered only once, since there can be multiple instances of KMMainWidget
         static bool pagesRegistered = false;
 
         if (!pagesRegistered) {
             Akonadi::CollectionPropertiesDialog::registerPage(new PimCommon::CollectionAclPageFactory);
             Akonadi::CollectionPropertiesDialog::registerPage(new MailCommon::CollectionGeneralPageFactory);
             Akonadi::CollectionPropertiesDialog::registerPage(new CollectionMaintenancePageFactory);
             Akonadi::CollectionPropertiesDialog::registerPage(new CollectionQuotaPageFactory);
             Akonadi::CollectionPropertiesDialog::registerPage(new CollectionTemplatesPageFactory);
             Akonadi::CollectionPropertiesDialog::registerPage(new MailCommon::CollectionExpiryPageFactory);
             Akonadi::CollectionPropertiesDialog::registerPage(new CollectionViewPageFactory);
             Akonadi::CollectionPropertiesDialog::registerPage(new CollectionMailingListPageFactory);
             Akonadi::CollectionPropertiesDialog::registerPage(new CollectionShortcutPageFactory);
 
             pagesRegistered = true;
         }
     }
 
     KMainWindow *mainWin = qobject_cast<KMainWindow *>(window());
     QStatusBar *sb = mainWin ? mainWin->statusBar() : nullptr;
     mVacationScriptIndicator = new KMail::VacationScriptIndicatorWidget(sb);
     mVacationScriptIndicator->hide();
     connect(mVacationScriptIndicator, &KMail::VacationScriptIndicatorWidget::clicked, this, &KMMainWidget::slotEditVacation);
     if (KSieveUi::Util::checkOutOfOfficeOnStartup()) {
         QTimer::singleShot(0, this, &KMMainWidget::slotCheckVacation);
     }
 
     connect(mFolderTreeWidget->folderTreeView()->model(), &QAbstractItemModel::modelReset,
             this, &KMMainWidget::restoreCollectionFolderViewConfig);
     restoreCollectionFolderViewConfig();
 
     if (kmkernel->firstStart()) {
         const QStringList listOfMailerFound = MailCommon::Util::foundMailer();
         if (!listOfMailerFound.isEmpty()) {
             if (KMessageBox::questionYesNoList(this, i18n("Another mailer was found on system. Do you want to import data from it?"), listOfMailerFound) == KMessageBox::Yes) {
                 const QString path = QStandardPaths::findExecutable(QStringLiteral("akonadiimportwizard"));
                 if (!QProcess::startDetached(path)) {
                     KMessageBox::error(this, i18n("Could not start the import wizard. "
                                                   "Please check your installation."),
                                        i18n("Unable to start import wizard"));
                 }
             } else {
                 mLaunchExternalComponent->slotAccountWizard();
             }
         } else {
             mLaunchExternalComponent->slotAccountWizard();
         }
     }
     // must be the last line of the constructor:
     mStartupDone = true;
 
     mCheckMailTimer.setInterval(3 * 1000);
     mCheckMailTimer.setSingleShot(true);
     connect(&mCheckMailTimer, &QTimer::timeout, this, &KMMainWidget::slotUpdateActionsAfterMailChecking);
+
+    setupUnifiedMailboxChecker();
 }
 
 void KMMainWidget::restoreCollectionFolderViewConfig()
 {
     ETMViewStateSaver *saver = new ETMViewStateSaver;
     saver->setView(mFolderTreeWidget->folderTreeView());
     const KConfigGroup cfg(KMKernel::self()->config(), "CollectionFolderView");
     mFolderTreeWidget->restoreHeaderState(cfg.readEntry("HeaderState", QByteArray()));
     saver->restoreState(cfg);
     //Restore startup folder
 
     Akonadi::Collection::Id id = -1;
     if (mCurrentCollection.isValid()) {
         id = mCurrentCollection.id();
     }
 
     if (id == -1) {
         if (KMailSettings::self()->startSpecificFolderAtStartup()) {
             Akonadi::Collection::Id startupFolder = KMailSettings::self()->startupFolder();
             if (startupFolder > 0) {
                 saver->restoreCurrentItem(QStringLiteral("c%1").arg(startupFolder));
             }
         }
     } else {
         saver->restoreCurrentItem(QStringLiteral("c%1").arg(id));
     }
 }
 
 //-----------------------------------------------------------------------------
 //The kernel may have already been deleted when this method is called,
 //perform all cleanup that requires the kernel in destruct()
 KMMainWidget::~KMMainWidget()
 {
     theMainWidgetList->removeAll(this);
     qDeleteAll(mFilterCommands);
     destruct();
 }
 
 //-----------------------------------------------------------------------------
 //This method performs all cleanup that requires the kernel to exist.
 void KMMainWidget::destruct()
 {
     if (mDestructed) {
         return;
     }
     if (mSearchWin) {
         mSearchWin->close();
     }
     disconnect(mFolderTreeWidget->folderTreeView()->selectionModel(), &QItemSelectionModel::selectionChanged, this, &KMMainWidget::updateFolderMenu);
     writeConfig(false); /* don't force kmkernel sync when close BUG: 289287 */
     writeFolderConfig();
     deleteWidgets();
     clearCurrentFolder();
     delete mMoveOrCopyToDialog;
     delete mSelectFromAllFoldersDialog;
     delete mSievePasswordProvider;
 
     disconnect(kmkernel->folderCollectionMonitor(), SIGNAL(itemAdded(Akonadi::Item,Akonadi::Collection)), this, nullptr);
     disconnect(kmkernel->folderCollectionMonitor(), SIGNAL(itemRemoved(Akonadi::Item)), this, nullptr);
     disconnect(kmkernel->folderCollectionMonitor(), SIGNAL(itemMoved(Akonadi::Item,Akonadi::Collection,Akonadi::Collection)), this, nullptr);
     disconnect(kmkernel->folderCollectionMonitor(), SIGNAL(collectionChanged(Akonadi::Collection,QSet<QByteArray>)), this, nullptr);
     disconnect(kmkernel->folderCollectionMonitor(), SIGNAL(collectionStatisticsChanged(Akonadi::Collection::Id,Akonadi::CollectionStatistics)), this, nullptr);
 
     mDestructed = true;
 }
 
 void KMMainWidget::clearCurrentFolder()
 {
     mCurrentFolderSettings.clear();
     mCurrentCollection = Akonadi::Collection();
 }
 
 void KMMainWidget::slotStartCheckMail()
 {
     if (mCheckMailTimer.isActive()) {
         mCheckMailTimer.stop();
     }
 }
 
 void KMMainWidget::slotEndCheckMail()
 {
     if (!mCheckMailTimer.isActive()) {
         mCheckMailTimer.start();
     }
 }
 
 void KMMainWidget::slotUpdateActionsAfterMailChecking()
 {
     const bool sendOnAll
         = KMailSettings::self()->sendOnCheck() == KMailSettings::EnumSendOnCheck::SendOnAllChecks;
     const bool sendOnManual
         = KMailSettings::self()->sendOnCheck() == KMailSettings::EnumSendOnCheck::SendOnManualChecks;
     if (!kmkernel->isOffline() && (sendOnAll || sendOnManual)) {
         slotSendQueued();
     }
     // update folder menus in case some mail got filtered to trash/current folder
     // and we can enable "empty trash/move all to trash" action etc.
     updateFolderMenu();
 }
 
 void KMMainWidget::setCurrentCollection(const Akonadi::Collection &col)
 {
     mCurrentCollection = col;
     if (mCurrentFolderSettings) {
         mCurrentFolderSettings->setCollection(col);
     }
 }
 
 void KMMainWidget::slotCollectionFetched(int collectionId)
 {
     // Called when a collection is fetched for the first time by the ETM.
     // This is the right time to update the caption (which still says "Loading...")
     // and to update the actions that depend on the number of mails in the folder.
     if (collectionId == mCurrentCollection.id()) {
         setCurrentCollection(CommonKernel->collectionFromId(mCurrentCollection.id()));
         updateMessageActions();
         updateFolderMenu();
     }
     // We call this for any collection, it could be one of our parents...
     if (mCurrentCollection.isValid()) {
         Q_EMIT captionChangeRequest(fullCollectionPath());
     }
 }
 
 QString KMMainWidget::fullCollectionPath() const
 {
     if (mCurrentCollection.isValid()) {
         return MailCommon::Util::fullCollectionPath(mCurrentCollection);
     }
     return {};
 }
 
 // Connected to the currentChanged signals from the folderTreeView and favorites view.
 void KMMainWidget::slotFolderChanged(const Akonadi::Collection &collection)
 {
     if (mCurrentCollection == collection)
         return;
     folderSelected(collection);
     if (collection.cachePolicy().syncOnDemand()) {
         AgentManager::self()->synchronizeCollection(collection, false);
     }
     mMsgActions->setCurrentMessage(Akonadi::Item());
     Q_EMIT captionChangeRequest(MailCommon::Util::fullCollectionPath(collection));
 }
 
 // Called by slotFolderChanged (no particular reason for this method to be split out)
 void KMMainWidget::folderSelected(const Akonadi::Collection &col)
 {
     if (mGoToFirstUnreadMessageInSelectedFolder) {
         // the default action has been overridden from outside
         mPreSelectionMode = MessageList::Core::PreSelectFirstUnreadCentered;
     } else {
         // use the default action
         switch (KMailSettings::self()->actionEnterFolder()) {
         case KMailSettings::EnumActionEnterFolder::SelectFirstUnread:
             mPreSelectionMode = MessageList::Core::PreSelectFirstUnreadCentered;
             break;
         case KMailSettings::EnumActionEnterFolder::SelectLastSelected:
             mPreSelectionMode = MessageList::Core::PreSelectLastSelected;
             break;
         case KMailSettings::EnumActionEnterFolder::SelectNewest:
             mPreSelectionMode = MessageList::Core::PreSelectNewestCentered;
             break;
         case KMailSettings::EnumActionEnterFolder::SelectOldest:
             mPreSelectionMode = MessageList::Core::PreSelectOldestCentered;
             break;
         default:
             mPreSelectionMode = MessageList::Core::PreSelectNone;
             break;
         }
     }
 
     mGoToFirstUnreadMessageInSelectedFolder = false;
 #ifndef QT_NO_CURSOR
     KPIM::KCursorSaver busy(KPIM::KBusyPtr::busy());
 #endif
 
     if (mMsgView) {
         mMsgView->clear(true);
     }
     const bool newFolder = mCurrentCollection != col;
 
     // Delete any pending timer, if needed it will be recreated below
     delete mShowBusySplashTimer;
     mShowBusySplashTimer = nullptr;
     if (newFolder) {
         // We're changing folder: write configuration for the old one
         writeFolderConfig();
     }
 
     mCurrentFolderSettings = FolderSettings::forCollection(col);
     mCurrentCollection = col;
 
     readFolderConfig();
     if (mMsgView) {
         mMsgView->setDisplayFormatMessageOverwrite(mFolderDisplayFormatPreference);
         mMsgView->setHtmlLoadExtDefault(mFolderHtmlLoadExtPreference);
     }
 
     if (!mCurrentFolderSettings->isValid() && (mMessagePane->count() < 2)) {
         slotIntro();
     } else {
         if (mMessagePane->isHidden()) {
             mMessagePane->show();
         }
     }
 
     // The message pane uses the selection model of the folder view to load the correct aggregation model and theme
     //  settings. At this point the selection model hasn't been updated yet to the user's new choice, so it would load
     //  the old folder settings instead.
     QTimer::singleShot(0, this, &KMMainWidget::slotShowSelectedFolderInPane);
 }
 
 void KMMainWidget::slotShowSelectedFolderInPane()
 {
     if (mCurrentCollection.isValid()) {
         QModelIndex idx = Akonadi::EntityTreeModel::modelIndexForCollection(KMKernel::self()->entityTreeModel(), mCurrentCollection);
         mMessagePane->setCurrentFolder(mCurrentCollection, idx, false, mPreSelectionMode);
     }
     updateMessageActions();
     updateFolderMenu();
 }
 
 void KMMainWidget::clearViewer()
 {
     if (mMsgView) {
         mMsgView->clear(true);
         mMsgView->displayAboutPage();
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::readPreConfig()
 {
     mLongFolderList = KMailSettings::self()->folderList() == KMailSettings::EnumFolderList::longlist;
     mReaderWindowActive = KMailSettings::self()->readerWindowMode() != KMailSettings::EnumReaderWindowMode::hide;
     mReaderWindowBelow = KMailSettings::self()->readerWindowMode() == KMailSettings::EnumReaderWindowMode::below;
 
     mHtmlGlobalSetting = MessageViewer::MessageViewerSettings::self()->htmlMail();
     mHtmlLoadExtGlobalSetting = MessageViewer::MessageViewerSettings::self()->htmlLoadExternal();
 
     mEnableFavoriteFolderView = (KMKernel::self()->mailCommonSettings()->favoriteCollectionViewMode() != MailCommon::MailCommonSettings::EnumFavoriteCollectionViewMode::HiddenMode);
     mEnableFolderQuickSearch = KMailSettings::self()->enableFolderQuickSearch();
 
     readFolderConfig();
     updateHtmlMenuEntry();
     if (mMsgView) {
         mMsgView->setDisplayFormatMessageOverwrite(mFolderDisplayFormatPreference);
         mMsgView->update(true);
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::readFolderConfig()
 {
     if (!mCurrentCollection.isValid()) {
         return;
     }
     KSharedConfig::Ptr config = KMKernel::self()->config();
     KConfigGroup group(config, MailCommon::FolderSettings::configGroupName(mCurrentCollection));
     if (group.hasKey("htmlMailOverride")) {
         const bool useHtml = group.readEntry("htmlMailOverride", false);
         mFolderDisplayFormatPreference = useHtml ? MessageViewer::Viewer::Html : MessageViewer::Viewer::Text;
         group.deleteEntry("htmlMailOverride");
         group.sync();
     } else {
         mFolderDisplayFormatPreference = static_cast<MessageViewer::Viewer::DisplayFormatMessage>(group.readEntry("displayFormatOverride", static_cast<int>(MessageViewer::Viewer::UseGlobalSetting)));
     }
     mFolderHtmlLoadExtPreference
         = group.readEntry("htmlLoadExternalOverride", false);
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::writeFolderConfig()
 {
     if (mCurrentCollection.isValid()) {
         KSharedConfig::Ptr config = KMKernel::self()->config();
         KConfigGroup group(config, MailCommon::FolderSettings::configGroupName(mCurrentCollection));
         group.writeEntry("htmlLoadExternalOverride", mFolderHtmlLoadExtPreference);
         if (mFolderDisplayFormatPreference == MessageViewer::Viewer::UseGlobalSetting) {
             group.deleteEntry("displayFormatOverride");
         } else {
             group.writeEntry("displayFormatOverride", static_cast<int>(mFolderDisplayFormatPreference));
         }
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::layoutSplitters()
 {
     // This function can only be called when the old splitters are already deleted
     Q_ASSERT(!mSplitter1);
     Q_ASSERT(!mSplitter2);
 
     // For some reason, this is necessary here so that the copy action still
     // works after changing the folder layout.
     if (mMsgView) {
         disconnect(mMsgView->copyAction(), &QAction::triggered,
                    mMsgView, &KMReaderWin::slotCopySelectedText);
     }
 
     // If long folder list is enabled, the splitters are:
     // Splitter 1: FolderView vs (HeaderAndSearch vs MessageViewer)
     // Splitter 2: HeaderAndSearch vs MessageViewer
     //
     // If long folder list is disabled, the splitters are:
     // Splitter 1: (FolderView vs HeaderAndSearch) vs MessageViewer
     // Splitter 2: FolderView vs HeaderAndSearch
 
     // The folder view is both the folder tree and the favorite folder view, if
     // enabled
 
     const bool readerWindowAtSide = !mReaderWindowBelow && mReaderWindowActive;
     const bool readerWindowBelow = mReaderWindowBelow && mReaderWindowActive;
 
     mSplitter1 = new QSplitter(this);
     mSplitter2 = new QSplitter(mSplitter1);
 
     QWidget *folderTreeWidget = mFolderTreeWidget;
     if (mFavoriteCollectionsView) {
         mFolderViewSplitter = new QSplitter(Qt::Vertical);
         mFolderViewSplitter->setChildrenCollapsible(false);
         mFolderViewSplitter->addWidget(mFavoriteCollectionsView);
         mFolderViewSplitter->addWidget(mFolderTreeWidget);
         folderTreeWidget = mFolderViewSplitter;
     }
 
     if (mLongFolderList) {
         // add folder tree
         mSplitter1->setOrientation(Qt::Horizontal);
         mSplitter1->addWidget(folderTreeWidget);
 
         // and the rest to the right
         mSplitter1->addWidget(mSplitter2);
 
         // add the message list to the right or below
         if (readerWindowAtSide) {
             mSplitter2->setOrientation(Qt::Horizontal);
         } else {
             mSplitter2->setOrientation(Qt::Vertical);
         }
         mSplitter2->addWidget(mMessagePane);
 
         // add the preview window, if there is one
         if (mMsgView) {
             mSplitter2->addWidget(mMsgView);
         }
     } else { // short folder list
         if (mReaderWindowBelow) {
             mSplitter1->setOrientation(Qt::Vertical);
             mSplitter2->setOrientation(Qt::Horizontal);
         } else { // at side or none
             mSplitter1->setOrientation(Qt::Horizontal);
             mSplitter2->setOrientation(Qt::Vertical);
         }
 
         mSplitter1->addWidget(mSplitter2);
 
         // add folder tree
         mSplitter2->addWidget(folderTreeWidget);
         // add message list to splitter 2
         mSplitter2->addWidget(mMessagePane);
 
         // add the preview window, if there is one
         if (mMsgView) {
             mSplitter1->addWidget(mMsgView);
         }
     }
 
     //
     // Set splitter properties
     //
     mSplitter1->setObjectName(QStringLiteral("splitter1"));
     mSplitter1->setChildrenCollapsible(false);
     mSplitter2->setObjectName(QStringLiteral("splitter2"));
     mSplitter2->setChildrenCollapsible(false);
 
     //
     // Set the stretch factors
     //
     mSplitter1->setStretchFactor(0, 0);
     mSplitter2->setStretchFactor(0, 0);
     mSplitter1->setStretchFactor(1, 1);
     mSplitter2->setStretchFactor(1, 1);
 
     if (mFavoriteCollectionsView) {
         mFolderViewSplitter->setStretchFactor(0, 0);
         mFolderViewSplitter->setStretchFactor(1, 1);
     }
 
     // Because the reader windows's width increases a tiny bit after each
     // restart in short folder list mode with message window at side, disable
     // the stretching as a workaround here
     if (readerWindowAtSide && !mLongFolderList) {
         mSplitter1->setStretchFactor(0, 1);
         mSplitter1->setStretchFactor(1, 0);
     }
 
     //
     // Set the sizes of the splitters to the values stored in the config
     //
     QList<int> splitter1Sizes;
     QList<int> splitter2Sizes;
 
     const int folderViewWidth = KMailSettings::self()->folderViewWidth();
     int ftHeight = KMailSettings::self()->folderTreeHeight();
     int headerHeight = KMailSettings::self()->searchAndHeaderHeight();
     const int messageViewerWidth = KMailSettings::self()->readerWindowWidth();
     int headerWidth = KMailSettings::self()->searchAndHeaderWidth();
     int messageViewerHeight = KMailSettings::self()->readerWindowHeight();
 
     int ffvHeight = mFolderViewSplitter ? KMKernel::self()->mailCommonSettings()->favoriteCollectionViewHeight() : 0;
 
     // If the message viewer was hidden before, make sure it is not zero height
     if (messageViewerHeight < 10 && readerWindowBelow) {
         headerHeight /= 2;
         messageViewerHeight = headerHeight;
     }
 
     if (mLongFolderList) {
         if (!readerWindowAtSide) {
             splitter1Sizes << folderViewWidth << headerWidth;
             splitter2Sizes << headerHeight << messageViewerHeight;
         } else {
             splitter1Sizes << folderViewWidth << (headerWidth + messageViewerWidth);
             splitter2Sizes << headerWidth << messageViewerWidth;
         }
     } else {
         if (!readerWindowAtSide) {
             splitter1Sizes << headerHeight << messageViewerHeight;
             splitter2Sizes << folderViewWidth << headerWidth;
         } else {
             splitter1Sizes << headerWidth << messageViewerWidth;
             splitter2Sizes << ftHeight + ffvHeight << messageViewerHeight;
         }
     }
 
     mSplitter1->setSizes(splitter1Sizes);
     mSplitter2->setSizes(splitter2Sizes);
 
     if (mFolderViewSplitter) {
         QList<int> splitterSizes;
         splitterSizes << ffvHeight << ftHeight;
         mFolderViewSplitter->setSizes(splitterSizes);
     }
 
     //
     // Now add the splitters to the main layout
     //
     mTopLayout->addWidget(mSplitter1);
 
     // Make sure the focus is on the view, and not on the quick search line edit, because otherwise
     // shortcuts like + or j go to the wrong place.
     // This would normally be done in the message list itself, but apparently something resets the focus
     // again, probably all the reparenting we do here.
     mMessagePane->focusView();
 
     // By default hide th unread and size columns on first run.
     if (kmkernel->firstStart()) {
         mFolderTreeWidget->folderTreeView()->hideColumn(1);
         mFolderTreeWidget->folderTreeView()->hideColumn(3);
         mFolderTreeWidget->folderTreeView()->header()->resizeSection(0, folderViewWidth * 0.8);
     }
 
     // Make the copy action work, see disconnect comment above
     if (mMsgView) {
         connect(mMsgView->copyAction(), &QAction::triggered,
                 mMsgView, &KMReaderWin::slotCopySelectedText);
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::refreshFavoriteFoldersViewProperties()
 {
     if (mFavoriteCollectionsView) {
         if (KMKernel::self()->mailCommonSettings()->favoriteCollectionViewMode() == MailCommon::MailCommonSettings::EnumFavoriteCollectionViewMode::IconMode) {
             mFavoriteCollectionsView->changeViewMode(QListView::IconMode);
         } else if (KMKernel::self()->mailCommonSettings()->favoriteCollectionViewMode() == MailCommon::MailCommonSettings::EnumFavoriteCollectionViewMode::ListMode) {
             mFavoriteCollectionsView->changeViewMode(QListView::ListMode);
         } else {
             Q_ASSERT(false);    // we should never get here in hidden mode
         }
         mFavoriteCollectionsView->setDropActionMenuEnabled(kmkernel->showPopupAfterDnD());
         mFavoriteCollectionsView->setWordWrap(true);
         mFavoriteCollectionsView->updateMode();
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::readConfig()
 {
     const bool oldLongFolderList = mLongFolderList;
     const bool oldReaderWindowActive = mReaderWindowActive;
     const bool oldReaderWindowBelow = mReaderWindowBelow;
     const bool oldFavoriteFolderView = mEnableFavoriteFolderView;
     const bool oldFolderQuickSearch = mEnableFolderQuickSearch;
 
     // on startup, the layout is always new and we need to relayout the widgets
     bool layoutChanged = !mStartupDone;
 
     if (mStartupDone) {
         readPreConfig();
 
         layoutChanged = (oldLongFolderList != mLongFolderList)
                         || (oldReaderWindowActive != mReaderWindowActive)
                         || (oldReaderWindowBelow != mReaderWindowBelow)
                         || (oldFavoriteFolderView != mEnableFavoriteFolderView);
 
         if (layoutChanged) {
             deleteWidgets();
             createWidgets();
             restoreCollectionFolderViewConfig();
             Q_EMIT recreateGui();
         } else if (oldFolderQuickSearch != mEnableFolderQuickSearch) {
             if (mEnableFolderQuickSearch) {
                 mFolderTreeWidget->filterFolderLineEdit()->show();
             } else {
                 mFolderTreeWidget->filterFolderLineEdit()->hide();
             }
         }
     }
 
     {
         // Read the config of the folder views and the header
         if (mMsgView) {
             mMsgView->readConfig();
         }
         mMessagePane->reloadGlobalConfiguration();
         mFolderTreeWidget->readConfig();
         if (mFavoriteCollectionsView) {
             mFavoriteCollectionsView->readConfig();
         }
         refreshFavoriteFoldersViewProperties();
     }
 
     {
         // area for config group "General"
         if (!mStartupDone) {
             // check mail on startup
             // do it after building the kmmainwin, so that the progressdialog is available
             QTimer::singleShot(0, this, &KMMainWidget::slotCheckMailOnStartup);
         }
     }
 
     if (layoutChanged) {
         layoutSplitters();
     }
 
     updateMessageMenu();
     updateFileMenu();
     kmkernel->toggleSystemTray();
     mAccountActionMenu->setAccountOrder(KMKernel::self()->mailCommonSettings()->order());
 
     connect(Akonadi::AgentManager::self(), &AgentManager::instanceAdded,
             this, &KMMainWidget::updateFileMenu);
     connect(Akonadi::AgentManager::self(), &AgentManager::instanceRemoved,
             this, &KMMainWidget::updateFileMenu);
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::writeConfig(bool force)
 {
     // Don't save the sizes of all the widgets when we were never shown.
     // This can happen in Kontact, where the KMail plugin is automatically
     // loaded, but not necessarily shown.
     // This prevents invalid sizes from being saved
     if (mWasEverShown) {
         // The height of the header widget can be 0, this happens when the user
         // did not switch to the header widget onced and the "Welcome to KMail"
         // HTML widget was shown the whole time
         int headersHeight = mMessagePane->height();
         if (headersHeight == 0) {
             headersHeight = height() / 2;
         }
 
         KMailSettings::self()->setSearchAndHeaderHeight(headersHeight);
         KMailSettings::self()->setSearchAndHeaderWidth(mMessagePane->width());
         if (mFavoriteCollectionsView) {
             KMKernel::self()->mailCommonSettings()->setFavoriteCollectionViewHeight(mFavoriteCollectionsView->height());
             KMailSettings::self()->setFolderTreeHeight(mFolderTreeWidget->height());
             if (!mLongFolderList) {
                 KMailSettings::self()->setFolderViewHeight(mFolderViewSplitter->height());
             }
         } else if (!mLongFolderList && mFolderTreeWidget) {
             KMailSettings::self()->setFolderTreeHeight(mFolderTreeWidget->height());
         }
         if (mFolderTreeWidget) {
             KMailSettings::self()->setFolderViewWidth(mFolderTreeWidget->width());
             KSharedConfig::Ptr config = KMKernel::self()->config();
             KConfigGroup group(config, "CollectionFolderView");
 
             ETMViewStateSaver saver;
             saver.setView(mFolderTreeWidget->folderTreeView());
             saver.saveState(group);
 
             group.writeEntry("HeaderState", mFolderTreeWidget->folderTreeView()->header()->saveState());
             //Work around from startup folder
             group.deleteEntry("Selection");
 #if 0
             if (!KMailSettings::self()->startSpecificFolderAtStartup()) {
                 group.deleteEntry("Current");
             }
 #endif
             group.sync();
         }
 
         if (mMsgView) {
             if (!mReaderWindowBelow) {
                 KMailSettings::self()->setReaderWindowWidth(mMsgView->width());
             }
             mMsgView->viewer()->writeConfig(force);
             KMailSettings::self()->setReaderWindowHeight(mMsgView->height());
         }
     }
 }
 
 void KMMainWidget::writeReaderConfig()
 {
     if (mWasEverShown) {
         if (mMsgView) {
             mMsgView->viewer()->writeConfig();
         }
     }
 }
 
 KMReaderWin *KMMainWidget::messageView() const
 {
     return mMsgView;
 }
 
 CollectionPane *KMMainWidget::messageListPane() const
 {
     return mMessagePane;
 }
 
 Collection KMMainWidget::currentCollection() const
 {
     return mCurrentCollection;
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::deleteWidgets()
 {
     // Simply delete the top splitter, which always is mSplitter1, regardless
     // of the layout. This deletes all children.
     // akonadi action manager is created in createWidgets(), parented to this
     //  so not autocleaned up.
     delete mAkonadiStandardActionManager;
     mAkonadiStandardActionManager = nullptr;
     delete mSplitter1;
     mMsgView = nullptr;
     mFolderViewSplitter = nullptr;
     mFavoriteCollectionsView = nullptr;
     mFolderTreeWidget = nullptr;
     mSplitter1 = nullptr;
     mSplitter2 = nullptr;
     mFavoritesModel = nullptr;
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::createWidgets()
 {
     // Note that all widgets we create in this function have the parent 'this'.
     // They will be properly reparented in layoutSplitters()
 
     //
     // Create the folder tree
     //
     FolderTreeWidget::TreeViewOptions opt = FolderTreeWidget::ShowUnreadCount;
     opt |= FolderTreeWidget::UseLineEditForFiltering;
     opt |= FolderTreeWidget::ShowCollectionStatisticAnimation;
     opt |= FolderTreeWidget::DontKeyFilter;
     mFolderTreeWidget = new FolderTreeWidget(this, mGUIClient, opt);
 
     connect(mFolderTreeWidget->folderTreeView(), QOverload<const Akonadi::Collection &>::of(&EntityTreeView::currentChanged), this, &KMMainWidget::slotFolderChanged);
 
     connect(mFolderTreeWidget->folderTreeView()->selectionModel(), &QItemSelectionModel::selectionChanged, this, &KMMainWidget::updateFolderMenu);
 
     connect(mFolderTreeWidget->folderTreeView(), &FolderTreeView::newTabRequested, this, &KMMainWidget::slotCreateNewTab);
 
     //
     // Create the message pane
     //
     mMessagePane = new CollectionPane(!KMailSettings::self()->startSpecificFolderAtStartup(), KMKernel::self()->entityTreeModel(),
                                       mFolderTreeWidget->folderTreeView()->selectionModel(),
                                       this);
     connect(KMKernel::self()->entityTreeModel(), &Akonadi::EntityTreeModel::collectionFetched, this, &KMMainWidget::slotCollectionFetched);
 
     mMessagePane->setXmlGuiClient(mGUIClient);
     connect(mMessagePane, &MessageList::Pane::messageSelected,
             this, &KMMainWidget::slotMessageSelected);
     connect(mMessagePane, &MessageList::Pane::selectionChanged,
             this, &KMMainWidget::startUpdateMessageActionsTimer);
     connect(mMessagePane, &CollectionPane::currentTabChanged, this, &KMMainWidget::refreshMessageListSelection);
     connect(mMessagePane, &MessageList::Pane::messageActivated,
             this, &KMMainWidget::slotMessageActivated);
     connect(mMessagePane, &MessageList::Pane::messageStatusChangeRequest,
             this, &KMMainWidget::slotMessageStatusChangeRequest);
 
     connect(mMessagePane, &MessageList::Pane::statusMessage,
             this, &KMMainWidget::showMessageActivities);
 
     connect(mMessagePane, &MessageList::Pane::forceLostFocus,
             this, &KMMainWidget::slotSetFocusToViewer);
 
     //
     // Create the reader window
     //
     if (mReaderWindowActive) {
         mMsgView = new KMReaderWin(this, this, actionCollection());
         if (mMsgActions) {
             mMsgActions->setMessageView(mMsgView);
         }
         connect(mMsgView->viewer(), &MessageViewer::Viewer::displayPopupMenu, this, &KMMainWidget::slotMessagePopup);
         connect(mMsgView->viewer(), &MessageViewer::Viewer::moveMessageToTrash,
                 this, &KMMainWidget::slotMoveMessageToTrash);
         connect(mMsgView->viewer(), &MessageViewer::Viewer::pageIsScrolledToBottom,
                 this, &KMMainWidget::slotPageIsScrolledToBottom);
         connect(mMsgView->viewer(), &MessageViewer::Viewer::replyMessageTo,
                 this, &KMMainWidget::slotReplyMessageTo);
         if (mShowIntroductionAction) {
             mShowIntroductionAction->setEnabled(true);
         }
     } else {
         if (mMsgActions) {
             mMsgActions->setMessageView(nullptr);
         }
         if (mShowIntroductionAction) {
             mShowIntroductionAction->setEnabled(false);
         }
     }
     if (!KMailSettings::self()->enableFolderQuickSearch()) {
         mFolderTreeWidget->filterFolderLineEdit()->hide();
     }
 
     //
     // Create the favorite folder view
     //
     mAkonadiStandardActionManager = new Akonadi::StandardMailActionManager(mGUIClient->actionCollection(), this);
     connect(mAkonadiStandardActionManager, &Akonadi::StandardMailActionManager::actionStateUpdated, this, &KMMainWidget::slotAkonadiStandardActionUpdated);
 
     mAkonadiStandardActionManager->setCollectionSelectionModel(mFolderTreeWidget->folderTreeView()->selectionModel());
     mAkonadiStandardActionManager->setItemSelectionModel(mMessagePane->currentItemSelectionModel());
 
     if (mEnableFavoriteFolderView) {
         mFavoriteCollectionsView = new FavoriteCollectionWidget(KMKernel::self()->mailCommonSettings(), mGUIClient, this);
         refreshFavoriteFoldersViewProperties();
         connect(mFavoriteCollectionsView, QOverload<const Akonadi::Collection &>::of(&EntityListView::currentChanged), this, &KMMainWidget::slotFolderChanged);
         connect(mFavoriteCollectionsView, &FavoriteCollectionWidget::newTabRequested, this, &KMMainWidget::slotCreateNewTab);
         mFavoritesModel = new Akonadi::FavoriteCollectionsModel(
             mFolderTreeWidget->folderTreeWidgetProxyModel(),
             KMKernel::self()->config()->group("FavoriteCollections"), mFavoriteCollectionsView);
 
         auto *orderProxy = new MailCommon::FavoriteCollectionOrderProxyModel(this);
         orderProxy->setOrderConfig(KMKernel::self()->config()->group("FavoriteCollectionsOrder"));
         orderProxy->setSourceModel(mFavoritesModel);
         orderProxy->sort(0, Qt::AscendingOrder);
 
         mFavoriteCollectionsView->setModel(orderProxy);
 
         mAkonadiStandardActionManager->setFavoriteCollectionsModel(mFavoritesModel);
         mAkonadiStandardActionManager->setFavoriteSelectionModel(mFavoriteCollectionsView->selectionModel());
     }
 
     //Don't use mMailActionManager->createAllActions() to save memory by not
     //creating actions that doesn't make sense.
     const auto standardActions = {
         StandardActionManager::CreateCollection,
         StandardActionManager::CopyCollections,
         StandardActionManager::DeleteCollections,
         StandardActionManager::SynchronizeCollections,
         StandardActionManager::CollectionProperties,
         StandardActionManager::CopyItems,
         StandardActionManager::Paste,
         StandardActionManager::DeleteItems,
         StandardActionManager::ManageLocalSubscriptions,
         StandardActionManager::CopyCollectionToMenu,
         StandardActionManager::CopyItemToMenu,
         StandardActionManager::MoveItemToMenu,
         StandardActionManager::MoveCollectionToMenu,
         StandardActionManager::CutItems,
         StandardActionManager::CutCollections,
         StandardActionManager::CreateResource,
         StandardActionManager::DeleteResources,
         StandardActionManager::ResourceProperties,
         StandardActionManager::SynchronizeResources,
         StandardActionManager::ToggleWorkOffline,
         StandardActionManager::SynchronizeCollectionsRecursive,
     };
 
     for (StandardActionManager::Type standardAction : standardActions) {
         mAkonadiStandardActionManager->createAction(standardAction);
     }
 
     if (mEnableFavoriteFolderView) {
         const auto favoriteActions = {
             StandardActionManager::AddToFavoriteCollections,
             StandardActionManager::RemoveFromFavoriteCollections,
             StandardActionManager::RenameFavoriteCollection,
             StandardActionManager::SynchronizeFavoriteCollections,
         };
         for (StandardActionManager::Type favoriteAction : favoriteActions) {
             mAkonadiStandardActionManager->createAction(favoriteAction);
         }
     }
 
     const auto mailActions = {
         StandardMailActionManager::MarkAllMailAsRead,
         StandardMailActionManager::MoveToTrash,
         StandardMailActionManager::MoveAllToTrash,
         StandardMailActionManager::RemoveDuplicates,
         StandardMailActionManager::EmptyAllTrash,
         StandardMailActionManager::MarkMailAsRead,
         StandardMailActionManager::MarkMailAsUnread,
         StandardMailActionManager::MarkMailAsImportant,
         StandardMailActionManager::MarkMailAsActionItem
     };
 
     for (StandardMailActionManager::Type mailAction : mailActions) {
         mAkonadiStandardActionManager->createAction(mailAction);
     }
 
     mAkonadiStandardActionManager->interceptAction(Akonadi::StandardActionManager::CollectionProperties);
     connect(mAkonadiStandardActionManager->action(
                 Akonadi::StandardActionManager::CollectionProperties), &QAction::triggered, mManageShowCollectionProperties, &ManageShowCollectionProperties::slotCollectionProperties);
 
     //
     // Create all kinds of actions
     //
     mAkonadiStandardActionManager->action(Akonadi::StandardMailActionManager::RemoveDuplicates)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Asterisk));
     mAkonadiStandardActionManager->interceptAction(Akonadi::StandardMailActionManager::RemoveDuplicates);
     connect(mAkonadiStandardActionManager->action(Akonadi::StandardMailActionManager::RemoveDuplicates), &QAction::triggered, this, &KMMainWidget::slotRemoveDuplicates);
 
     mCollectionProperties = mAkonadiStandardActionManager->action(Akonadi::StandardActionManager::CollectionProperties);
     connect(kmkernel->folderCollectionMonitor(), &Monitor::collectionRemoved,
             this, &KMMainWidget::slotCollectionRemoved);
     connect(kmkernel->folderCollectionMonitor(), &Monitor::itemAdded,
             this, &KMMainWidget::slotItemAdded);
     connect(kmkernel->folderCollectionMonitor(), &Monitor::itemRemoved,
             this, &KMMainWidget::slotItemRemoved);
     connect(kmkernel->folderCollectionMonitor(), &Monitor::itemMoved,
             this, &KMMainWidget::slotItemMoved);
     connect(kmkernel->folderCollectionMonitor(), QOverload<const Akonadi::Collection &, const QSet<QByteArray> &>::of(&ChangeRecorder::collectionChanged),
             this, &KMMainWidget::slotCollectionChanged);
 
     connect(kmkernel->folderCollectionMonitor(), &Monitor::collectionStatisticsChanged, this, &KMMainWidget::slotCollectionStatisticsChanged);
 }
 
 void KMMainWidget::updateMoveAction(const Akonadi::CollectionStatistics &statistic)
 {
     const bool hasUnreadMails = (statistic.unreadCount() > 0);
     updateMoveAction(hasUnreadMails);
 }
 
 void KMMainWidget::updateMoveAction(bool hasUnreadMails)
 {
     const bool enable_goto_unread = hasUnreadMails
                                     || (KMailSettings::self()->loopOnGotoUnread() == KMailSettings::EnumLoopOnGotoUnread::LoopInAllFolders)
                                     || (KMailSettings::self()->loopOnGotoUnread() == KMailSettings::EnumLoopOnGotoUnread::LoopInAllMarkedFolders);
     actionCollection()->action(QStringLiteral("go_next_unread_message"))->setEnabled(enable_goto_unread);
     actionCollection()->action(QStringLiteral("go_prev_unread_message"))->setEnabled(enable_goto_unread);
     if (mAkonadiStandardActionManager && mAkonadiStandardActionManager->action(Akonadi::StandardMailActionManager::MarkAllMailAsRead)) {
         mAkonadiStandardActionManager->action(Akonadi::StandardMailActionManager::MarkAllMailAsRead)->setEnabled(hasUnreadMails);
     }
 }
 
 void KMMainWidget::updateAllToTrashAction(qint64 statistics)
 {
     if (mAkonadiStandardActionManager->action(Akonadi::StandardMailActionManager::MoveAllToTrash)) {
         const bool folderWithContent = mCurrentFolderSettings && !mCurrentFolderSettings->isStructural();
         mAkonadiStandardActionManager->action(Akonadi::StandardMailActionManager::MoveAllToTrash)->setEnabled(folderWithContent
                                                                                                               && (statistics > 0)
                                                                                                               && mCurrentFolderSettings->canDeleteMessages());
     }
 }
 
 void KMMainWidget::slotCollectionStatisticsChanged(Akonadi::Collection::Id id, const Akonadi::CollectionStatistics &statistic)
 {
     if (id == CommonKernel->outboxCollectionFolder().id()) {
         const bool enableAction = (statistic.count() > 0);
         mSendQueued->setEnabled(enableAction);
         mSendActionMenu->setEnabled(enableAction);
     } else if (id == mCurrentCollection.id()) {
         updateMoveAction(statistic);
         updateAllToTrashAction(statistic.count());
         setCurrentCollection(CommonKernel->collectionFromId(mCurrentCollection.id()));
     }
 }
 
 void KMMainWidget::slotCreateNewTab(bool preferNewTab)
 {
     mMessagePane->setPreferEmptyTab(preferNewTab);
 }
 
 void KMMainWidget::slotCollectionChanged(const Akonadi::Collection &collection, const QSet<QByteArray> &set)
 {
     if ((collection == mCurrentCollection)
         && (set.contains("MESSAGEFOLDER") || set.contains("expirationcollectionattribute"))) {
         if (set.contains("MESSAGEFOLDER")) {
             mMessagePane->resetModelStorage();
         } else {
             setCurrentCollection(collection);
         }
     } else if (set.contains("ENTITYDISPLAY") || set.contains("NAME")) {
         const QModelIndex idx = Akonadi::EntityTreeModel::modelIndexForCollection(KMKernel::self()->collectionModel(), collection);
         if (idx.isValid()) {
             const QString text = idx.data().toString();
             const QIcon icon = idx.data(Qt::DecorationRole).value<QIcon>();
             mMessagePane->updateTabIconText(collection, text, icon);
         }
     }
 }
 
 void KMMainWidget::slotItemAdded(const Akonadi::Item &msg, const Akonadi::Collection &col)
 {
     Q_UNUSED(msg);
     if (col.isValid()) {
         if (col == CommonKernel->outboxCollectionFolder()) {
             startUpdateMessageActionsTimer();
         }
     }
 }
 
 void KMMainWidget::slotItemRemoved(const Akonadi::Item &item)
 {
     if (item.isValid() && item.parentCollection().isValid() && (item.parentCollection() == CommonKernel->outboxCollectionFolder())) {
         startUpdateMessageActionsTimer();
     }
 }
 
 void KMMainWidget::slotItemMoved(const Akonadi::Item &item, const Akonadi::Collection &from, const Akonadi::Collection &to)
 {
     if (item.isValid() && ((from.id() == CommonKernel->outboxCollectionFolder().id())
                            || to.id() == CommonKernel->outboxCollectionFolder().id())) {
         startUpdateMessageActionsTimer();
     }
 }
 
 //-------------------------------------------------------------------------
 void KMMainWidget::slotFocusQuickSearch()
 {
     const QString text = mMsgView ? mMsgView->copyText() : QString();
     mMessagePane->focusQuickSearch(text);
 }
 
 //-------------------------------------------------------------------------
 bool KMMainWidget::showSearchDialog()
 {
     if (!mSearchWin) {
         mSearchWin = new SearchWindow(this, mCurrentCollection);
         mSearchWin->setModal(false);
         mSearchWin->setObjectName(QStringLiteral("Search"));
     } else {
         mSearchWin->activateFolder(mCurrentCollection);
     }
 
     mSearchWin->show();
     KWindowSystem::activateWindow(mSearchWin->winId());
     return true;
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotFilter()
 {
     FilterIf->openFilterDialog(true);
 }
 
 void KMMainWidget::slotManageSieveScripts()
 {
     if (!kmkernel->askToGoOnline()) {
         return;
     }
     if (mManageSieveDialog) {
         return;
     }
 
     mManageSieveDialog = new KSieveUi::ManageSieveScriptsDialog(mSievePasswordProvider);
     connect(mManageSieveDialog.data(), &KSieveUi::ManageSieveScriptsDialog::finished, this, &KMMainWidget::slotCheckVacation);
     mManageSieveDialog->show();
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotCheckMail()
 {
     kmkernel->checkMail();
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotCheckMailOnStartup()
 {
     kmkernel->checkMailOnStartup();
 }
 
 void KMMainWidget::slotCompose()
 {
     ComposeNewMessageJob *job = new ComposeNewMessageJob;
     job->setFolderSettings(mCurrentFolderSettings);
     job->setCurrentCollection(mCurrentCollection);
     job->start();
 }
 
 //-----------------------------------------------------------------------------
 // TODO: do we want the list sorted alphabetically?
 void KMMainWidget::slotShowNewFromTemplate()
 {
     if (mCurrentFolderSettings) {
         const KIdentityManagement::Identity &ident
             = kmkernel->identityManager()->identityForUoidOrDefault(mCurrentFolderSettings->identity());
         mTemplateFolder = CommonKernel->collectionFromId(ident.templates().toLongLong());
     }
 
     if (!mTemplateFolder.isValid()) {
         mTemplateFolder = CommonKernel->templatesCollectionFolder();
     }
     if (!mTemplateFolder.isValid()) {
         qCWarning(KMAIL_LOG) << "Template folder not found";
         return;
     }
 
     mTemplateMenu->menu()->clear();
 
     Akonadi::ItemFetchJob *job = new Akonadi::ItemFetchJob(mTemplateFolder);
     job->fetchScope().setAncestorRetrieval(ItemFetchScope::Parent);
     job->fetchScope().fetchFullPayload();
     connect(job, &Akonadi::ItemFetchJob::result, this, &KMMainWidget::slotDelayedShowNewFromTemplate);
 }
 
 void KMMainWidget::slotDelayedShowNewFromTemplate(KJob *job)
 {
     Akonadi::ItemFetchJob *fetchJob = qobject_cast<Akonadi::ItemFetchJob *>(job);
 
     const Akonadi::Item::List items = fetchJob->items();
     const int numberOfItems = items.count();
     for (int idx = 0; idx < numberOfItems; ++idx) {
         KMime::Message::Ptr msg = MessageComposer::Util::message(items.at(idx));
         if (msg) {
             QString subj = msg->subject()->asUnicodeString();
             if (subj.isEmpty()) {
                 subj = i18n("No Subject");
             }
 
             QAction *templateAction = mTemplateMenu->menu()->addAction(KStringHandler::rsqueeze(subj.replace(QLatin1Char('&'), QStringLiteral("&&"))));
             QVariant var;
             var.setValue(items.at(idx));
             templateAction->setData(var);
         }
     }
 
     // If there are no templates available, add a menu entry which informs
     // the user about this.
     if (mTemplateMenu->menu()->actions().isEmpty()) {
         QAction *noAction = mTemplateMenu->menu()->addAction(
             i18n("(no templates)"));
         noAction->setEnabled(false);
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotNewFromTemplate(QAction *action)
 {
     if (!mTemplateFolder.isValid()) {
         return;
     }
     const Akonadi::Item item = action->data().value<Akonadi::Item>();
     newFromTemplate(item);
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::newFromTemplate(const Akonadi::Item &msg)
 {
     if (!msg.isValid()) {
         return;
     }
     KMCommand *command = new KMUseTemplateCommand(this, msg);
     command->start();
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotPostToML()
 {
     if (mCurrentFolderSettings && mCurrentFolderSettings->isMailingListEnabled()) {
         if (KMail::Util::mailingListPost(mCurrentFolderSettings, mCurrentCollection)) {
             return;
         }
     }
     slotCompose();
 }
 
 void KMMainWidget::slotExpireFolder()
 {
     if (!mCurrentFolderSettings) {
         return;
     }
     bool mustDeleteExpirationAttribute = false;
     MailCommon::ExpireCollectionAttribute *attr = MailCommon::Util::expirationCollectionAttribute(mCurrentCollection, mustDeleteExpirationAttribute);
     bool canBeExpired = true;
     if (!attr->isAutoExpire()) {
         canBeExpired = false;
     } else if (attr->unreadExpireUnits() == MailCommon::ExpireCollectionAttribute::ExpireNever
                && attr->readExpireUnits() == MailCommon::ExpireCollectionAttribute::ExpireNever) {
         canBeExpired = false;
     }
 
     if (!canBeExpired) {
         const QString message = i18n("This folder does not have any expiry options set");
         KMessageBox::information(this, message);
         if (mustDeleteExpirationAttribute) {
             delete attr;
         }
         return;
     }
 
     if (KMailSettings::self()->warnBeforeExpire()) {
         const QString message = i18n("<qt>Are you sure you want to expire the folder <b>%1</b>?</qt>",
                                      mCurrentFolderSettings->name().toHtmlEscaped());
         if (KMessageBox::warningContinueCancel(this, message, i18n("Expire Folder"),
                                                KGuiItem(i18n("&Expire")))
             != KMessageBox::Continue) {
             if (mustDeleteExpirationAttribute) {
                 delete attr;
             }
             return;
         }
     }
 
     MailCommon::Util::expireOldMessages(mCurrentCollection, true /*immediate*/);
     if (mustDeleteExpirationAttribute) {
         delete attr;
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotEmptyFolder()
 {
     if (!mCurrentCollection.isValid()) {
         return;
     }
     const bool isTrash = CommonKernel->folderIsTrash(mCurrentCollection);
     const QString title = (isTrash) ? i18n("Empty Trash") : i18n("Move to Trash");
     const QString text = (isTrash)
                          ? i18n("Are you sure you want to empty the trash folder?")
                          : i18n("<qt>Are you sure you want to move all messages from "
                                 "folder <b>%1</b> to the trash?</qt>", mCurrentCollection.name().toHtmlEscaped());
 
     if (KMessageBox::warningContinueCancel(this, text, title, KGuiItem(title, QStringLiteral("user-trash")))
         != KMessageBox::Continue) {
         return;
     }
 #ifndef QT_NO_CURSOR
     KPIM::KCursorSaver busy(KPIM::KBusyPtr::busy());
 #endif
     slotSelectAllMessages();
     if (isTrash) {
         /* Don't ask for confirmation again when deleting, the user has already
         confirmed. */
         deleteSelectedMessages(false);
     } else {
         slotTrashSelectedMessages();
     }
 
     if (mMsgView) {
         mMsgView->clearCache();
     }
 
     if (!isTrash) {
         const QString str = i18n("Moved all messages to the trash");
         showMessageActivities(str);
     }
 
     updateMessageActions();
 
     // Disable empty trash/move all to trash action - we've just deleted/moved
     // all folder contents.
     mAkonadiStandardActionManager->action(Akonadi::StandardMailActionManager::MoveAllToTrash)->setEnabled(false);
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotArchiveFolder()
 {
     if (mCurrentCollection.isValid()) {
         QPointer<KMail::ArchiveFolderDialog> archiveDialog = new KMail::ArchiveFolderDialog(this);
         archiveDialog->setFolder(mCurrentCollection);
         archiveDialog->exec();
         delete archiveDialog;
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotRemoveFolder()
 {
     if (!mCurrentFolderSettings) {
         return;
     }
     if (!mCurrentFolderSettings->isValid()) {
         return;
     }
     if (mCurrentFolderSettings->isSystemFolder()) {
         return;
     }
     if (mCurrentFolderSettings->isReadOnly()) {
         return;
     }
 
     RemoveCollectionJob *job = new RemoveCollectionJob(this);
     connect(job, &RemoveCollectionJob::clearCurrentFolder, this, &KMMainWidget::slotClearCurrentFolder);
     job->setMainWidget(this);
     job->setCurrentFolder(mCurrentCollection);
     job->start();
 }
 
 void KMMainWidget::slotClearCurrentFolder()
 {
     clearCurrentFolder();
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotExpireAll()
 {
     if (KMailSettings::self()->warnBeforeExpire()) {
         const int ret = KMessageBox::warningContinueCancel(KMainWindow::memberList().constFirst(),
                                                            i18n("Are you sure you want to expire all old messages?"),
                                                            i18n("Expire Old Messages?"), KGuiItem(i18n("Expire")));
         if (ret != KMessageBox::Continue) {
             return;
         }
     }
 
     kmkernel->expireAllFoldersNow();
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotOverrideHtmlLoadExt()
 {
     if (mHtmlLoadExtGlobalSetting == mFolderHtmlLoadExtPreference) {
         int result = KMessageBox::warningContinueCancel(this,
                                                         // the warning text is taken from configuredialog.cpp:
                                                         i18n("Loading external references in html mail will make you more vulnerable to "
                                                              "\"spam\" and may increase the likelihood that your system will be "
                                                              "compromised by other present and anticipated security exploits."),
                                                         i18n("Security Warning"),
                                                         KGuiItem(i18n("Load External References")),
                                                         KStandardGuiItem::cancel(),
                                                         QStringLiteral("OverrideHtmlLoadExtWarning"), nullptr);
         if (result == KMessageBox::Cancel) {
             mPreferHtmlLoadExtAction->setChecked(false);
             return;
         }
     }
     mFolderHtmlLoadExtPreference = !mFolderHtmlLoadExtPreference;
 
     if (mMsgView) {
         mMsgView->setHtmlLoadExtDefault(mFolderHtmlLoadExtPreference);
         mMsgView->update(true);
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotForwardInlineMsg()
 {
     if (!mCurrentFolderSettings) {
         return;
     }
 
     const Akonadi::Item::List selectedMessages = mMessagePane->selectionAsMessageItemList();
     if (selectedMessages.isEmpty()) {
         return;
     }
     const QString text = mMsgView ? mMsgView->copyText() : QString();
     KMForwardCommand *command = new KMForwardCommand(
         this, selectedMessages, mCurrentFolderSettings->identity(), QString(), text
         );
 
     command->start();
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotForwardAttachedMessage()
 {
     if (!mCurrentFolderSettings) {
         return;
     }
 
     const Akonadi::Item::List selectedMessages = mMessagePane->selectionAsMessageItemList();
     if (selectedMessages.isEmpty()) {
         return;
     }
     KMForwardAttachedCommand *command = new KMForwardAttachedCommand(
         this, selectedMessages, mCurrentFolderSettings->identity()
         );
 
     command->start();
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotUseTemplate()
 {
     newFromTemplate(mMessagePane->currentItem());
 }
 
 //-----------------------------------------------------------------------------
 // Message moving and permanent deletion
 //
 
 void KMMainWidget::moveMessageSelected(MessageList::Core::MessageItemSetReference ref, const Akonadi::Collection &dest, bool confirmOnDeletion)
 {
     Akonadi::Item::List selectMsg = mMessagePane->itemListFromPersistentSet(ref);
     // If this is a deletion, ask for confirmation
     if (confirmOnDeletion) {
         const int selectedMessageCount = selectMsg.count();
         int ret = KMessageBox::warningContinueCancel(
             this,
             i18np(
                 "<qt>Do you really want to delete the selected message?<br />"
                 "Once deleted, it cannot be restored.</qt>",
                 "<qt>Do you really want to delete the %1 selected messages?<br />"
                 "Once deleted, they cannot be restored.</qt>",
                 selectedMessageCount
                 ),
             selectedMessageCount > 1 ? i18n("Delete Messages") : i18n("Delete Message"),
             KStandardGuiItem::del(),
             KStandardGuiItem::cancel()
             );
         if (ret == KMessageBox::Cancel) {
             mMessagePane->deletePersistentSet(ref);
             return;  // user canceled the action
         }
     }
     mMessagePane->markMessageItemsAsAboutToBeRemoved(ref, true);
     // And stuff them into a KMMoveCommand :)
     KMMoveCommand *command = new KMMoveCommand(dest, selectMsg, ref);
     QObject::connect(
         command, &KMMoveCommand::moveDone,
         this, &KMMainWidget::slotMoveMessagesCompleted
         );
     command->start();
 
     if (dest.isValid()) {
         showMessageActivities(i18n("Moving messages..."));
     } else {
         showMessageActivities(i18n("Deleting messages..."));
     }
 }
 
 void KMMainWidget::slotMoveMessagesCompleted(KMMoveCommand *command)
 {
     Q_ASSERT(command);
     mMessagePane->markMessageItemsAsAboutToBeRemoved(command->refSet(), false);
     mMessagePane->deletePersistentSet(command->refSet());
     // Bleah :D
     const bool moveWasReallyADelete = !command->destFolder().isValid();
 
     QString str;
     if (command->result() == KMCommand::OK) {
         if (moveWasReallyADelete) {
             str = i18n("Messages deleted successfully.");
         } else {
             str = i18n("Messages moved successfully.");
         }
     } else {
         if (moveWasReallyADelete) {
             if (command->result() == KMCommand::Failed) {
                 str = i18n("Deleting messages failed.");
             } else {
                 str = i18n("Deleting messages canceled.");
             }
         } else {
             if (command->result() == KMCommand::Failed) {
                 str = i18n("Moving messages failed.");
             } else {
                 str = i18n("Moving messages canceled.");
             }
         }
     }
     showMessageActivities(str);
     // The command will autodelete itself and will also kill the set.
 }
 
 void KMMainWidget::slotDeleteMessages()
 {
     deleteSelectedMessages(true);
 }
 
 Akonadi::Item::List KMMainWidget::currentSelection() const
 {
     Akonadi::Item::List selectMsg;
     MessageList::Core::MessageItemSetReference ref = mMessagePane->selectionAsPersistentSet();
     if (ref != -1) {
         selectMsg = mMessagePane->itemListFromPersistentSet(ref);
     }
     return selectMsg;
 }
 
 void KMMainWidget::deleteSelectedMessages(bool confirmDelete)
 {
     // Create a persistent message set from the current selection
     MessageList::Core::MessageItemSetReference ref = mMessagePane->selectionAsPersistentSet();
     if (ref != -1) {
         moveMessageSelected(ref, Akonadi::Collection(), confirmDelete);
     }
 }
 
 void KMMainWidget::slotDeleteThread(bool confirmDelete)
 {
     // Create a persistent set from the current thread.
     MessageList::Core::MessageItemSetReference ref = mMessagePane->currentThreadAsPersistentSet();
     if (ref != -1) {
         moveMessageSelected(ref, Akonadi::Collection(), confirmDelete);
     }
 }
 
 FolderSelectionDialog *KMMainWidget::moveOrCopyToDialog()
 {
     if (!mMoveOrCopyToDialog) {
         FolderSelectionDialog::SelectionFolderOption options = FolderSelectionDialog::HideVirtualFolder;
         mMoveOrCopyToDialog = new FolderSelectionDialog(this, options);
         mMoveOrCopyToDialog->setModal(true);
     }
     return mMoveOrCopyToDialog;
 }
 
 FolderSelectionDialog *KMMainWidget::selectFromAllFoldersDialog()
 {
     if (!mSelectFromAllFoldersDialog) {
         FolderSelectionDialog::SelectionFolderOptions options = FolderSelectionDialog::None;
         options |= FolderSelectionDialog::NotAllowToCreateNewFolder;
 
         mSelectFromAllFoldersDialog = new FolderSelectionDialog(this, options);
         mSelectFromAllFoldersDialog->setModal(true);
     }
     return mSelectFromAllFoldersDialog;
 }
 
 void KMMainWidget::slotMoveSelectedMessageToFolder()
 {
     QPointer<MailCommon::FolderSelectionDialog> dialog(moveOrCopyToDialog());
     dialog->setWindowTitle(i18n("Move Messages to Folder"));
     if (dialog->exec() && dialog) {
         const Akonadi::Collection dest = dialog->selectedCollection();
         if (dest.isValid()) {
             moveSelectedMessagesToFolder(dest);
         }
     }
 }
 
 void KMMainWidget::moveSelectedMessagesToFolder(const Akonadi::Collection &dest)
 {
     MessageList::Core::MessageItemSetReference ref = mMessagePane->selectionAsPersistentSet();
     if (ref != -1) {
         //Need to verify if dest == src ??? akonadi do it for us.
         moveMessageSelected(ref, dest, false);
     }
 }
 
 void KMMainWidget::copyMessageSelected(const Akonadi::Item::List &selectMsg, const Akonadi::Collection &dest)
 {
     if (selectMsg.isEmpty()) {
         return;
     }
     // And stuff them into a KMCopyCommand :)
     KMCommand *command = new KMCopyCommand(dest, selectMsg);
     QObject::connect(
         command, &KMCommand::completed,
         this, &KMMainWidget::slotCopyMessagesCompleted
         );
     command->start();
     showMessageActivities(i18n("Copying messages..."));
 }
 
 void KMMainWidget::slotCopyMessagesCompleted(KMCommand *command)
 {
     Q_ASSERT(command);
     QString str;
     if (command->result() == KMCommand::OK) {
         str = i18n("Messages copied successfully.");
     } else {
         if (command->result() == KMCommand::Failed) {
             str = i18n("Copying messages failed.");
         } else {
             str = i18n("Copying messages canceled.");
         }
     }
     showMessageActivities(str);
     // The command will autodelete itself and will also kill the set.
 }
 
 void KMMainWidget::slotCopySelectedMessagesToFolder()
 {
     QPointer<MailCommon::FolderSelectionDialog> dialog(moveOrCopyToDialog());
     dialog->setWindowTitle(i18n("Copy Messages to Folder"));
 
     if (dialog->exec() && dialog) {
         const Akonadi::Collection dest = dialog->selectedCollection();
         if (dest.isValid()) {
             copySelectedMessagesToFolder(dest);
         }
     }
 }
 
 void KMMainWidget::copySelectedMessagesToFolder(const Akonadi::Collection &dest)
 {
     const Akonadi::Item::List lstMsg = mMessagePane->selectionAsMessageItemList();
     if (!lstMsg.isEmpty()) {
         copyMessageSelected(lstMsg, dest);
     }
 }
 
 //-----------------------------------------------------------------------------
 // Message trashing
 //
 void KMMainWidget::trashMessageSelected(MessageList::Core::MessageItemSetReference ref)
 {
     if (!mCurrentCollection.isValid()) {
         return;
     }
 
     const Akonadi::Item::List select = mMessagePane->itemListFromPersistentSet(ref);
     mMessagePane->markMessageItemsAsAboutToBeRemoved(ref, true);
 
     // FIXME: Why we don't use KMMoveCommand( trashFolder(), selectedMessages ); ?
     // And stuff them into a KMTrashMsgCommand :)
     KMTrashMsgCommand *command = new KMTrashMsgCommand(mCurrentCollection, select, ref);
 
     QObject::connect(
         command, &KMMoveCommand::moveDone,
         this, &KMMainWidget::slotTrashMessagesCompleted
         );
     command->start();
     bool moveToTrash = command->destFolder().isValid();
     showMessageActivities(moveToTrash ? i18n("Moving messages to trash...") : i18n("Deleting messages..."));
 }
 
 void KMMainWidget::slotTrashMessagesCompleted(KMMoveCommand *command)
 {
     Q_ASSERT(command);
     mMessagePane->markMessageItemsAsAboutToBeRemoved(command->refSet(), false);
     mMessagePane->deletePersistentSet(command->refSet());
     bool moveToTrash = command->destFolder().isValid();
     if (command->result() == KMCommand::OK) {
         showMessageActivities(moveToTrash ? i18n("Messages moved to trash successfully.") : i18n("Messages deleted successfully."));
     } else {
         if (command->result() == KMCommand::Failed) {
             showMessageActivities(moveToTrash ? i18n("Moving messages to trash failed.") : i18n("Deleting messages failed."));
         } else {
             showMessageActivities(moveToTrash ? i18n("Moving messages to trash canceled.") : i18n("Deleting messages canceled."));
         }
     }
 
     // The command will autodelete itself and will also kill the set.
 }
 
 void KMMainWidget::slotTrashSelectedMessages()
 {
     MessageList::Core::MessageItemSetReference ref = mMessagePane->selectionAsPersistentSet();
     if (ref != -1) {
         trashMessageSelected(ref);
     }
 }
 
 void KMMainWidget::slotTrashThread()
 {
     MessageList::Core::MessageItemSetReference ref = mMessagePane->currentThreadAsPersistentSet();
     if (ref != -1) {
         trashMessageSelected(ref);
     }
 }
 
 //-----------------------------------------------------------------------------
 // Message tag setting for messages
 //
 // FIXME: The "selection" version of these functions is in MessageActions.
 //        We should probably move everything there....
 void KMMainWidget::toggleMessageSetTag(const Akonadi::Item::List &select, const Akonadi::Tag &tag)
 {
     if (select.isEmpty()) {
         return;
     }
     KMCommand *command = new KMSetTagCommand(Akonadi::Tag::List() << tag, select, KMSetTagCommand::Toggle);
     command->start();
 }
 
 void KMMainWidget::slotSelectMoreMessageTagList()
 {
     const Akonadi::Item::List selectedMessages = mMessagePane->selectionAsMessageItemList();
     if (selectedMessages.isEmpty()) {
         return;
     }
 
     QPointer<TagSelectDialog> dlg = new TagSelectDialog(this, selectedMessages.count(), selectedMessages.first());
     dlg->setActionCollection(QList<KActionCollection *> { actionCollection() });
     if (dlg->exec()) {
         const Akonadi::Tag::List lst = dlg->selectedTag();
         KMCommand *command = new KMSetTagCommand(lst, selectedMessages, KMSetTagCommand::CleanExistingAndAddNew);
         command->start();
     }
     delete dlg;
 }
 
 void KMMainWidget::slotUpdateMessageTagList(const Akonadi::Tag &tag)
 {
     // Create a persistent set from the current thread.
     const Akonadi::Item::List selectedMessages = mMessagePane->selectionAsMessageItemList();
     if (selectedMessages.isEmpty()) {
         return;
     }
     toggleMessageSetTag(selectedMessages, tag);
 }
 
 void KMMainWidget::refreshMessageListSelection()
 {
     mAkonadiStandardActionManager->setItemSelectionModel(mMessagePane->currentItemSelectionModel());
     slotMessageSelected(mMessagePane->currentItem());
     Q_EMIT captionChangeRequest(MailCommon::Util::fullCollectionPath(mMessagePane->currentFolder()));
 }
 
 //-----------------------------------------------------------------------------
 // Status setting for threads
 //
 // FIXME: The "selection" version of these functions is in MessageActions.
 //        We should probably move everything there....
 void KMMainWidget::setMessageSetStatus(const Akonadi::Item::List &select, const Akonadi::MessageStatus &status, bool toggle)
 {
     KMCommand *command = new KMSetStatusCommand(status, select, toggle);
     command->start();
 }
 
 void KMMainWidget::setCurrentThreadStatus(const Akonadi::MessageStatus &status, bool toggle)
 {
     const Akonadi::Item::List select = mMessagePane->currentThreadAsMessageList();
     if (select.isEmpty()) {
         return;
     }
     setMessageSetStatus(select, status, toggle);
 }
 
 void KMMainWidget::slotSetThreadStatusUnread()
 {
     setCurrentThreadStatus(MessageStatus::statusRead(), true);
 }
 
 void KMMainWidget::slotSetThreadStatusImportant()
 {
     setCurrentThreadStatus(MessageStatus::statusImportant(), true);
 }
 
 void KMMainWidget::slotSetThreadStatusRead()
 {
     setCurrentThreadStatus(MessageStatus::statusRead(), false);
 }
 
 void KMMainWidget::slotSetThreadStatusToAct()
 {
     setCurrentThreadStatus(MessageStatus::statusToAct(), true);
 }
 
 void KMMainWidget::slotSetThreadStatusWatched()
 {
     setCurrentThreadStatus(MessageStatus::statusWatched(), true);
     if (mWatchThreadAction->isChecked()) {
         mIgnoreThreadAction->setChecked(false);
     }
 }
 
 void KMMainWidget::slotSetThreadStatusIgnored()
 {
     setCurrentThreadStatus(MessageStatus::statusIgnored(), true);
     if (mIgnoreThreadAction->isChecked()) {
         mWatchThreadAction->setChecked(false);
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotRedirectMessage()
 {
     const Akonadi::Item::List selectedMessages = mMessagePane->selectionAsMessageItemList();
     if (selectedMessages.isEmpty()) {
         return;
     }
 
     KMCommand *command = new KMRedirectCommand(this, selectedMessages);
     command->start();
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotCustomReplyToMsg(const QString &tmpl)
 {
     const Akonadi::Item msg = mMessagePane->currentItem();
     if (!msg.isValid()) {
         return;
     }
 
     const QString text = mMsgView ? mMsgView->copyText() : QString();
 
     qCDebug(KMAIL_LOG) << "Reply with template:" << tmpl;
 
     KMCommand *command = new KMReplyCommand(this,
                                             msg,
                                             MessageComposer::ReplySmart,
                                             text, false,
                                             tmpl);
     command->start();
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotCustomReplyAllToMsg(const QString &tmpl)
 {
     const Akonadi::Item msg = mMessagePane->currentItem();
     if (!msg.isValid()) {
         return;
     }
 
     const QString text = mMsgView ? mMsgView->copyText() : QString();
 
     qCDebug(KMAIL_LOG) << "Reply to All with template:" << tmpl;
 
     KMCommand *command = new KMReplyCommand(this,
                                             msg,
                                             MessageComposer::ReplyAll,
                                             text,
                                             false,
                                             tmpl
                                             );
 
     command->start();
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotCustomForwardMsg(const QString &tmpl)
 {
     if (!mCurrentFolderSettings) {
         return;
     }
 
     const Akonadi::Item::List selectedMessages = mMessagePane->selectionAsMessageItemList();
     if (selectedMessages.isEmpty()) {
         return;
     }
     const QString text = mMsgView ? mMsgView->copyText() : QString();
     qCDebug(KMAIL_LOG) << "Forward with template:" << tmpl;
     KMForwardCommand *command = new KMForwardCommand(
         this, selectedMessages, mCurrentFolderSettings->identity(), tmpl, text
         );
 
     command->start();
 }
 
 void KMMainWidget::openFilterDialog(const QByteArray &field, const QString &value)
 {
     FilterIf->openFilterDialog(false);
     FilterIf->createFilter(field, value);
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotSubjectFilter()
 {
     const KMime::Message::Ptr msg = mMessagePane->currentMessage();
     if (!msg) {
         return;
     }
 
     openFilterDialog("Subject", msg->subject()->asUnicodeString());
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotFromFilter()
 {
     KMime::Message::Ptr msg = mMessagePane->currentMessage();
     if (!msg) {
         return;
     }
 
     AddrSpecList al = MessageHelper::extractAddrSpecs(msg, "From");
     if (al.empty()) {
         openFilterDialog("From", msg->from()->asUnicodeString());
     } else {
         openFilterDialog("From", al.front().asString());
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotToFilter()
 {
     KMime::Message::Ptr msg = mMessagePane->currentMessage();
     if (!msg) {
         return;
     }
     openFilterDialog("To", msg->to()->asUnicodeString());
 }
 
 void KMMainWidget::slotCcFilter()
 {
     KMime::Message::Ptr msg = mMessagePane->currentMessage();
     if (!msg) {
         return;
     }
     openFilterDialog("Cc", msg->cc()->asUnicodeString());
 }
 
 void KMMainWidget::slotBandwidth(bool b)
 {
     PimCommon::NetworkUtil::self()->setLowBandwidth(b);
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotUndo()
 {
     kmkernel->undoStack()->undo();
     updateMessageActions();
     updateFolderMenu();
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotJumpToFolder()
 {
     QPointer<MailCommon::FolderSelectionDialog> dialog(selectFromAllFoldersDialog());
     dialog->setWindowTitle(i18n("Jump to Folder"));
     if (dialog->exec() && dialog) {
         Akonadi::Collection collection = dialog->selectedCollection();
         if (collection.isValid()) {
             slotSelectCollectionFolder(collection);
         }
     }
 }
 
 void KMMainWidget::slotSelectCollectionFolder(const Akonadi::Collection &col)
 {
     if (mFolderTreeWidget) {
         mFolderTreeWidget->selectCollectionFolder(col);
         slotFolderChanged(col); // call it explicitly in case the collection is filtered out in the foldertreeview
     }
 }
 
 void KMMainWidget::slotApplyFilters()
 {
     const Akonadi::Item::List selectedMessages = mMessagePane->selectionAsMessageItemList();
     if (selectedMessages.isEmpty()) {
         return;
     }
     applyFilters(selectedMessages);
 }
 
 Akonadi::Collection::List KMMainWidget::applyFilterOnCollection(bool recursive)
 {
     Akonadi::Collection::List cols;
     if (recursive) {
         cols = KMKernel::self()->subfolders(mCurrentCollection);
     } else {
         cols << mCurrentCollection;
     }
     return cols;
 }
 
 void KMMainWidget::slotApplyFiltersOnFolder(bool recursive)
 {
     if (mCurrentCollection.isValid()) {
         const Akonadi::Collection::List cols = applyFilterOnCollection(recursive);
         applyFilters(cols);
     }
 }
 
 void KMMainWidget::slotApplyFilterOnFolder(bool recursive)
 {
     if (mCurrentCollection.isValid()) {
         const Akonadi::Collection::List cols = applyFilterOnCollection(recursive);
         QAction *action = qobject_cast<QAction *>(sender());
         applyFilter(cols, action->property("filter_id").toString());
     }
 }
 
 void KMMainWidget::applyFilters(const Akonadi::Item::List &selectedMessages)
 {
 #ifndef QT_NO_CURSOR
     KPIM::KCursorSaver busy(KPIM::KBusyPtr::busy());
 #endif
 
     MailCommon::FilterManager::instance()->filter(selectedMessages);
 }
 
 void KMMainWidget::applyFilters(const Akonadi::Collection::List &selectedCols)
 {
 #ifndef QT_NO_CURSOR
     KPIM::KCursorSaver busy(KPIM::KBusyPtr::busy());
 #endif
     MailCommon::FilterManager::instance()->filter(selectedCols);
 }
 
 void KMMainWidget::applyFilter(const Akonadi::Collection::List &selectedCols, const QString &filter)
 {
 #ifndef QT_NO_CURSOR
     KPIM::KCursorSaver busy(KPIM::KBusyPtr::busy());
 #endif
     MailCommon::FilterManager::instance()->filter(selectedCols, { filter });
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotCheckVacation()
 {
     updateVacationScriptStatus(false);
     if (!kmkernel->askToGoOnline()) {
         return;
     }
 
     mVacationManager->checkVacation();
 }
 
 void KMMainWidget::slotEditCurrentVacation()
 {
     slotEditVacation(QString());
 }
 
 void KMMainWidget::slotEditVacation(const QString &serverName)
 {
     if (!kmkernel->askToGoOnline()) {
         return;
     }
 
     mVacationManager->slotEditVacation(serverName);
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotDebugSieve()
 {
     if (kmkernel->allowToDebug()) {
         QPointer<KSieveUi::SieveDebugDialog> mSieveDebugDialog = new KSieveUi::SieveDebugDialog(mSievePasswordProvider, this);
         mSieveDebugDialog->exec();
         delete mSieveDebugDialog;
     }
 }
 
 void KMMainWidget::slotConfigChanged()
 {
     readConfig();
     mMsgActions->setupForwardActions(actionCollection());
     mMsgActions->setupForwardingActionsList(mGUIClient);
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotSaveMsg()
 {
     const Akonadi::Item::List selectedMessages = mMessagePane->selectionAsMessageItemList();
     if (selectedMessages.isEmpty()) {
         return;
     }
     KMSaveMsgCommand *saveCommand = new KMSaveMsgCommand(this, selectedMessages);
     saveCommand->start();
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotOpenMsg()
 {
     KMOpenMsgCommand *openCommand = new KMOpenMsgCommand(this, QUrl(), overrideEncoding(), this);
 
     openCommand->start();
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotSaveAttachments()
 {
     const Akonadi::Item::List selectedMessages = mMessagePane->selectionAsMessageItemList();
     if (selectedMessages.isEmpty()) {
         return;
     }
     // Avoid re-downloading in the common case that only one message is selected, and the message
     // is also displayed in the viewer. For this, create a dummy item without a parent collection / item id,
     // so that KMCommand doesn't download it.
     KMSaveAttachmentsCommand *saveCommand = nullptr;
     if (mMsgView && selectedMessages.size() == 1
         && mMsgView->message().hasPayload<KMime::Message::Ptr>()
         && selectedMessages.first().id() == mMsgView->message().id()) {
         Akonadi::Item dummyItem;
         dummyItem.setPayload<KMime::Message::Ptr>(mMsgView->message().payload<KMime::Message::Ptr>());
         saveCommand = new KMSaveAttachmentsCommand(this, dummyItem, mMsgView->viewer());
     } else {
         saveCommand = new KMSaveAttachmentsCommand(this, selectedMessages);
     }
 
     saveCommand->start();
 }
 
 void KMMainWidget::slotOnlineStatus()
 {
     // KMKernel will emit a signal when we toggle the network state that is caught by
     // KMMainWidget::slotUpdateOnlineStatus to update our GUI
     if (KMailSettings::self()->networkState() == KMailSettings::EnumNetworkState::Online) {
         // if online; then toggle and set it offline.
         kmkernel->stopNetworkJobs();
     } else {
         kmkernel->resumeNetworkJobs();
         slotCheckVacation();
     }
 }
 
 void KMMainWidget::slotUpdateOnlineStatus(KMailSettings::EnumNetworkState::type)
 {
     if (!mAkonadiStandardActionManager) {
         return;
     }
     QAction *action = mAkonadiStandardActionManager->action(Akonadi::StandardActionManager::ToggleWorkOffline);
     if (KMailSettings::self()->networkState() == KMailSettings::EnumNetworkState::Online) {
         action->setText(i18n("Work Offline"));
         action->setIcon(QIcon::fromTheme(QStringLiteral("user-offline")));
     } else {
         action->setText(i18n("Work Online"));
         action->setIcon(QIcon::fromTheme(QStringLiteral("user-online")));
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotSendQueued()
 {
     if (kmkernel->msgSender()) {
         if (!kmkernel->msgSender()->sendQueued()) {
             KMessageBox::error(this, i18n("Impossible to send email"), i18n("Send Email"));
         }
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotSendQueuedVia(MailTransport::Transport *transport)
 {
     if (transport) {
         if (kmkernel->msgSender()) {
             if (!kmkernel->msgSender()->sendQueued(transport->id())) {
                 KMessageBox::error(this, i18n("Impossible to send email"), i18n("Send Email"));
             }
         }
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotShowBusySplash()
 {
     if (mReaderWindowActive) {
         mMsgView->displayBusyPage();
     }
 }
 
 void KMMainWidget::showOfflinePage()
 {
     if (!mReaderWindowActive) {
         return;
     }
 
     mMsgView->displayOfflinePage();
 }
 
 void KMMainWidget::showResourceOfflinePage()
 {
     if (!mReaderWindowActive) {
         return;
     }
 
     mMsgView->displayResourceOfflinePage();
 }
 
 void KMMainWidget::slotFocusOnNextMessage()
 {
     mMessagePane->focusNextMessageItem(MessageList::Core::MessageTypeAny, true, false);
 }
 
 void KMMainWidget::slotFocusOnPrevMessage()
 {
     mMessagePane->focusPreviousMessageItem(MessageList::Core::MessageTypeAny, true, false);
 }
 
 void KMMainWidget::slotSelectFirstMessage()
 {
     mMessagePane->selectFirstMessageItem(MessageList::Core::MessageTypeAny, true);
 }
 
 void KMMainWidget::slotSelectLastMessage()
 {
     mMessagePane->selectLastMessageItem(MessageList::Core::MessageTypeAny, true);
 }
 
 void KMMainWidget::slotSelectFocusedMessage()
 {
     mMessagePane->selectFocusedMessageItem(true);
 }
 
 void KMMainWidget::slotSelectNextMessage()
 {
     mMessagePane->selectNextMessageItem(MessageList::Core::MessageTypeAny,
                                         MessageList::Core::ClearExistingSelection,
                                         true, false);
 }
 
 void KMMainWidget::slotExtendSelectionToNextMessage()
 {
     mMessagePane->selectNextMessageItem(
         MessageList::Core::MessageTypeAny,
         MessageList::Core::GrowOrShrinkExistingSelection,
         true,  // center item
         false  // don't loop in folder
         );
 }
 
 void KMMainWidget::slotSelectNextUnreadMessage()
 {
     // The looping logic is: "Don't loop" just never loops, "Loop in current folder"
     // loops just in current folder, "Loop in all folders" loops in the current folder
     // first and then after confirmation jumps to the next folder.
     // A bad point here is that if you answer "No, and don't ask me again" to the confirmation
     // dialog then you have "Loop in current folder" and "Loop in all folders" that do
     // the same thing and no way to get the old behaviour. However, after a consultation on #kontact,
     // for bug-to-bug backward compatibility, the masters decided to keep it b0rken :D
     // If nobody complains, it stays like it is: if you complain enough maybe the masters will
     // decide to reconsider :)
     if (!mMessagePane->selectNextMessageItem(
             MessageList::Core::MessageTypeUnreadOnly,
             MessageList::Core::ClearExistingSelection,
             true,      // center item
             KMailSettings::self()->loopOnGotoUnread() != KMailSettings::EnumLoopOnGotoUnread::DontLoop
             )) {
         // no next unread message was found in the current folder
         if ((KMailSettings::self()->loopOnGotoUnread()
              == KMailSettings::EnumLoopOnGotoUnread::LoopInAllFolders)
             || (KMailSettings::self()->loopOnGotoUnread()
                 == KMailSettings::EnumLoopOnGotoUnread::LoopInAllMarkedFolders)) {
             mGoToFirstUnreadMessageInSelectedFolder = true;
             mFolderTreeWidget->folderTreeView()->selectNextUnreadFolder(true);
             mGoToFirstUnreadMessageInSelectedFolder = false;
         }
     }
 }
 
 void KMMainWidget::slotSelectPreviousMessage()
 {
     mMessagePane->selectPreviousMessageItem(MessageList::Core::MessageTypeAny,
                                             MessageList::Core::ClearExistingSelection,
                                             true, false);
 }
 
 void KMMainWidget::slotExtendSelectionToPreviousMessage()
 {
     mMessagePane->selectPreviousMessageItem(
         MessageList::Core::MessageTypeAny,
         MessageList::Core::GrowOrShrinkExistingSelection,
         true,  // center item
         false  // don't loop in folder
         );
 }
 
 void KMMainWidget::slotSelectPreviousUnreadMessage()
 {
     if (!mMessagePane->selectPreviousMessageItem(
             MessageList::Core::MessageTypeUnreadOnly,
             MessageList::Core::ClearExistingSelection,
             true,      // center item
             KMailSettings::self()->loopOnGotoUnread() == KMailSettings::EnumLoopOnGotoUnread::LoopInCurrentFolder
             )) {
         // no next unread message was found in the current folder
         if ((KMailSettings::self()->loopOnGotoUnread()
              == KMailSettings::EnumLoopOnGotoUnread::LoopInAllFolders)
             || (KMailSettings::self()->loopOnGotoUnread()
                 == KMailSettings::EnumLoopOnGotoUnread::LoopInAllMarkedFolders)) {
             mGoToFirstUnreadMessageInSelectedFolder = true;
             mFolderTreeWidget->folderTreeView()->selectPrevUnreadFolder();
             mGoToFirstUnreadMessageInSelectedFolder = false;
         }
     }
 }
 
 void KMMainWidget::slotDisplayCurrentMessage()
 {
     if (mMessagePane->currentItem().isValid() && !mMessagePane->searchEditHasFocus()) {
         slotMessageActivated(mMessagePane->currentItem());
     }
 }
 
 // Called by double-clicked or 'Enter' in the messagelist -> pop up reader window
 void KMMainWidget::slotMessageActivated(const Akonadi::Item &msg)
 {
     if (!mCurrentCollection.isValid() || !msg.isValid()) {
         return;
     }
 
     if (CommonKernel->folderIsDraftOrOutbox(mCurrentCollection)) {
         mMsgActions->setCurrentMessage(msg);
         mMsgActions->editCurrentMessage();
         return;
     }
 
     if (CommonKernel->folderIsTemplates(mCurrentCollection)) {
         slotUseTemplate();
         return;
     }
 
     KMReaderMainWin *win = nullptr;
     if (!mMsgView) {
         win = new KMReaderMainWin(mFolderDisplayFormatPreference, mFolderHtmlLoadExtPreference);
     }
     // Try to fetch the mail, even in offline mode, it might be cached
     KMFetchMessageCommand *cmd = new KMFetchMessageCommand(this, msg, win ? win->viewer() : mMsgView->viewer(), win);
     connect(cmd, &KMCommand::completed,
             this, &KMMainWidget::slotItemsFetchedForActivation);
     cmd->start();
 }
 
 void KMMainWidget::slotItemsFetchedForActivation(KMCommand *command)
 {
     KMCommand::Result result = command->result();
     if (result != KMCommand::OK) {
         qCDebug(KMAIL_LOG) << "Result:" << result;
         return;
     }
 
     KMFetchMessageCommand *fetchCmd = qobject_cast<KMFetchMessageCommand *>(command);
     const Item msg = fetchCmd->item();
     KMReaderMainWin *win = fetchCmd->readerMainWin();
 
     if (!win) {
         win = new KMReaderMainWin(mFolderDisplayFormatPreference, mFolderHtmlLoadExtPreference);
     }
     const bool useFixedFont = mMsgView ? mMsgView->isFixedFont()
                               : MessageViewer::MessageViewerSettings::self()->useFixedFont();
     win->setUseFixedFont(useFixedFont);
     win->showMessage(overrideEncoding(), msg, CommonKernel->collectionFromId(msg.parentCollection().id()));
     win->show();
 }
 
 void KMMainWidget::slotMessageStatusChangeRequest(const Akonadi::Item &item, const Akonadi::MessageStatus &set, const Akonadi::MessageStatus &clear)
 {
     if (!item.isValid()) {
         return;
     }
 
     if (clear.toQInt32() != Akonadi::MessageStatus().toQInt32()) {
         KMCommand *command = new KMSetStatusCommand(clear, Akonadi::Item::List() << item, true);
         command->start();
     }
 
     if (set.toQInt32() != Akonadi::MessageStatus().toQInt32()) {
         KMCommand *command = new KMSetStatusCommand(set, Akonadi::Item::List() << item, false);
         command->start();
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotSelectAllMessages()
 {
     mMessagePane->selectAll();
     updateMessageActions();
 }
 
 void KMMainWidget::slotMessagePopup(const Akonadi::Item &msg, const WebEngineViewer::WebHitTestResult &result, const QPoint &aPoint)
 {
     QUrl aUrl = result.linkUrl();
     QUrl imageUrl = result.imageUrl();
     updateMessageMenu();
 
     const QString email = KEmailAddress::firstEmailAddress(aUrl.path()).toLower();
     if (aUrl.scheme() == QLatin1String("mailto") && !email.isEmpty()) {
         Akonadi::ContactSearchJob *job = new Akonadi::ContactSearchJob(this);
         job->setLimit(1);
         job->setQuery(Akonadi::ContactSearchJob::Email, email, Akonadi::ContactSearchJob::ExactMatch);
         job->setProperty("msg", QVariant::fromValue(msg));
         job->setProperty("point", aPoint);
         job->setProperty("imageUrl", imageUrl);
         job->setProperty("url", aUrl);
         job->setProperty("webhitresult", QVariant::fromValue(result));
         connect(job, &Akonadi::ContactSearchJob::result, this, &KMMainWidget::slotContactSearchJobForMessagePopupDone);
     } else {
         showMessagePopup(msg, aUrl, imageUrl, aPoint, false, false, result);
     }
 }
 
 void KMMainWidget::slotContactSearchJobForMessagePopupDone(KJob *job)
 {
     const Akonadi::ContactSearchJob *searchJob = qobject_cast<Akonadi::ContactSearchJob *>(job);
     const bool contactAlreadyExists = !searchJob->contacts().isEmpty();
 
     const Akonadi::Item::List listContact = searchJob->items();
     const bool uniqueContactFound = (listContact.count() == 1);
     if (uniqueContactFound) {
         mMsgView->setContactItem(listContact.first(), searchJob->contacts().at(0));
     } else {
         mMsgView->clearContactItem();
     }
     const Akonadi::Item msg = job->property("msg").value<Akonadi::Item>();
     const QPoint aPoint = job->property("point").toPoint();
     const QUrl imageUrl = job->property("imageUrl").toUrl();
     const QUrl url = job->property("url").toUrl();
     const WebEngineViewer::WebHitTestResult result = job->property("webhitresult").value<WebEngineViewer::WebHitTestResult>();
 
     showMessagePopup(msg, url, imageUrl, aPoint, contactAlreadyExists, uniqueContactFound, result);
 }
 
 void KMMainWidget::showMessagePopup(const Akonadi::Item &msg, const QUrl &url, const QUrl &imageUrl, const QPoint &aPoint, bool contactAlreadyExists, bool uniqueContactFound,
                                     const WebEngineViewer::WebHitTestResult &result)
 {
     QMenu menu(this);
     bool urlMenuAdded = false;
 
     if (!url.isEmpty()) {
         if (url.scheme() == QLatin1String("mailto")) {
             // popup on a mailto URL
             menu.addAction(mMsgView->mailToComposeAction());
             menu.addAction(mMsgView->mailToReplyAction());
             menu.addAction(mMsgView->mailToForwardAction());
 
             menu.addSeparator();
 
             if (contactAlreadyExists) {
                 if (uniqueContactFound) {
                     menu.addAction(mMsgView->editContactAction());
                 } else {
                     menu.addAction(mMsgView->openAddrBookAction());
                 }
             } else {
                 menu.addAction(mMsgView->addAddrBookAction());
                 menu.addAction(mMsgView->addToExistingContactAction());
             }
             menu.addSeparator();
             menu.addMenu(mMsgView->viewHtmlOption());
             menu.addSeparator();
             menu.addAction(mMsgView->copyURLAction());
             urlMenuAdded = true;
         } else if (url.scheme() != QLatin1String("attachment")) {
             // popup on a not-mailto URL
             menu.addAction(mMsgView->urlOpenAction());
             menu.addAction(mMsgView->addBookmarksAction());
             menu.addAction(mMsgView->urlSaveAsAction());
             menu.addAction(mMsgView->copyURLAction());
             menu.addSeparator();
             menu.addAction(mMsgView->shareServiceUrlMenu());
             menu.addActions(mMsgView->viewerPluginActionList(MessageViewer::ViewerPluginInterface::NeedUrl));
             if (!imageUrl.isEmpty()) {
                 menu.addSeparator();
                 menu.addAction(mMsgView->copyImageLocation());
                 menu.addAction(mMsgView->downloadImageToDiskAction());
                 menu.addAction(mMsgView->shareImage());
             }
             urlMenuAdded = true;
         }
         qCDebug(KMAIL_LOG) << "URL is:" << url;
     }
     const QString selectedText = mMsgView ? mMsgView->copyText() : QString();
     if (mMsgView && !selectedText.isEmpty()) {
         if (urlMenuAdded) {
             menu.addSeparator();
         }
         menu.addAction(mMsgActions->replyMenu());
         menu.addSeparator();
 
         menu.addAction(mMsgView->copyAction());
         menu.addAction(mMsgView->selectAllAction());
         menu.addSeparator();
         mMsgActions->addWebShortcutsMenu(&menu, selectedText);
         menu.addSeparator();
         menu.addActions(mMsgView->viewerPluginActionList(MessageViewer::ViewerPluginInterface::NeedSelection));
         if (KPIMTextEdit::TextToSpeech::self()->isReady()) {
             menu.addSeparator();
             menu.addAction(mMsgView->speakTextAction());
         }
     } else if (!urlMenuAdded) {
         // popup somewhere else (i.e., not a URL) on the message
         if (!mMessagePane->currentMessage()) {
             // no messages
             return;
         }
         Akonadi::Collection parentCol = msg.parentCollection();
         if (parentCol.isValid() && CommonKernel->folderIsTemplates(parentCol)) {
             menu.addAction(mMsgActions->newMessageFromTemplateAction());
         } else {
             menu.addAction(mMsgActions->replyMenu());
             menu.addAction(mMsgActions->forwardMenu());
         }
         if (parentCol.isValid() && CommonKernel->folderIsSentMailFolder(parentCol)) {
             menu.addAction(mMsgActions->sendAgainAction());
         }
         menu.addAction(mailingListActionMenu());
         menu.addSeparator();
 
         menu.addAction(mCopyActionMenu);
         menu.addAction(mMoveActionMenu);
 
         menu.addSeparator();
 
         menu.addAction(mMsgActions->messageStatusMenu());
         menu.addSeparator();
         if (mMsgView) {
             if (!imageUrl.isEmpty()) {
                 menu.addSeparator();
                 menu.addAction(mMsgView->copyImageLocation());
                 menu.addAction(mMsgView->downloadImageToDiskAction());
                 menu.addAction(mMsgView->shareImage());
                 menu.addSeparator();
             }
         }
         menu.addSeparator();
         menu.addAction(mMsgActions->printPreviewAction());
         menu.addAction(mMsgActions->printAction());
         menu.addSeparator();
         menu.addAction(mSaveAsAction);
         menu.addAction(mSaveAttachmentsAction);
         menu.addSeparator();
         if (parentCol.isValid() && CommonKernel->folderIsTrash(parentCol)) {
             menu.addAction(mDeleteAction);
         } else {
             menu.addAction(akonadiStandardAction(Akonadi::StandardMailActionManager::MoveToTrash));
         }
         menu.addSeparator();
 
         if (mMsgView) {
             menu.addActions(mMsgView->viewerPluginActionList(MessageViewer::ViewerPluginInterface::NeedMessage));
             menu.addSeparator();
         }
 #if 0
         menu.addAction(mMsgActions->annotateAction());
 
         menu.addSeparator();
 #endif
         menu.addAction(mMsgActions->addFollowupReminderAction());
         if (kmkernel->allowToDebug()) {
             menu.addSeparator();
             menu.addAction(mMsgActions->debugAkonadiSearchAction());
         }
     }
     if (mMsgView) {
         const QList<QAction *> interceptorUrlActions = mMsgView->interceptorUrlActions(result);
         if (!interceptorUrlActions.isEmpty()) {
             menu.addSeparator();
             menu.addActions(interceptorUrlActions);
         }
     }
 
     KAcceleratorManager::manage(&menu);
     menu.exec(aPoint, nullptr);
 }
 
 void KMMainWidget::setupActions()
 {
     KMailPluginInterface::self()->setParentWidget(this);
     KMailPluginInterface::self()->createPluginInterface();
     mMsgActions = new KMail::MessageActions(actionCollection(), this);
     mMsgActions->setMessageView(mMsgView);
 
     //----- File Menu
     mSaveAsAction = new QAction(QIcon::fromTheme(QStringLiteral("document-save")), i18n("Save &As..."), this);
     actionCollection()->addAction(QStringLiteral("file_save_as"), mSaveAsAction);
     connect(mSaveAsAction, &QAction::triggered, this, &KMMainWidget::slotSaveMsg);
     actionCollection()->setDefaultShortcut(mSaveAsAction, KStandardShortcut::save().first());
 
     mOpenAction = KStandardAction::open(this, &KMMainWidget::slotOpenMsg,
                                         actionCollection());
 
     mOpenRecentAction = KStandardAction::openRecent(this, &KMMainWidget::slotOpenRecentMessage,
                                                     actionCollection());
     KConfigGroup grp = mConfig->group(QStringLiteral("Recent Files"));
     mOpenRecentAction->loadEntries(grp);
 
     {
         QAction *action = new QAction(i18n("&Expire All Folders"), this);
         actionCollection()->addAction(QStringLiteral("expire_all_folders"), action);
         connect(action, &QAction::triggered, this, &KMMainWidget::slotExpireAll);
     }
     {
         QAction *action = new QAction(QIcon::fromTheme(QStringLiteral("mail-receive")), i18n("Check &Mail"), this);
         actionCollection()->addAction(QStringLiteral("check_mail"), action);
         connect(action, &QAction::triggered, this, &KMMainWidget::slotCheckMail);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::CTRL + Qt::Key_L));
     }
 
     mAccountActionMenu = new KActionMenuAccount(this);
     mAccountActionMenu->setIcon(QIcon::fromTheme(QStringLiteral("mail-receive")));
     mAccountActionMenu->setText(i18n("Check Mail In"));
 
     mAccountActionMenu->setIconText(i18n("Check Mail"));
     mAccountActionMenu->setToolTip(i18n("Check Mail"));
     actionCollection()->addAction(QStringLiteral("check_mail_in"), mAccountActionMenu);
     connect(mAccountActionMenu, &KActionMenu::triggered, this, &KMMainWidget::slotCheckMail);
 
     mSendQueued = new QAction(QIcon::fromTheme(QStringLiteral("mail-send")), i18n("&Send Queued Messages"), this);
     actionCollection()->addAction(QStringLiteral("send_queued"), mSendQueued);
     connect(mSendQueued, &QAction::triggered, this, &KMMainWidget::slotSendQueued);
     {
         QAction *action = mAkonadiStandardActionManager->action(Akonadi::StandardActionManager::ToggleWorkOffline);
         mAkonadiStandardActionManager->interceptAction(Akonadi::StandardActionManager::ToggleWorkOffline);
         action->setCheckable(false);
         connect(action, &QAction::triggered, this, &KMMainWidget::slotOnlineStatus);
         action->setText(i18n("Online status (unknown)"));
     }
 
     mSendActionMenu = new KActionMenuTransport(this);
     mSendActionMenu->setIcon(QIcon::fromTheme(QStringLiteral("mail-send")));
     mSendActionMenu->setText(i18n("Send Queued Messages Via"));
     actionCollection()->addAction(QStringLiteral("send_queued_via"), mSendActionMenu);
 
     connect(mSendActionMenu, &KActionMenuTransport::transportSelected, this, &KMMainWidget::slotSendQueuedVia);
 
     //----- Tools menu
     if (parent()->inherits("KMMainWin")) {
         QAction *action = new QAction(QIcon::fromTheme(QStringLiteral("x-office-address-book")), i18n("&Address Book"), this);
         actionCollection()->addAction(QStringLiteral("addressbook"), action);
         connect(action, &QAction::triggered, mLaunchExternalComponent, &KMLaunchExternalComponent::slotRunAddressBook);
         if (QStandardPaths::findExecutable(QStringLiteral("kaddressbook")).isEmpty()) {
             action->setEnabled(false);
         }
     }
 
     {
         QAction *action = new QAction(QIcon::fromTheme(QStringLiteral("pgp-keys")), i18n("Certificate Manager"), this);
         actionCollection()->addAction(QStringLiteral("tools_start_certman"), action);
         connect(action, &QAction::triggered, mLaunchExternalComponent, &KMLaunchExternalComponent::slotStartCertManager);
         // disable action if no certman binary is around
         if (QStandardPaths::findExecutable(QStringLiteral("kleopatra")).isEmpty()) {
             action->setEnabled(false);
         }
     }
 
     {
         QAction *action = new QAction(QIcon::fromTheme(QStringLiteral("document-import")), i18n("&Import Messages..."), this);
         actionCollection()->addAction(QStringLiteral("import"), action);
         connect(action, &QAction::triggered, mLaunchExternalComponent, &KMLaunchExternalComponent::slotImport);
         if (QStandardPaths::findExecutable(QStringLiteral("akonadiimportwizard")).isEmpty()) {
             action->setEnabled(false);
         }
     }
 
     {
         if (kmkernel->allowToDebug()) {
             QAction *action = new QAction(i18n("&Debug Sieve..."), this);
             actionCollection()->addAction(QStringLiteral("tools_debug_sieve"), action);
             connect(action, &QAction::triggered, this, &KMMainWidget::slotDebugSieve);
         }
     }
 
     {
         QAction *action = new QAction(i18n("Filter &Log Viewer..."), this);
         actionCollection()->addAction(QStringLiteral("filter_log_viewer"), action);
         connect(action, &QAction::triggered, mLaunchExternalComponent, &KMLaunchExternalComponent::slotFilterLogViewer);
     }
     {
         QAction *action = new QAction(i18n("&Import from another Email Client..."), this);
         actionCollection()->addAction(QStringLiteral("importWizard"), action);
         connect(action, &QAction::triggered, mLaunchExternalComponent, &KMLaunchExternalComponent::slotImportWizard);
     }
     if (KSieveUi::Util::allowOutOfOfficeSettings()) {
         QAction *action = new QAction(i18n("Edit \"Out of Office\" Replies..."), this);
         actionCollection()->addAction(QStringLiteral("tools_edit_vacation"), action);
         connect(action, &QAction::triggered, this, &KMMainWidget::slotEditCurrentVacation);
     }
 
     {
         QAction *action = new QAction(i18n("&Configure Automatic Archiving..."), this);
         actionCollection()->addAction(QStringLiteral("tools_automatic_archiving"), action);
         connect(action, &QAction::triggered, mLaunchExternalComponent, &KMLaunchExternalComponent::slotConfigureAutomaticArchiving);
     }
 
     {
         QAction *action = new QAction(i18n("Delayed Messages..."), this);
         actionCollection()->addAction(QStringLiteral("message_delayed"), action);
         connect(action, &QAction::triggered, mLaunchExternalComponent, &KMLaunchExternalComponent::slotConfigureSendLater);
     }
 
     {
         QAction *action = new QAction(i18n("Followup Reminder Messages..."), this);
         actionCollection()->addAction(QStringLiteral("followup_reminder_messages"), action);
         connect(action, &QAction::triggered, mLaunchExternalComponent, &KMLaunchExternalComponent::slotConfigureFollowupReminder);
     }
 
     // Disable the standard action delete key sortcut.
     QAction *const standardDelAction = akonadiStandardAction(Akonadi::StandardActionManager::DeleteItems);
     standardDelAction->setShortcut(QKeySequence());
 
     //----- Edit Menu
 
     mDeleteAction = new QAction(QIcon::fromTheme(QStringLiteral("edit-delete")), i18nc("@action Hard delete, bypassing trash", "&Delete"), this);
     actionCollection()->addAction(QStringLiteral("delete"), mDeleteAction);
     connect(mDeleteAction, &QAction::triggered, this, &KMMainWidget::slotDeleteMessages);
     actionCollection()->setDefaultShortcut(mDeleteAction, QKeySequence(Qt::SHIFT + Qt::Key_Delete));
 
     mTrashThreadAction = new QAction(i18n("M&ove Thread to Trash"), this);
     actionCollection()->addAction(QStringLiteral("move_thread_to_trash"), mTrashThreadAction);
     actionCollection()->setDefaultShortcut(mTrashThreadAction, QKeySequence(Qt::CTRL + Qt::Key_Delete));
     mTrashThreadAction->setIcon(QIcon::fromTheme(QStringLiteral("user-trash")));
     KMail::Util::addQActionHelpText(mTrashThreadAction, i18n("Move thread to trashcan"));
     connect(mTrashThreadAction, &QAction::triggered, this, &KMMainWidget::slotTrashThread);
 
     mDeleteThreadAction = new QAction(QIcon::fromTheme(QStringLiteral("edit-delete")), i18n("Delete T&hread"), this);
     actionCollection()->addAction(QStringLiteral("delete_thread"), mDeleteThreadAction);
     //Don't use new connect api.
     connect(mDeleteThreadAction, &QAction::triggered, this, &KMMainWidget::slotDeleteThread);
     actionCollection()->setDefaultShortcut(mDeleteThreadAction, QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_Delete));
 
     mSearchMessages = new QAction(QIcon::fromTheme(QStringLiteral("edit-find-mail")), i18n("&Find Messages..."), this);
     actionCollection()->addAction(QStringLiteral("search_messages"), mSearchMessages);
     connect(mSearchMessages, &QAction::triggered, this, &KMMainWidget::slotRequestFullSearchFromQuickSearch);
     actionCollection()->setDefaultShortcut(mSearchMessages, QKeySequence(Qt::Key_S));
 
     mSelectAllMessages = new QAction(i18n("Select &All Messages"), this);
     actionCollection()->addAction(QStringLiteral("mark_all_messages"), mSelectAllMessages);
     connect(mSelectAllMessages, &QAction::triggered, this, &KMMainWidget::slotSelectAllMessages);
     actionCollection()->setDefaultShortcut(mSelectAllMessages, QKeySequence(Qt::CTRL + Qt::Key_A));
 
     //----- Folder Menu
 
     mFolderMailingListPropertiesAction = new QAction(i18n("&Mailing List Management..."), this);
     actionCollection()->addAction(QStringLiteral("folder_mailinglist_properties"), mFolderMailingListPropertiesAction);
     connect(mFolderMailingListPropertiesAction, &QAction::triggered, mManageShowCollectionProperties, &ManageShowCollectionProperties::slotFolderMailingListProperties);
     // mFolderMailingListPropertiesAction->setIcon(QIcon::fromTheme("document-properties-mailing-list"));
 
     mShowFolderShortcutDialogAction = new QAction(QIcon::fromTheme(QStringLiteral("configure-shortcuts")), i18n("&Assign Shortcut..."), this);
     actionCollection()->addAction(QStringLiteral("folder_shortcut_command"), mShowFolderShortcutDialogAction);
     connect(mShowFolderShortcutDialogAction, &QAction::triggered, mManageShowCollectionProperties,
             &ManageShowCollectionProperties::slotShowFolderShortcutDialog);
     // FIXME: this action is not currently enabled in the rc file, but even if
     // it were there is inconsistency between the action name and action.
     // "Expiration Settings" implies that this will lead to a settings dialogue
     // and it should be followed by a "...", but slotExpireFolder() performs
     // an immediate expiry.
     //
     // TODO: expire action should be disabled if there is no content or if
     // the folder can't delete messages.
     //
     // Leaving the action here for the moment, it and the "Expire" option in the
     // folder popup menu should be combined or at least made consistent.  Same for
     // slotExpireFolder() and FolderViewItem::slotShowExpiryProperties().
     mExpireFolderAction = new QAction(i18n("&Expiration Settings"), this);
     actionCollection()->addAction(QStringLiteral("expire"), mExpireFolderAction);
     connect(mExpireFolderAction, &QAction::triggered, this, &KMMainWidget::slotExpireFolder);
 
     mAkonadiStandardActionManager->interceptAction(Akonadi::StandardMailActionManager::MoveToTrash);
     connect(mAkonadiStandardActionManager->action(Akonadi::StandardMailActionManager::MoveToTrash), &QAction::triggered, this, &KMMainWidget::slotTrashSelectedMessages);
 
     mAkonadiStandardActionManager->interceptAction(Akonadi::StandardMailActionManager::MoveAllToTrash);
     connect(mAkonadiStandardActionManager->action(Akonadi::StandardMailActionManager::MoveAllToTrash), &QAction::triggered, this, &KMMainWidget::slotEmptyFolder);
 
     mAkonadiStandardActionManager->interceptAction(Akonadi::StandardActionManager::DeleteCollections);
     connect(mAkonadiStandardActionManager->action(Akonadi::StandardActionManager::DeleteCollections), &QAction::triggered, this, &KMMainWidget::slotRemoveFolder);
 
     // ### PORT ME: Add this to the context menu. Not possible right now because
     //              the context menu uses XMLGUI, and that would add the entry to
     //              all collection context menus
     mArchiveFolderAction = new QAction(i18n("&Archive Folder..."), this);
     actionCollection()->addAction(QStringLiteral("archive_folder"), mArchiveFolderAction);
     connect(mArchiveFolderAction, &QAction::triggered, this, &KMMainWidget::slotArchiveFolder);
 
     mDisplayMessageFormatMenu = new DisplayMessageFormatActionMenu(this);
     connect(mDisplayMessageFormatMenu, &DisplayMessageFormatActionMenu::changeDisplayMessageFormat, this, &KMMainWidget::slotChangeDisplayMessageFormat);
     actionCollection()->addAction(QStringLiteral("display_format_message"), mDisplayMessageFormatMenu);
 
     mPreferHtmlLoadExtAction = new KToggleAction(i18n("Load E&xternal References"), this);
     actionCollection()->addAction(QStringLiteral("prefer_html_external_refs"), mPreferHtmlLoadExtAction);
     connect(mPreferHtmlLoadExtAction, &KToggleAction::triggered, this, &KMMainWidget::slotOverrideHtmlLoadExt);
 
     {
         QAction *action = mAkonadiStandardActionManager->action(Akonadi::StandardActionManager::CopyCollections);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::SHIFT + Qt::CTRL + Qt::Key_C));
     }
     {
         QAction *action = mAkonadiStandardActionManager->action(Akonadi::StandardActionManager::Paste);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::SHIFT + Qt::CTRL + Qt::Key_V));
     }
     {
         QAction *action = mAkonadiStandardActionManager->action(Akonadi::StandardActionManager::CopyItems);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::ALT + Qt::CTRL + Qt::Key_C));
     }
     {
         QAction *action = mAkonadiStandardActionManager->action(Akonadi::StandardActionManager::CutItems);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::ALT + Qt::CTRL + Qt::Key_X));
     }
 
     {
         QAction *action = mAkonadiStandardActionManager->action(Akonadi::StandardActionManager::CopyItemToMenu);
         action->setText(i18n("Copy Message To..."));
         action = mAkonadiStandardActionManager->action(Akonadi::StandardActionManager::MoveItemToMenu);
         action->setText(i18n("Move Message To..."));
     }
 
     //----- Message Menu
     {
         QAction *action = new QAction(QIcon::fromTheme(QStringLiteral("mail-message-new")), i18n("&New Message..."), this);
         actionCollection()->addAction(QStringLiteral("new_message"), action);
         action->setIconText(i18nc("@action:intoolbar New Empty Message", "New"));
         connect(action, &QAction::triggered, this, &KMMainWidget::slotCompose);
         // do not set a New shortcut if kmail is a component
         if (kmkernel->xmlGuiInstanceName().isEmpty()) {
             actionCollection()->setDefaultShortcut(action, KStandardShortcut::openNew().first());
         }
     }
 
     mTemplateMenu = new KActionMenu(QIcon::fromTheme(QStringLiteral("document-new")), i18n("Message From &Template"),
                                     actionCollection());
     mTemplateMenu->setDelayed(true);
     actionCollection()->addAction(QStringLiteral("new_from_template"), mTemplateMenu);
     connect(mTemplateMenu->menu(), &QMenu::aboutToShow, this,
             &KMMainWidget::slotShowNewFromTemplate);
     connect(mTemplateMenu->menu(), &QMenu::triggered, this,
             &KMMainWidget::slotNewFromTemplate);
 
     mMessageNewList = new QAction(QIcon::fromTheme(QStringLiteral("mail-message-new-list")),
                                   i18n("New Message t&o Mailing-List..."),
                                   this);
     actionCollection()->addAction(QStringLiteral("post_message"), mMessageNewList);
     connect(mMessageNewList, &QAction::triggered,
             this, &KMMainWidget::slotPostToML);
     actionCollection()->setDefaultShortcut(mMessageNewList, QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_N));
 
     //----- Create filter actions
     mFilterMenu = new KActionMenu(QIcon::fromTheme(QStringLiteral("view-filter")), i18n("&Create Filter"), this);
     actionCollection()->addAction(QStringLiteral("create_filter"), mFilterMenu);
     connect(mFilterMenu, &QAction::triggered, this,
             &KMMainWidget::slotFilter);
     {
         QAction *action = new QAction(i18n("Filter on &Subject..."), this);
         actionCollection()->addAction(QStringLiteral("subject_filter"), action);
         connect(action, &QAction::triggered, this, &KMMainWidget::slotSubjectFilter);
         mFilterMenu->addAction(action);
     }
 
     {
         QAction *action = new QAction(i18n("Filter on &From..."), this);
         actionCollection()->addAction(QStringLiteral("from_filter"), action);
         connect(action, &QAction::triggered, this, &KMMainWidget::slotFromFilter);
         mFilterMenu->addAction(action);
     }
     {
         QAction *action = new QAction(i18n("Filter on &To..."), this);
         actionCollection()->addAction(QStringLiteral("to_filter"), action);
         connect(action, &QAction::triggered, this, &KMMainWidget::slotToFilter);
         mFilterMenu->addAction(action);
     }
     {
         QAction *action = new QAction(i18n("Filter on &Cc..."), this);
         actionCollection()->addAction(QStringLiteral("cc_filter"), action);
         connect(action, &QAction::triggered, this, &KMMainWidget::slotCcFilter);
         mFilterMenu->addAction(action);
     }
     mFilterMenu->addAction(mMsgActions->listFilterAction());
 
     //----- "Mark Thread" submenu
     mThreadStatusMenu = new KActionMenu(i18n("Mark &Thread"), this);
     actionCollection()->addAction(QStringLiteral("thread_status"), mThreadStatusMenu);
 
     mMarkThreadAsReadAction = new QAction(QIcon::fromTheme(QStringLiteral("mail-mark-read")), i18n("Mark Thread as &Read"), this);
     actionCollection()->addAction(QStringLiteral("thread_read"), mMarkThreadAsReadAction);
     connect(mMarkThreadAsReadAction, &QAction::triggered, this, &KMMainWidget::slotSetThreadStatusRead);
     KMail::Util::addQActionHelpText(mMarkThreadAsReadAction, i18n("Mark all messages in the selected thread as read"));
     mThreadStatusMenu->addAction(mMarkThreadAsReadAction);
 
     mMarkThreadAsUnreadAction = new QAction(QIcon::fromTheme(QStringLiteral("mail-mark-unread")), i18n("Mark Thread as &Unread"), this);
     actionCollection()->addAction(QStringLiteral("thread_unread"), mMarkThreadAsUnreadAction);
     connect(mMarkThreadAsUnreadAction, &QAction::triggered, this, &KMMainWidget::slotSetThreadStatusUnread);
     KMail::Util::addQActionHelpText(mMarkThreadAsUnreadAction, i18n("Mark all messages in the selected thread as unread"));
     mThreadStatusMenu->addAction(mMarkThreadAsUnreadAction);
 
     mThreadStatusMenu->addSeparator();
 
     //----- "Mark Thread" toggle actions
     mToggleThreadImportantAction = new KToggleAction(QIcon::fromTheme(QStringLiteral("mail-mark-important")), i18n("Mark Thread as &Important"), this);
     actionCollection()->addAction(QStringLiteral("thread_flag"), mToggleThreadImportantAction);
     connect(mToggleThreadImportantAction, &KToggleAction::triggered, this, &KMMainWidget::slotSetThreadStatusImportant);
     mToggleThreadImportantAction->setCheckedState(KGuiItem(i18n("Remove &Important Thread Mark")));
     mThreadStatusMenu->addAction(mToggleThreadImportantAction);
 
     mToggleThreadToActAction = new KToggleAction(QIcon::fromTheme(QStringLiteral("mail-mark-task")), i18n("Mark Thread as &Action Item"), this);
     actionCollection()->addAction(QStringLiteral("thread_toact"), mToggleThreadToActAction);
     connect(mToggleThreadToActAction, &KToggleAction::triggered, this, &KMMainWidget::slotSetThreadStatusToAct);
     mToggleThreadToActAction->setCheckedState(KGuiItem(i18n("Remove &Action Item Thread Mark")));
     mThreadStatusMenu->addAction(mToggleThreadToActAction);
 
     //------- "Watch and ignore thread" actions
     mWatchThreadAction = new KToggleAction(QIcon::fromTheme(QStringLiteral("mail-thread-watch")), i18n("&Watch Thread"), this);
     actionCollection()->addAction(QStringLiteral("thread_watched"), mWatchThreadAction);
     connect(mWatchThreadAction, &KToggleAction::triggered, this, &KMMainWidget::slotSetThreadStatusWatched);
 
     mIgnoreThreadAction = new KToggleAction(QIcon::fromTheme(QStringLiteral("mail-thread-ignored")), i18n("&Ignore Thread"), this);
     actionCollection()->addAction(QStringLiteral("thread_ignored"), mIgnoreThreadAction);
     connect(mIgnoreThreadAction, &KToggleAction::triggered, this, &KMMainWidget::slotSetThreadStatusIgnored);
 
     mThreadStatusMenu->addSeparator();
     mThreadStatusMenu->addAction(mWatchThreadAction);
     mThreadStatusMenu->addAction(mIgnoreThreadAction);
 
     mSaveAttachmentsAction = new QAction(QIcon::fromTheme(QStringLiteral("mail-attachment")), i18n("Save A&ttachments..."), this);
     actionCollection()->addAction(QStringLiteral("file_save_attachments"), mSaveAttachmentsAction);
     connect(mSaveAttachmentsAction, &QAction::triggered, this, &KMMainWidget::slotSaveAttachments);
 
     mMoveActionMenu = mAkonadiStandardActionManager->action(Akonadi::StandardActionManager::MoveItemToMenu);
 
     mCopyActionMenu = mAkonadiStandardActionManager->action(Akonadi::StandardActionManager::CopyItemToMenu);
 
     mCopyDecryptedActionMenu = new KActionMenu(i18n("Copy Decrypted To..."), this);
     actionCollection()->addAction(QStringLiteral("copy_decrypted_to_menu"), mCopyDecryptedActionMenu);
     connect(mCopyDecryptedActionMenu->menu(), &QMenu::triggered,
             this, &KMMainWidget::slotCopyDecryptedTo);
 
     mApplyAllFiltersAction
         = new QAction(QIcon::fromTheme(QStringLiteral("view-filter")), i18n("Appl&y All Filters"), this);
     actionCollection()->addAction(QStringLiteral("apply_filters"), mApplyAllFiltersAction);
     connect(mApplyAllFiltersAction, &QAction::triggered,
             this, &KMMainWidget::slotApplyFilters);
     actionCollection()->setDefaultShortcut(mApplyAllFiltersAction, QKeySequence(Qt::CTRL + Qt::Key_J));
 
     mApplyFilterActionsMenu = new KActionMenu(i18n("A&pply Filter"), this);
     actionCollection()->addAction(QStringLiteral("apply_filter_actions"), mApplyFilterActionsMenu);
 
     {
         QAction *action = new QAction(i18nc("View->", "&Expand Thread / Group"), this);
         actionCollection()->addAction(QStringLiteral("expand_thread"), action);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::Key_Period));
         KMail::Util::addQActionHelpText(action, i18n("Expand the current thread or group"));
         connect(action, &QAction::triggered, this, &KMMainWidget::slotExpandThread);
     }
     {
         QAction *action = new QAction(i18nc("View->", "&Collapse Thread / Group"), this);
         actionCollection()->addAction(QStringLiteral("collapse_thread"), action);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::Key_Comma));
         KMail::Util::addQActionHelpText(action, i18n("Collapse the current thread or group"));
         connect(action, &QAction::triggered, this, &KMMainWidget::slotCollapseThread);
     }
     {
         QAction *action = new QAction(i18nc("View->", "Ex&pand All Threads"), this);
         actionCollection()->addAction(QStringLiteral("expand_all_threads"), action);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::CTRL + Qt::Key_Period));
         KMail::Util::addQActionHelpText(action, i18n("Expand all threads in the current folder"));
         connect(action, &QAction::triggered, this, &KMMainWidget::slotExpandAllThreads);
     }
     {
         QAction *action = new QAction(i18nc("View->", "C&ollapse All Threads"), this);
         actionCollection()->addAction(QStringLiteral("collapse_all_threads"), action);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::CTRL + Qt::Key_Comma));
         KMail::Util::addQActionHelpText(action, i18n("Collapse all threads in the current folder"));
         connect(action, &QAction::triggered, this, &KMMainWidget::slotCollapseAllThreads);
     }
 
     QAction *dukeOfMonmoth = new QAction(i18n("&Display Message"), this);
     actionCollection()->addAction(QStringLiteral("display_message"), dukeOfMonmoth);
     connect(dukeOfMonmoth, &QAction::triggered, this, &KMMainWidget::slotDisplayCurrentMessage);
     actionCollection()->setDefaultShortcuts(dukeOfMonmoth, QList<QKeySequence> {
         QKeySequence(Qt::Key_Enter),
         QKeySequence(Qt::Key_Return)
     });
 
     //----- Go Menu
     {
         QAction *action = new QAction(i18n("&Next Message"), this);
         actionCollection()->addAction(QStringLiteral("go_next_message"), action);
         actionCollection()->setDefaultShortcuts(action, QList<QKeySequence> {
             QKeySequence(Qt::Key_N),
             QKeySequence(Qt::Key_Right)
         });
         KMail::Util::addQActionHelpText(action, i18n("Go to the next message"));
         connect(action, &QAction::triggered, this, &KMMainWidget::slotSelectNextMessage);
     }
     {
         QAction *action = new QAction(i18n("Next &Unread Message"), this);
         actionCollection()->addAction(QStringLiteral("go_next_unread_message"), action);
         actionCollection()->setDefaultShortcuts(action, QList<QKeySequence> {
             QKeySequence(Qt::Key_Plus),
             QKeySequence(Qt::Key_Plus + Qt::KeypadModifier)
         });
         if (QApplication::isRightToLeft()) {
             action->setIcon(QIcon::fromTheme(QStringLiteral("go-previous")));
         } else {
             action->setIcon(QIcon::fromTheme(QStringLiteral("go-next")));
         }
         action->setIconText(i18nc("@action:inmenu Goto next unread message", "Next"));
         KMail::Util::addQActionHelpText(action, i18n("Go to the next unread message"));
         connect(action, &QAction::triggered, this, &KMMainWidget::slotSelectNextUnreadMessage);
     }
     {
         QAction *action = new QAction(i18n("&Previous Message"), this);
         actionCollection()->addAction(QStringLiteral("go_prev_message"), action);
         KMail::Util::addQActionHelpText(action, i18n("Go to the previous message"));
         actionCollection()->setDefaultShortcuts(action, QList<QKeySequence> {
             QKeySequence(Qt::Key_P),
             QKeySequence(Qt::Key_Left)
         });
         connect(action, &QAction::triggered, this, &KMMainWidget::slotSelectPreviousMessage);
     }
     {
         QAction *action = new QAction(i18n("Previous Unread &Message"), this);
         actionCollection()->addAction(QStringLiteral("go_prev_unread_message"), action);
         actionCollection()->setDefaultShortcuts(action, QList<QKeySequence> {
             QKeySequence(Qt::Key_Minus),
             QKeySequence(Qt::Key_Minus + Qt::KeypadModifier)
         });
         if (QApplication::isRightToLeft()) {
             action->setIcon(QIcon::fromTheme(QStringLiteral("go-next")));
         } else {
             action->setIcon(QIcon::fromTheme(QStringLiteral("go-previous")));
         }
         action->setIconText(i18nc("@action:inmenu Goto previous unread message.", "Previous"));
         KMail::Util::addQActionHelpText(action, i18n("Go to the previous unread message"));
         connect(action, &QAction::triggered, this, &KMMainWidget::slotSelectPreviousUnreadMessage);
     }
     {
         QAction *action = new QAction(i18n("Next Unread &Folder"), this);
         actionCollection()->addAction(QStringLiteral("go_next_unread_folder"), action);
         connect(action, &QAction::triggered, this, &KMMainWidget::slotNextUnreadFolder);
         actionCollection()->setDefaultShortcuts(action, QList<QKeySequence> {
             QKeySequence(Qt::ALT + Qt::Key_Plus),
             QKeySequence(Qt::ALT + Qt::Key_Plus + Qt::KeypadModifier)
         });
         KMail::Util::addQActionHelpText(action, i18n("Go to the next folder with unread messages"));
     }
     {
         QAction *action = new QAction(i18n("Previous Unread F&older"), this);
         actionCollection()->addAction(QStringLiteral("go_prev_unread_folder"), action);
         actionCollection()->setDefaultShortcuts(action, QList<QKeySequence> {
             QKeySequence(Qt::ALT + Qt::Key_Minus),
             QKeySequence(Qt::ALT + Qt::Key_Minus + Qt::KeypadModifier)
         });
         KMail::Util::addQActionHelpText(action, i18n("Go to the previous folder with unread messages"));
         connect(action, &QAction::triggered, this, &KMMainWidget::slotPrevUnreadFolder);
     }
     {
         QAction *action = new QAction(i18nc("Go->", "Next Unread &Text"), this);
         actionCollection()->addAction(QStringLiteral("go_next_unread_text"), action);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::Key_Space));
         KMail::Util::addQActionHelpText(action, i18n("Go to the next unread text"));
         action->setWhatsThis(i18n("Scroll down current message. "
                                   "If at end of current message, "
                                   "go to next unread message."));
         connect(action, &QAction::triggered, this, &KMMainWidget::slotReadOn);
     }
 
     //----- Settings Menu
     {
         QAction *action = new QAction(i18n("Configure &Filters..."), this);
         action->setMenuRole(QAction::NoRole);   // do not move to application menu on OS X
         actionCollection()->addAction(QStringLiteral("filter"), action);
         connect(action, &QAction::triggered, this, &KMMainWidget::slotFilter);
     }
     {
         QAction *action = new QAction(i18n("Manage &Sieve Scripts..."), this);
         actionCollection()->addAction(QStringLiteral("sieveFilters"), action);
         connect(action, &QAction::triggered, this, &KMMainWidget::slotManageSieveScripts);
     }
     {
         QAction *action = new QAction(i18n("&Add Account..."), this);
         actionCollection()->addAction(QStringLiteral("accountWizard"), action);
         connect(action, &QAction::triggered, mLaunchExternalComponent, &KMLaunchExternalComponent::slotAccountWizard);
     }
     {
         mShowIntroductionAction = new QAction(QIcon::fromTheme(QStringLiteral("kmail")), i18n("KMail &Introduction"), this);
         actionCollection()->addAction(QStringLiteral("help_kmail_welcomepage"), mShowIntroductionAction);
         KMail::Util::addQActionHelpText(mShowIntroductionAction, i18n("Display KMail's Welcome Page"));
         connect(mShowIntroductionAction, &QAction::triggered, this, &KMMainWidget::slotIntro);
         mShowIntroductionAction->setEnabled(mMsgView != nullptr);
     }
 
     // ----- Standard Actions
     {
         QAction *action = new QAction(QIcon::fromTheme(QStringLiteral("preferences-desktop-notification")),
                                       i18n("Configure &Notifications..."), this);
         action->setMenuRole(QAction::NoRole);   // do not move to application menu on OS X
         actionCollection()->addAction(QStringLiteral("kmail_configure_notifications"), action);
         connect(action, &QAction::triggered, this, &KMMainWidget::slotEditNotifications);
     }
 
     {
         QAction *action = new QAction(QIcon::fromTheme(QStringLiteral("configure")), i18n("&Configure KMail..."), this);
         action->setMenuRole(QAction::PreferencesRole);   // this one should move to the application menu on OS X
         actionCollection()->addAction(QStringLiteral("kmail_configure_kmail"), action);
         connect(action, &QAction::triggered, kmkernel, &KMKernel::slotShowConfigurationDialog);
     }
 
     {
         mExpireConfigAction = new QAction(i18n("Expire..."), this);
         actionCollection()->addAction(QStringLiteral("expire_settings"), mExpireConfigAction);
         connect(mExpireConfigAction, &QAction::triggered, mManageShowCollectionProperties, &ManageShowCollectionProperties::slotShowExpiryProperties);
     }
 
     {
         QAction *action = new QAction(QIcon::fromTheme(QStringLiteral("bookmark-new")), i18n("Add Favorite Folder..."), this);
         actionCollection()->addAction(QStringLiteral("add_favorite_folder"), action);
         connect(action, &QAction::triggered, this, &KMMainWidget::slotAddFavoriteFolder);
     }
 
     {
         mServerSideSubscription = new QAction(QIcon::fromTheme(QStringLiteral("folder-bookmarks")), i18n("Serverside Subscription..."), this);
         actionCollection()->addAction(QStringLiteral("serverside_subscription"), mServerSideSubscription);
         connect(mServerSideSubscription, &QAction::triggered, this, &KMMainWidget::slotServerSideSubscription);
     }
 
     {
         mApplyAllFiltersFolderAction = new QAction(QIcon::fromTheme(QStringLiteral("view-filter")), i18n("Apply All Filters"), this);
         actionCollection()->addAction(QStringLiteral("apply_filters_folder"), mApplyAllFiltersFolderAction);
         connect(mApplyAllFiltersFolderAction, &QAction::triggered,
                 this, [this] {
             slotApplyFiltersOnFolder(/* recursive */ false);
         });
     }
 
     {
         mApplyAllFiltersFolderRecursiveAction = new QAction(QIcon::fromTheme(QStringLiteral("view-filter")), i18n("Apply All Filters"), this);
         actionCollection()->addAction(QStringLiteral("apply_filters_folder_recursive"), mApplyAllFiltersFolderRecursiveAction);
         connect(mApplyAllFiltersFolderRecursiveAction, &QAction::triggered,
                 this, [this] {
             slotApplyFiltersOnFolder(/* recursive */ true);
         });
     }
 
     {
         mApplyFilterFolderActionsMenu = new KActionMenu(i18n("Apply Filters on Folder"), this);
         actionCollection()->addAction(QStringLiteral("apply_filters_on_folder_actions"), mApplyFilterFolderActionsMenu);
     }
 
     {
         mApplyFilterFolderRecursiveActionsMenu = new KActionMenu(i18n("Apply Filters on Folder and all its Subfolders"), this);
         actionCollection()->addAction(QStringLiteral("apply_filters_on_folder_recursive_actions"), mApplyFilterFolderRecursiveActionsMenu);
     }
 
     {
         QAction *action = new QAction(QIcon::fromTheme(QStringLiteral("kontact")), i18n("Import/Export KMail Data..."), this);
         actionCollection()->addAction(QStringLiteral("kmail_export_data"), action);
         connect(action, &QAction::triggered, mLaunchExternalComponent, &KMLaunchExternalComponent::slotExportData);
     }
 
     {
         QAction *action = new QAction(QIcon::fromTheme(QStringLiteral("contact-new")), i18n("New AddressBook Contact..."), this);
         actionCollection()->addAction(QStringLiteral("kmail_new_addressbook_contact"), action);
         connect(action, &QAction::triggered, this, &KMMainWidget::slotCreateAddressBookContact);
     }
 
     QAction *act = actionCollection()->addAction(KStandardAction::Undo, QStringLiteral("kmail_undo"));
     connect(act, &QAction::triggered, this, &KMMainWidget::slotUndo);
 
     menutimer = new QTimer(this);
     menutimer->setObjectName(QStringLiteral("menutimer"));
     menutimer->setSingleShot(true);
     connect(menutimer, &QTimer::timeout, this, &KMMainWidget::updateMessageActionsDelayed);
     connect(kmkernel->undoStack(),
             &KMail::UndoStack::undoStackChanged, this, &KMMainWidget::slotUpdateUndo);
 
     updateMessageActions();
     updateFolderMenu();
     mTagActionManager = new KMail::TagActionManager(this, actionCollection(), mMsgActions,
                                                     mGUIClient);
     mFolderShortcutActionManager = new KMail::FolderShortcutActionManager(this, actionCollection());
 
     {
         QAction *action = new QAction(i18n("Copy Message to Folder"), this);
         actionCollection()->addAction(QStringLiteral("copy_message_to_folder"), action);
         connect(action, &QAction::triggered,
                 this, &KMMainWidget::slotCopySelectedMessagesToFolder);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::Key_C));
     }
     {
         QAction *action = new QAction(i18n("Jump to Folder..."), this);
         actionCollection()->addAction(QStringLiteral("jump_to_folder"), action);
         connect(action, &QAction::triggered,
                 this, &KMMainWidget::slotJumpToFolder);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::Key_J));
     }
     {
         QAction *action = new QAction(i18n("Abort Current Operation"), this);
         actionCollection()->addAction(QStringLiteral("cancel"), action);
         connect(action, &QAction::triggered,
                 ProgressManager::instance(), &KPIM::ProgressManager::slotAbortAll);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::Key_Escape));
     }
     {
         QAction *action = new QAction(i18n("Focus on Next Folder"), this);
         actionCollection()->addAction(QStringLiteral("inc_current_folder"), action);
         connect(action, &QAction::triggered,
                 mFolderTreeWidget->folderTreeView(), &FolderTreeView::slotFocusNextFolder);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::CTRL + Qt::Key_Right));
     }
     {
         QAction *action = new QAction(i18n("Focus on Previous Folder"), this);
         actionCollection()->addAction(QStringLiteral("dec_current_folder"), action);
         connect(action, &QAction::triggered,
                 mFolderTreeWidget->folderTreeView(), &FolderTreeView::slotFocusPrevFolder);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::CTRL + Qt::Key_Left));
     }
     {
         QAction *action = new QAction(i18n("Select Folder with Focus"), this);
         actionCollection()->addAction(QStringLiteral("select_current_folder"), action);
 
         connect(action, &QAction::triggered,
                 mFolderTreeWidget->folderTreeView(), &FolderTreeView::slotSelectFocusFolder);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::CTRL + Qt::Key_Space));
     }
     {
         QAction *action = new QAction(i18n("Focus on First Folder"), this);
         actionCollection()->addAction(QStringLiteral("focus_first_folder"), action);
         connect(action, &QAction::triggered,
                 mFolderTreeWidget->folderTreeView(), &FolderTreeView::slotFocusFirstFolder);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::CTRL + Qt::Key_Home));
     }
     {
         QAction *action = new QAction(i18n("Focus on Last Folder"), this);
         actionCollection()->addAction(QStringLiteral("focus_last_folder"), action);
         connect(action, &QAction::triggered,
                 mFolderTreeWidget->folderTreeView(), &FolderTreeView::slotFocusLastFolder);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::CTRL + Qt::Key_End));
     }
     {
         QAction *action = new QAction(i18n("Focus on Next Message"), this);
         actionCollection()->addAction(QStringLiteral("inc_current_message"), action);
         connect(action, &QAction::triggered,
                 this, &KMMainWidget::slotFocusOnNextMessage);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::ALT + Qt::Key_Right));
     }
     {
         QAction *action = new QAction(i18n("Focus on Previous Message"), this);
         actionCollection()->addAction(QStringLiteral("dec_current_message"), action);
         connect(action, &QAction::triggered,
                 this, &KMMainWidget::slotFocusOnPrevMessage);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::ALT + Qt::Key_Left));
     }
     {
         QAction *action = new QAction(i18n("Select First Message"), this);
         actionCollection()->addAction(QStringLiteral("select_first_message"), action);
         connect(action, &QAction::triggered,
                 this, &KMMainWidget::slotSelectFirstMessage);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::ALT + Qt::Key_Home));
     }
     {
         QAction *action = new QAction(i18n("Select Last Message"), this);
         actionCollection()->addAction(QStringLiteral("select_last_message"), action);
         connect(action, &QAction::triggered,
                 this, &KMMainWidget::slotSelectLastMessage);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::ALT + Qt::Key_End));
     }
     {
         QAction *action = new QAction(i18n("Select Message with Focus"), this);
         actionCollection()->addAction(QStringLiteral("select_current_message"), action);
         connect(action, &QAction::triggered,
                 this, &KMMainWidget::slotSelectFocusedMessage);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::ALT + Qt::Key_Space));
     }
 
     {
         mQuickSearchAction = new QAction(i18n("Set Focus to Quick Search"), this);
         //If change shortcut change Panel::setQuickSearchClickMessage(...) message
         actionCollection()->setDefaultShortcut(mQuickSearchAction, QKeySequence(Qt::ALT + Qt::Key_Q));
         actionCollection()->addAction(QStringLiteral("focus_to_quickseach"), mQuickSearchAction);
         connect(mQuickSearchAction, &QAction::triggered,
                 this, &KMMainWidget::slotFocusQuickSearch);
         updateQuickSearchLineText();
     }
     {
         QAction *action = new QAction(i18n("Extend Selection to Previous Message"), this);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::SHIFT + Qt::Key_Left));
         actionCollection()->addAction(QStringLiteral("previous_message"), action);
         connect(action, &QAction::triggered,
                 this, &KMMainWidget::slotExtendSelectionToPreviousMessage);
     }
     {
         QAction *action = new QAction(i18n("Extend Selection to Next Message"), this);
         actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::SHIFT + Qt::Key_Right));
         actionCollection()->addAction(QStringLiteral("next_message"), action);
         connect(action, &QAction::triggered,
                 this, &KMMainWidget::slotExtendSelectionToNextMessage);
     }
 
     {
         mMoveMsgToFolderAction = new QAction(i18n("Move Message to Folder"), this);
         actionCollection()->setDefaultShortcut(mMoveMsgToFolderAction, QKeySequence(Qt::Key_M));
         actionCollection()->addAction(QStringLiteral("move_message_to_folder"), mMoveMsgToFolderAction);
         connect(mMoveMsgToFolderAction, &QAction::triggered,
                 this, &KMMainWidget::slotMoveSelectedMessageToFolder);
     }
 
     mArchiveAction = new QAction(i18nc("@action", "Archive"), this);
     actionCollection()->addAction(QStringLiteral("archive_mails"), mArchiveAction);
     connect(mArchiveAction, &QAction::triggered, this, &KMMainWidget::slotArchiveMails);
 
     mUseLessBandwidth = new KToggleAction(i18n("Use Less Bandwidth"), this);
     actionCollection()->addAction(QStringLiteral("low_bandwidth"), mUseLessBandwidth);
     connect(mUseLessBandwidth, &KToggleAction::triggered, this, &KMMainWidget::slotBandwidth);
 
     mMarkAllMessageAsReadAndInAllSubFolder = new QAction(i18n("Mark All Messages As Read in This Folder and All its Subfolder"), this);
     mMarkAllMessageAsReadAndInAllSubFolder->setIcon(QIcon::fromTheme(QStringLiteral("mail-mark-read")));
     actionCollection()->addAction(QStringLiteral("markallmessagereadcurentfolderandsubfolder"), mMarkAllMessageAsReadAndInAllSubFolder);
     connect(mMarkAllMessageAsReadAndInAllSubFolder, &KToggleAction::triggered, this, &KMMainWidget::slotMarkAllMessageAsReadInCurrentFolderAndSubfolder);
 
     mRemoveDuplicateRecursiveAction = new QAction(i18n("Remove Duplicates in This Folder and All its Subfolder"), this);
     actionCollection()->addAction(QStringLiteral("remove_duplicate_recursive"), mRemoveDuplicateRecursiveAction);
     connect(mRemoveDuplicateRecursiveAction, &KToggleAction::triggered, this, &KMMainWidget::slotRemoveDuplicateRecursive);
 }
 
 void KMMainWidget::slotAddFavoriteFolder()
 {
     if (!mFavoritesModel) {
         return;
     }
     QPointer<MailCommon::FolderSelectionDialog> dialog(selectFromAllFoldersDialog());
     dialog->setWindowTitle(i18n("Add Favorite Folder"));
     if (dialog->exec() && dialog) {
         const Akonadi::Collection collection = dialog->selectedCollection();
         if (collection.isValid()) {
             mFavoritesModel->addCollection(collection);
         }
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotEditNotifications()
 {
     QPointer<KMail::KMKnotify> notifyDlg = new KMail::KMKnotify(this);
     notifyDlg->exec();
     delete notifyDlg;
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotReadOn()
 {
     if (!mMsgView) {
         return;
     }
     mMsgView->viewer()->atBottom();
 }
 
 void KMMainWidget::slotPageIsScrolledToBottom(bool isAtBottom)
 {
     if (isAtBottom) {
         slotSelectNextUnreadMessage();
     } else {
         mMsgView->viewer()->slotJumpDown();
     }
 }
 
 void KMMainWidget::slotNextUnreadFolder()
 {
     if (!mFolderTreeWidget) {
         return;
     }
     mGoToFirstUnreadMessageInSelectedFolder = true;
     mFolderTreeWidget->folderTreeView()->selectNextUnreadFolder();
     mGoToFirstUnreadMessageInSelectedFolder = false;
 }
 
 void KMMainWidget::slotPrevUnreadFolder()
 {
     if (!mFolderTreeWidget) {
         return;
     }
     mGoToFirstUnreadMessageInSelectedFolder = true;
     mFolderTreeWidget->folderTreeView()->selectPrevUnreadFolder();
     mGoToFirstUnreadMessageInSelectedFolder = false;
 }
 
 void KMMainWidget::slotExpandThread()
 {
     mMessagePane->setCurrentThreadExpanded(true);
 }
 
 void KMMainWidget::slotCollapseThread()
 {
     mMessagePane->setCurrentThreadExpanded(false);
 }
 
 void KMMainWidget::slotExpandAllThreads()
 {
     // TODO: Make this asynchronous ? (if there is enough demand)
 #ifndef QT_NO_CURSOR
     KPIM::KCursorSaver busy(KPIM::KBusyPtr::busy());
 #endif
     mMessagePane->setAllThreadsExpanded(true);
 }
 
 void KMMainWidget::slotCollapseAllThreads()
 {
     // TODO: Make this asynchronous ? (if there is enough demand)
 #ifndef QT_NO_CURSOR
     KPIM::KCursorSaver busy(KPIM::KBusyPtr::busy());
 #endif
     mMessagePane->setAllThreadsExpanded(false);
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::updateMessageMenu()
 {
     updateMessageActions();
 }
 
 void KMMainWidget::startUpdateMessageActionsTimer()
 {
     // FIXME: This delay effectively CAN make the actions to be in an incoherent state
     //        Maybe we should mark actions as "dirty" here and check it in every action handler...
     updateMessageActions(true);
 
     menutimer->stop();
     menutimer->start(500);
 }
 
 void KMMainWidget::updateMessageActions(bool fast)
 {
     Akonadi::Item::List selectedItems;
     Akonadi::Item::List selectedVisibleItems;
     bool allSelectedBelongToSameThread = false;
     if (mCurrentFolderSettings && mCurrentFolderSettings->isValid()
         && mMessagePane->getSelectionStats(selectedItems, selectedVisibleItems, &allSelectedBelongToSameThread)
         ) {
         mMsgActions->setCurrentMessage(mMessagePane->currentItem(), selectedVisibleItems);
     } else {
         mMsgActions->setCurrentMessage(Akonadi::Item());
     }
 
     if (!fast) {
         updateMessageActionsDelayed();
     }
 }
 
 void KMMainWidget::updateMessageActionsDelayed()
 {
     int count;
     Akonadi::Item::List selectedItems;
     Akonadi::Item::List selectedVisibleItems;
     bool allSelectedBelongToSameThread = false;
     Akonadi::Item currentMessage;
     bool currentFolderSettingsIsValid = mCurrentFolderSettings && mCurrentFolderSettings->isValid();
     if (currentFolderSettingsIsValid
         && mMessagePane->getSelectionStats(selectedItems, selectedVisibleItems, &allSelectedBelongToSameThread)
         ) {
         count = selectedItems.count();
 
         currentMessage = mMessagePane->currentItem();
     } else {
         count = 0;
         currentMessage = Akonadi::Item();
     }
 
     mApplyFilterActionsMenu->setEnabled(currentFolderSettingsIsValid);
     mApplyFilterFolderRecursiveActionsMenu->setEnabled(currentFolderSettingsIsValid);
 
     //
     // Here we have:
     //
     // - A list of selected messages stored in selectedSernums.
     //   The selected messages might contain some invisible ones as a selected
     //   collapsed node "includes" all the children in the selection.
     // - A list of selected AND visible messages stored in selectedVisibleSernums.
     //   This list does not contain children of selected and collapsed nodes.
     //
     // Now, actions can operate on:
     // - Any set of messages
     //     These are called "mass actions" and are enabled whenever we have a message selected.
     //     In fact we should differentiate between actions that operate on visible selection
     //     and those that operate on the selection as a whole (without considering visibility)...
     // - A single thread
     //     These are called "thread actions" and are enabled whenever all the selected messages belong
     //     to the same thread. If the selection doesn't cover the whole thread then the action
     //     will act on the whole thread anyway (thus will silently extend the selection)
     // - A single message
     //     And we have two sub-cases:
     //     - The selection must contain exactly one message
     //       These actions can't ignore the hidden messages and thus must be disabled if
     //       the selection contains any.
     //     - The selection must contain exactly one visible message
     //       These actions will ignore the hidden message and thus can be enabled if
     //       the selection contains any.
     //
 
     const bool readOnly = currentFolderSettingsIsValid && (mCurrentFolderSettings->rights() & Akonadi::Collection::ReadOnly);
     // can we apply strictly single message actions ? (this is false if the whole selection contains more than one message)
     const bool single_actions = count == 1;
     // can we apply loosely single message actions ? (this is false if the VISIBLE selection contains more than one message)
     const bool singleVisibleMessageSelected = selectedVisibleItems.count() == 1;
     // can we apply "mass" actions to the selection ? (this is actually always true if the selection is non-empty)
     const bool mass_actions = count >= 1;
     // does the selection identify a single thread ?
     const bool thread_actions = mass_actions && allSelectedBelongToSameThread && mMessagePane->isThreaded();
     // can we apply flags to the selected messages ?
     const bool flags_available = KMailSettings::self()->allowLocalFlags() || !(currentFolderSettingsIsValid ? readOnly : true);
 
     mThreadStatusMenu->setEnabled(thread_actions);
     // these need to be handled individually, the user might have them
     // in the toolbar
     mWatchThreadAction->setEnabled(thread_actions && flags_available);
     mIgnoreThreadAction->setEnabled(thread_actions && flags_available);
     mMarkThreadAsReadAction->setEnabled(thread_actions);
     mMarkThreadAsUnreadAction->setEnabled(thread_actions);
     mToggleThreadToActAction->setEnabled(thread_actions && flags_available);
     mToggleThreadImportantAction->setEnabled(thread_actions && flags_available);
     bool canDeleteMessages = currentFolderSettingsIsValid && (mCurrentFolderSettings->rights() & Akonadi::Collection::CanDeleteItem);
 
     mTrashThreadAction->setEnabled(thread_actions && canDeleteMessages);
     mDeleteThreadAction->setEnabled(thread_actions && canDeleteMessages);
     if (messageView() && messageView()->viewer() && messageView()->viewer()->headerStylePlugin()) {
         messageView()->viewer()->headerStylePlugin()->headerStyle()->setReadOnlyMessage(!canDeleteMessages);
     }
 
     if (currentMessage.isValid()) {
         MessageStatus status;
         status.setStatusFromFlags(currentMessage.flags());
         mTagActionManager->updateActionStates(count, mMessagePane->currentItem());
         if (thread_actions) {
             mToggleThreadToActAction->setChecked(status.isToAct());
             mToggleThreadImportantAction->setChecked(status.isImportant());
             mWatchThreadAction->setChecked(status.isWatched());
             mIgnoreThreadAction->setChecked(status.isIgnored());
         }
     }
 
     mMoveActionMenu->setEnabled(mass_actions && canDeleteMessages);
     if (mMoveMsgToFolderAction) {
         mMoveMsgToFolderAction->setEnabled(mass_actions && canDeleteMessages);
     }
     //mCopyActionMenu->setEnabled( mass_actions );
 
     mDeleteAction->setEnabled(mass_actions && canDeleteMessages);
 
     mExpireConfigAction->setEnabled(canDeleteMessages);
 
     if (mMsgView) {
         mMsgView->findInMessageAction()->setEnabled(mass_actions && !CommonKernel->folderIsTemplates(mCurrentCollection));
     }
     mMsgActions->forwardInlineAction()->setEnabled(mass_actions && !CommonKernel->folderIsTemplates(mCurrentCollection));
     mMsgActions->forwardAttachedAction()->setEnabled(mass_actions && !CommonKernel->folderIsTemplates(mCurrentCollection));
     mMsgActions->forwardMenu()->setEnabled(mass_actions && !CommonKernel->folderIsTemplates(mCurrentCollection));
 
     mMsgActions->newMessageFromTemplateAction()->setEnabled(single_actions && CommonKernel->folderIsTemplates(mCurrentCollection));
     filterMenu()->setEnabled(single_actions);
     mMsgActions->redirectAction()->setEnabled(/*single_actions &&*/ mass_actions && !CommonKernel->folderIsTemplates(mCurrentCollection));
 
     if (auto *menuCustom = mMsgActions->customTemplatesMenu()) {
         menuCustom->forwardActionMenu()->setEnabled(mass_actions);
         menuCustom->replyActionMenu()->setEnabled(single_actions);
         menuCustom->replyAllActionMenu()->setEnabled(single_actions);
     }
 
     // "Print" will act on the current message: it will ignore any hidden selection
     mMsgActions->printAction()->setEnabled(singleVisibleMessageSelected);
     // "Print preview" will act on the current message: it will ignore any hidden selection
     if (QAction *printPreviewAction = mMsgActions->printPreviewAction()) {
         printPreviewAction->setEnabled(singleVisibleMessageSelected);
     }
 
     // "View Source" will act on the current message: it will ignore any hidden selection
     if (mMsgView) {
         mMsgView->viewSourceAction()->setEnabled(singleVisibleMessageSelected);
         mMsgView->selectAllAction()->setEnabled(count);
     }
     MessageStatus status;
     status.setStatusFromFlags(currentMessage.flags());
 
     QList< QAction *> actionList;
     bool statusSendAgain = single_actions && ((currentMessage.isValid() && status.isSent()) || (currentMessage.isValid() && CommonKernel->folderIsSentMailFolder(mCurrentCollection)));
     if (statusSendAgain) {
         actionList << mMsgActions->sendAgainAction();
     }
     if (single_actions) {
         actionList << mSaveAttachmentsAction;
     }
     if (mCurrentCollection.isValid() && FolderArchive::FolderArchiveUtil::resourceSupportArchiving(mCurrentCollection.resource())) {
         actionList << mArchiveAction;
     }
     mGUIClient->unplugActionList(QStringLiteral("messagelist_actionlist"));
     mGUIClient->plugActionList(QStringLiteral("messagelist_actionlist"), actionList);
     mMsgActions->sendAgainAction()->setEnabled(statusSendAgain);
 
     mSaveAsAction->setEnabled(single_actions);
 
     if (currentFolderSettingsIsValid) {
         updateMoveAction(mCurrentFolderSettings->statistics());
     } else {
         updateMoveAction(false);
     }
 
     const auto col = CommonKernel->collectionFromId(CommonKernel->outboxCollectionFolder().id());
     const bool nbMsgOutboxCollectionIsNotNull = (col.statistics().count() > 0);
 
     mSendQueued->setEnabled(nbMsgOutboxCollectionIsNotNull);
     mSendActionMenu->setEnabled(nbMsgOutboxCollectionIsNotNull);
 
     const bool newPostToMailingList = mCurrentFolderSettings && mCurrentFolderSettings->isMailingListEnabled();
     mMessageNewList->setEnabled(newPostToMailingList);
 
     slotUpdateOnlineStatus(static_cast<GlobalSettingsBase::EnumNetworkState::type>(KMailSettings::self()->networkState()));
     if (QAction *act = action(QStringLiteral("kmail_undo"))) {
         act->setEnabled(kmkernel->undoStack() && !kmkernel->undoStack()->isEmpty());
     }
 
     // Enable / disable all filters.
     for (QAction *filterAction : qAsConst(mFilterMenuActions)) {
         filterAction->setEnabled(count > 0);
     }
 
     mApplyAllFiltersAction->setEnabled(count);
     mApplyFilterActionsMenu->setEnabled(count);
     mSelectAllMessages->setEnabled(count);
 
     if (currentMessage.hasFlag(Akonadi::MessageFlags::Encrypted) || count > 1) {
         mCopyDecryptedActionMenu->setVisible(true);
         mCopyDecryptedActionMenu->menu()->clear();
         mAkonadiStandardActionManager->standardActionManager()->createActionFolderMenu(
             mCopyDecryptedActionMenu->menu(),
             Akonadi::StandardActionManager::CopyItemToMenu);
     } else {
         mCopyDecryptedActionMenu->setVisible(false);
     }
 }
 
 void KMMainWidget::slotAkonadiStandardActionUpdated()
 {
     if (mCollectionProperties) {
         if (mCurrentCollection.isValid()) {
             const Akonadi::AgentInstance instance
                 = Akonadi::AgentManager::self()->instance(mCurrentCollection.resource());
 
             mCollectionProperties->setEnabled(!mCurrentFolderSettings->isStructural()
                                               && (instance.status() != Akonadi::AgentInstance::Broken));
         } else {
             mCollectionProperties->setEnabled(false);
         }
         QList< QAction * > collectionProperties;
         if (mCollectionProperties->isEnabled()) {
             collectionProperties << mCollectionProperties;
         }
         mGUIClient->unplugActionList(QStringLiteral("akonadi_collection_collectionproperties_actionlist"));
         mGUIClient->plugActionList(QStringLiteral("akonadi_collection_collectionproperties_actionlist"), collectionProperties);
     }
 
     const bool folderWithContent = mCurrentFolderSettings && !mCurrentFolderSettings->isStructural();
 
     if (QAction *act = mAkonadiStandardActionManager->action(Akonadi::StandardActionManager::DeleteCollections)) {
         act->setEnabled(mCurrentFolderSettings
                         && (mCurrentCollection.rights() & Collection::CanDeleteCollection)
                         && !mCurrentFolderSettings->isSystemFolder()
                         && folderWithContent);
     }
 
     if (QAction *act = mAkonadiStandardActionManager->action(Akonadi::StandardMailActionManager::MoveAllToTrash)) {
         act->setEnabled(folderWithContent
                         && (mCurrentFolderSettings->count() > 0)
                         && mCurrentFolderSettings->canDeleteMessages());
         act->setText((mCurrentFolderSettings
                       && CommonKernel->folderIsTrash(mCurrentCollection)) ? i18n("E&mpty Trash") : i18n(
                          "&Move All Messages to Trash"));
     }
 
     QList< QAction * > addToFavorite;
     QAction *actionAddToFavoriteCollections = akonadiStandardAction(Akonadi::StandardActionManager::AddToFavoriteCollections);
     if (actionAddToFavoriteCollections) {
         if (mEnableFavoriteFolderView && actionAddToFavoriteCollections->isEnabled()) {
             addToFavorite << actionAddToFavoriteCollections;
         }
         mGUIClient->unplugActionList(QStringLiteral("akonadi_collection_add_to_favorites_actionlist"));
         mGUIClient->plugActionList(QStringLiteral("akonadi_collection_add_to_favorites_actionlist"), addToFavorite);
     }
 
     QList< QAction * > syncActionList;
     QAction *actionSync = akonadiStandardAction(Akonadi::StandardActionManager::SynchronizeCollections);
     if (actionSync && actionSync->isEnabled()) {
         syncActionList << actionSync;
     }
     actionSync = akonadiStandardAction(Akonadi::StandardActionManager::SynchronizeCollectionsRecursive);
     if (actionSync && actionSync->isEnabled()) {
         syncActionList << actionSync;
     }
     mGUIClient->unplugActionList(QStringLiteral("akonadi_collection_sync_actionlist"));
     mGUIClient->plugActionList(QStringLiteral("akonadi_collection_sync_actionlist"), syncActionList);
 
     QList< QAction * > actionList;
 
     QAction *action = mAkonadiStandardActionManager->action(Akonadi::StandardActionManager::CreateCollection);
     if (action && action->isEnabled()) {
         actionList << action;
     }
 
     action = mAkonadiStandardActionManager->action(Akonadi::StandardActionManager::MoveCollectionToMenu);
     if (action && action->isEnabled()) {
         actionList << action;
     }
 
     action = mAkonadiStandardActionManager->action(Akonadi::StandardActionManager::CopyCollectionToMenu);
     if (action && action->isEnabled()) {
         actionList << action;
     }
     mGUIClient->unplugActionList(QStringLiteral("akonadi_collection_move_copy_menu_actionlist"));
     mGUIClient->plugActionList(QStringLiteral("akonadi_collection_move_copy_menu_actionlist"), actionList);
 }
 
 void KMMainWidget::updateHtmlMenuEntry()
 {
     if (mDisplayMessageFormatMenu && mPreferHtmlLoadExtAction) {
         // the visual ones only make sense if we are showing a message list
         const bool enabledAction = (mFolderTreeWidget
                                     && mFolderTreeWidget->folderTreeView()->currentFolder().isValid());
 
         mDisplayMessageFormatMenu->setEnabled(enabledAction);
         const bool isEnabled = (mFolderTreeWidget
                                 && mFolderTreeWidget->folderTreeView()->currentFolder().isValid());
         const bool useHtml = (mFolderDisplayFormatPreference == MessageViewer::Viewer::Html || (mHtmlGlobalSetting && mFolderDisplayFormatPreference == MessageViewer::Viewer::UseGlobalSetting));
         mPreferHtmlLoadExtAction->setEnabled(isEnabled && useHtml);
 
         mDisplayMessageFormatMenu->setDisplayMessageFormat(mFolderDisplayFormatPreference);
 
         mPreferHtmlLoadExtAction->setChecked((mHtmlLoadExtGlobalSetting ? !mFolderHtmlLoadExtPreference : mFolderHtmlLoadExtPreference));
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::updateFolderMenu()
 {
     if (!CommonKernel->outboxCollectionFolder().isValid()) {
         QTimer::singleShot(1000, this, &KMMainWidget::updateFolderMenu);
         return;
     }
 
     const bool folderWithContent = mCurrentFolderSettings
                                    && !mCurrentFolderSettings->isStructural()
                                    && mCurrentFolderSettings->isValid();
     mFolderMailingListPropertiesAction->setEnabled(folderWithContent
                                                    && !mCurrentFolderSettings->isSystemFolder());
 
     QList< QAction * > actionlist;
     if (mCurrentCollection.id() == CommonKernel->outboxCollectionFolder().id() && (mCurrentCollection).statistics().count() > 0) {
         qCDebug(KMAIL_LOG) << "Enabling send queued";
         mSendQueued->setEnabled(true);
         actionlist << mSendQueued;
     }
     //   if ( mCurrentCollection.id() != CommonKernel->trashCollectionFolder().id() ) {
     //     actionlist << mTrashAction;
     //   }
     mGUIClient->unplugActionList(QStringLiteral("outbox_folder_actionlist"));
     mGUIClient->plugActionList(QStringLiteral("outbox_folder_actionlist"), actionlist);
     actionlist.clear();
 
     const bool isASearchFolder = mCurrentCollection.resource() == QLatin1String("akonadi_search_resource");
     if (isASearchFolder) {
         mAkonadiStandardActionManager->action(Akonadi::StandardActionManager::DeleteCollections)->setText(i18n("&Delete Search"));
     }
 
     mArchiveFolderAction->setEnabled(mCurrentFolderSettings && folderWithContent);
 
     const bool isInTrashFolder = (mCurrentFolderSettings && CommonKernel->folderIsTrash(mCurrentCollection));
     QAction *moveToTrash = akonadiStandardAction(Akonadi::StandardMailActionManager::MoveToTrash);
     KMail::Util::setActionTrashOrDelete(moveToTrash, isInTrashFolder);
 
     mTrashThreadAction->setIcon(isInTrashFolder ? QIcon::fromTheme(QStringLiteral("edit-delete")) : QIcon::fromTheme(QStringLiteral("user-trash")));
     mTrashThreadAction->setText(isInTrashFolder ? i18n("Delete T&hread") : i18n("M&ove Thread to Trash"));
 
     mSearchMessages->setText((mCurrentCollection.resource() == QLatin1String("akonadi_search_resource")) ? i18n("Edit Search...") : i18n("&Find Messages..."));
 
     mExpireConfigAction->setEnabled(mCurrentFolderSettings
                                     && !mCurrentFolderSettings->isStructural()
                                     && mCurrentFolderSettings->canDeleteMessages()
                                     && folderWithContent
                                     && !MailCommon::Util::isVirtualCollection(mCurrentCollection));
 
     updateHtmlMenuEntry();
 
     mShowFolderShortcutDialogAction->setEnabled(folderWithContent);
     actionlist << akonadiStandardAction(Akonadi::StandardActionManager::ManageLocalSubscriptions);
     bool imapFolderIsOnline = false;
     if (mCurrentFolderSettings && PimCommon::MailUtil::isImapFolder(mCurrentCollection, imapFolderIsOnline)) {
         if (imapFolderIsOnline) {
             actionlist << mServerSideSubscription;
         }
     }
 
     mGUIClient->unplugActionList(QStringLiteral("collectionview_actionlist"));
     mGUIClient->plugActionList(QStringLiteral("collectionview_actionlist"), actionlist);
 
     const bool folderIsValid = folderWithContent;
     mApplyAllFiltersFolderAction->setEnabled(folderIsValid);
     mApplyFilterFolderActionsMenu->setEnabled(folderIsValid);
     mApplyFilterFolderRecursiveActionsMenu->setEnabled(folderIsValid);
     for (auto a : qAsConst(mFilterFolderMenuActions)) {
         a->setEnabled(folderIsValid);
     }
     for (auto a : qAsConst(mFilterFolderMenuRecursiveActions)) {
         a->setEnabled(folderIsValid);
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotIntro()
 {
     if (!mMsgView) {
         return;
     }
 
     mMsgView->clear(true);
 
     // hide widgets that are in the way:
     if (mMessagePane && mLongFolderList) {
         mMessagePane->hide();
     }
     mMsgView->displayAboutPage();
 
     clearCurrentFolder();
 }
 
 void KMMainWidget::slotShowStartupFolder()
 {
     connect(MailCommon::FilterManager::instance(), &FilterManager::filtersChanged,
             this, &KMMainWidget::initializeFilterActions);
     // Plug various action lists. This can't be done in the constructor, as that is called before
     // the main window or Kontact calls createGUI().
     // This function however is called with a single shot timer.
     checkAkonadiServerManagerState();
     mFolderShortcutActionManager->createActions();
     mTagActionManager->createActions();
     messageActions()->setupForwardingActionsList(mGUIClient);
     initializePluginActions();
 
     const QString newFeaturesMD5 = KMReaderWin::newFeaturesMD5();
     if (kmkernel->firstStart()
         || KMailSettings::self()->previousNewFeaturesMD5() != newFeaturesMD5) {
         KMailSettings::self()->setPreviousNewFeaturesMD5(newFeaturesMD5);
         slotIntro();
     }
 }
 
 void KMMainWidget::checkAkonadiServerManagerState()
 {
     Akonadi::ServerManager::State state = Akonadi::ServerManager::self()->state();
     if (state == Akonadi::ServerManager::Running) {
         initializeFilterActions();
     } else {
         connect(Akonadi::ServerManager::self(), &ServerManager::stateChanged,
                 this, &KMMainWidget::slotServerStateChanged);
     }
 }
 
 void KMMainWidget::slotServerStateChanged(Akonadi::ServerManager::State state)
 {
     if (state == Akonadi::ServerManager::Running) {
         initializeFilterActions();
         disconnect(Akonadi::ServerManager::self(), SIGNAL(stateChanged(Akonadi::ServerManager::State)));
     }
 }
 
 QList<KActionCollection *> KMMainWidget::actionCollections() const
 {
     return QList<KActionCollection *>() << actionCollection();
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::slotUpdateUndo()
 {
     if (actionCollection()->action(QStringLiteral("kmail_undo"))) {
         QAction *act = actionCollection()->action(QStringLiteral("kmail_undo"));
         act->setEnabled(!kmkernel->undoStack()->isEmpty());
         const QString infoStr = kmkernel->undoStack()->undoInfo();
         if (infoStr.isEmpty()) {
             act->setText(i18n("&Undo"));
         } else {
             act->setText(i18n("&Undo: \"%1\"", kmkernel->undoStack()->undoInfo()));
         }
     }
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::clearFilterActions()
 {
     if (mGUIClient->factory()) {
         if (!mFilterTBarActions.isEmpty()) {
             mGUIClient->unplugActionList(QStringLiteral("toolbar_filter_actions"));
         }
         if (!mFilterMenuActions.isEmpty()) {
             mGUIClient->unplugActionList(QStringLiteral("menu_filter_actions"));
         }
         if (!mFilterFolderMenuActions.isEmpty()) {
             mGUIClient->unplugActionList(QStringLiteral("menu_filter_folder_actions"));
         }
         if (!mFilterFolderMenuRecursiveActions.isEmpty()) {
             mGUIClient->unplugActionList(QStringLiteral("menu_filter_folder_recursive_actions"));
         }
     }
 
     for (QAction *a : qAsConst(mFilterMenuActions)) {
         actionCollection()->removeAction(a);
     }
     for (QAction *a : qAsConst(mFilterFolderMenuActions)) {
         actionCollection()->removeAction(a);
     }
     for (QAction *a : qAsConst(mFilterFolderMenuRecursiveActions)) {
         actionCollection()->removeAction(a);
     }
 
     mApplyFilterActionsMenu->menu()->clear();
     mApplyFilterFolderActionsMenu->menu()->clear();
     mApplyFilterFolderRecursiveActionsMenu->menu()->clear();
     mFilterTBarActions.clear();
     mFilterMenuActions.clear();
     mFilterFolderMenuActions.clear();
     mFilterFolderMenuRecursiveActions.clear();
 
     qDeleteAll(mFilterCommands);
     mFilterCommands.clear();
 }
 
 void KMMainWidget::initializePluginActions()
 {
     KMailPluginInterface::self()->initializePluginActions(QStringLiteral("kmail"), mGUIClient);
 }
 
 QAction *KMMainWidget::filterToAction(MailCommon::MailFilter *filter)
 {
     QString displayText = i18n("Filter %1", filter->name());
     QString icon = filter->icon();
     if (icon.isEmpty()) {
         icon = QStringLiteral("system-run");
     }
     QAction *filterAction = new QAction(QIcon::fromTheme(icon), displayText, actionCollection());
     filterAction->setProperty("filter_id", filter->identifier());
     filterAction->setIconText(filter->toolbarName());
 
     // The shortcut configuration is done in the filter dialog.
     // The shortcut set in the shortcut dialog would not be saved back to
     // the filter settings correctly.
     actionCollection()->setShortcutsConfigurable(filterAction, false);
 
     return filterAction;
 }
 
 //-----------------------------------------------------------------------------
 void KMMainWidget::initializeFilterActions()
 {
     clearFilterActions();
     mApplyFilterActionsMenu->menu()->addAction(mApplyAllFiltersAction);
     mApplyFilterFolderActionsMenu->menu()->addAction(mApplyAllFiltersFolderAction);
     mApplyFilterFolderRecursiveActionsMenu->menu()->addAction(mApplyAllFiltersFolderRecursiveAction);
     bool addedSeparator = false;
 
     const QList<MailFilter *> lstFilters = MailCommon::FilterManager::instance()->filters();
     for (MailFilter *filter : lstFilters) {
         if (!filter->isEmpty() && filter->configureShortcut() && filter->isEnabled()) {
             QString filterName = QStringLiteral("Filter %1").arg(filter->name());
             QString normalizedName = filterName.replace(QLatin1Char(' '), QLatin1Char('_'));
             if (action(normalizedName)) {
                 continue;
             }
 
             if (!addedSeparator) {
                 QAction *a = mApplyFilterActionsMenu->menu()->addSeparator();
                 mFilterMenuActions.append(a);
                 a = mApplyFilterFolderActionsMenu->menu()->addSeparator();
                 mFilterFolderMenuActions.append(a);
                 a = mApplyFilterFolderRecursiveActionsMenu->menu()->addSeparator();
                 mFilterFolderMenuRecursiveActions.append(a);
                 addedSeparator = true;
             }
 
             KMMetaFilterActionCommand *filterCommand = new KMMetaFilterActionCommand(filter->identifier(), this);
             mFilterCommands.append(filterCommand);
 
             auto filterAction = filterToAction(filter);
             actionCollection()->addAction(normalizedName, filterAction);
             connect(filterAction, &QAction::triggered,
                     filterCommand, &KMMetaFilterActionCommand::start);
             actionCollection()->setDefaultShortcut(filterAction, filter->shortcut());
             mApplyFilterActionsMenu->menu()->addAction(filterAction);
             mFilterMenuActions.append(filterAction);
             if (filter->configureToolbar()) {
                 mFilterTBarActions.append(filterAction);
             }
 
             filterAction = filterToAction(filter);
             actionCollection()->addAction(normalizedName + QStringLiteral("___folder"), filterAction);
             connect(filterAction, &QAction::triggered,
                     this, [this] {
                 slotApplyFilterOnFolder(/* recursive */ false);
             });
             mApplyFilterFolderActionsMenu->menu()->addAction(filterAction);
             mFilterFolderMenuActions.append(filterAction);
 
             filterAction = filterToAction(filter);
             actionCollection()->addAction(normalizedName + QStringLiteral("___folder_recursive"), filterAction);
             connect(filterAction, &QAction::triggered,
                     this, [this] {
                 slotApplyFilterOnFolder(/* recursive */ true);
             });
             mApplyFilterFolderRecursiveActionsMenu->menu()->addAction(filterAction);
             mFilterFolderMenuRecursiveActions.append(filterAction);
         }
     }
 
     if (mGUIClient->factory()) {
         if (!mFilterMenuActions.isEmpty()) {
             mGUIClient->plugActionList(QStringLiteral("menu_filter_actions"), mFilterMenuActions);
         }
         if (!mFilterTBarActions.isEmpty()) {
             mFilterTBarActions.prepend(mToolbarActionSeparator);
             mGUIClient->plugActionList(QStringLiteral("toolbar_filter_actions"), mFilterTBarActions);
         }
         if (!mFilterFolderMenuActions.isEmpty()) {
             mGUIClient->plugActionList(QStringLiteral("menu_filter_folder_actions"), mFilterFolderMenuActions);
         }
         if (!mFilterFolderMenuRecursiveActions.isEmpty()) {
             mGUIClient->plugActionList(QStringLiteral("menu_filter_folder_recursive_actions"), mFilterFolderMenuRecursiveActions);
         }
     }
 
     // Our filters have changed, now enable/disable them
     updateMessageActions();
 }
 
 void KMMainWidget::updateFileMenu()
 {
     const bool isEmpty = MailCommon::Util::agentInstances().isEmpty();
     actionCollection()->action(QStringLiteral("check_mail"))->setEnabled(!isEmpty);
     actionCollection()->action(QStringLiteral("check_mail_in"))->setEnabled(!isEmpty);
 }
 
 //-----------------------------------------------------------------------------
 const KMMainWidget::PtrList *KMMainWidget::mainWidgetList()
 {
     // better safe than sorry; check whether the global static has already been destroyed
     if (theMainWidgetList.isDestroyed()) {
         return nullptr;
     }
     return theMainWidgetList;
 }
 
 QSharedPointer<FolderSettings> KMMainWidget::currentFolder() const
 {
     return mCurrentFolderSettings;
 }
 
 QAction *KMMainWidget::action(const QString &name)
 {
     return mActionCollection->action(name);
 }
 
 KActionMenu *KMMainWidget::filterMenu() const
 {
     return mFilterMenu;
 }
 
 KActionMenu *KMMainWidget::mailingListActionMenu() const
 {
     return mMsgActions->mailingListActionMenu();
 }
 
 QAction *KMMainWidget::sendQueuedAction() const
 {
     return mSendQueued;
 }
 
 KActionMenuTransport *KMMainWidget::sendQueueViaMenu() const
 {
     return mSendActionMenu;
 }
 
 KMail::MessageActions *KMMainWidget::messageActions() const
 {
     return mMsgActions;
 }
 
 //-----------------------------------------------------------------------------
 QString KMMainWidget::overrideEncoding() const
 {
     if (mMsgView) {
         return mMsgView->overrideEncoding();
     } else {
         return MessageCore::MessageCoreSettings::self()->overrideCharacterEncoding();
     }
 }
 
 void KMMainWidget::showEvent(QShowEvent *event)
 {
     QWidget::showEvent(event);
     mWasEverShown = true;
 }
 
 KActionCollection *KMMainWidget::actionCollection() const
 {
     return mActionCollection;
 }
 
 void KMMainWidget::slotRequestFullSearchFromQuickSearch()
 {
     // First, open the search window. If we are currently on a search folder,
     // the search associated with that will be loaded.
     if (!showSearchDialog()) {
         return;
     }
 
     assert(mSearchWin);
 
     // Now we look at the current state of the quick search, and if there's
     // something in there, we add the criteria to the existing search for
     // the search folder, if applicable, or make a new one from it.
     SearchPattern pattern;
     const QString searchString = mMessagePane->currentFilterSearchString();
     if (!searchString.isEmpty()) {
         MessageList::Core::QuickSearchLine::SearchOptions options = mMessagePane->currentOptions();
         QByteArray searchStringVal;
         if (options & MessageList::Core::QuickSearchLine::SearchEveryWhere) {
             searchStringVal = QByteArrayLiteral("<message>");
         } else if (options & MessageList::Core::QuickSearchLine::SearchAgainstSubject) {
             searchStringVal = QByteArrayLiteral("subject");
         } else if (options & MessageList::Core::QuickSearchLine::SearchAgainstBody) {
             searchStringVal = QByteArrayLiteral("<body>");
         } else if (options & MessageList::Core::QuickSearchLine::SearchAgainstFrom) {
             searchStringVal = QByteArrayLiteral("from");
         } else if (options & MessageList::Core::QuickSearchLine::SearchAgainstBcc) {
             searchStringVal = QByteArrayLiteral("bcc");
         } else if (options & MessageList::Core::QuickSearchLine::SearchAgainstTo) {
             searchStringVal = QByteArrayLiteral("to");
         } else {
             searchStringVal = QByteArrayLiteral("<message>");
         }
         pattern.append(SearchRule::createInstance(searchStringVal, SearchRule::FuncContains, searchString));
         const QList<MessageStatus> statusList = mMessagePane->currentFilterStatus();
         for (MessageStatus status : statusList) {
             if (status.hasAttachment()) {
                 pattern.append(SearchRule::createInstance(searchStringVal, SearchRule::FuncHasAttachment, searchString));
                 status.setHasAttachment(false);
             }
             if (!status.isOfUnknownStatus()) {
                 pattern.append(SearchRule::Ptr(new SearchRuleStatus(status)));
             }
         }
     }
     if (!pattern.isEmpty()) {
         mSearchWin->addRulesToSearchPattern(pattern);
     }
 }
 
 void KMMainWidget::updateVacationScriptStatus(bool active, const QString &serverName)
 {
     mVacationScriptIndicator->setVacationScriptActive(active, serverName);
     mVacationIndicatorActive = mVacationScriptIndicator->hasVacationScriptActive();
 }
 
 QWidget *KMMainWidget::vacationScriptIndicator() const
 {
     return mVacationScriptIndicator;
 }
 
 FolderTreeView *KMMainWidget::folderTreeView() const
 {
     return mFolderTreeWidget->folderTreeView();
 }
 
 KXMLGUIClient *KMMainWidget::guiClient() const
 {
     return mGUIClient;
 }
 
 KMail::TagActionManager *KMMainWidget::tagActionManager() const
 {
     return mTagActionManager;
 }
 
 KMail::FolderShortcutActionManager *KMMainWidget::folderShortcutActionManager() const
 {
     return mFolderShortcutActionManager;
 }
 
 void KMMainWidget::slotMessageSelected(const Akonadi::Item &item)
 {
     delete mShowBusySplashTimer;
     mShowBusySplashTimer = nullptr;
     if (mMsgView) {
         // The current selection was cleared, so we'll remove the previously
         // selected message from the preview pane
         if (!item.isValid()) {
             mMsgView->clear();
         } else {
             mShowBusySplashTimer = new QTimer(this);
             mShowBusySplashTimer->setSingleShot(true);
             connect(mShowBusySplashTimer, &QTimer::timeout, this, &KMMainWidget::slotShowBusySplash);
             mShowBusySplashTimer->start(1000);
 
             Akonadi::ItemFetchJob *itemFetchJob = mMsgView->viewer()->createFetchJob(item);
             if (mCurrentCollection.isValid()) {
                 const QString resource = mCurrentCollection.resource();
                 itemFetchJob->setProperty("_resource", QVariant::fromValue(resource));
                 connect(itemFetchJob, &ItemFetchJob::itemsReceived,
                         this, &KMMainWidget::itemsReceived);
                 connect(itemFetchJob, &Akonadi::ItemFetchJob::result, this, &KMMainWidget::itemsFetchDone);
             }
         }
     }
 }
 
 void KMMainWidget::itemsReceived(const Akonadi::Item::List &list)
 {
     Q_ASSERT(list.size() == 1);
     delete mShowBusySplashTimer;
     mShowBusySplashTimer = nullptr;
 
     if (!mMsgView) {
         return;
     }
 
     Item item = list.first();
 
     if (mMessagePane) {
         mMessagePane->show();
 
         if (mMessagePane->currentItem() != item) {
             // The user has selected another email already, so don't render this one.
             // Mark it as read, though, if the user settings say so.
             if (MessageViewer::MessageViewerSettings::self()->delayedMarkAsRead()
                 && MessageViewer::MessageViewerSettings::self()->delayedMarkTime() == 0) {
                 item.setFlag(Akonadi::MessageFlags::Seen);
                 Akonadi::ItemModifyJob *modifyJob = new Akonadi::ItemModifyJob(item, this);
                 modifyJob->disableRevisionCheck();
                 modifyJob->setIgnorePayload(true);
             }
             return;
         }
     }
 
     Akonadi::Item copyItem(item);
     if (mCurrentCollection.isValid()) {
         copyItem.setParentCollection(mCurrentCollection);
     }
 
     mMsgView->setMessage(copyItem);
     // reset HTML override to the folder setting
     mMsgView->setDisplayFormatMessageOverwrite(mFolderDisplayFormatPreference);
     mMsgView->setHtmlLoadExtDefault(mFolderHtmlLoadExtPreference);
     mMsgView->setDecryptMessageOverwrite(false);
     mMsgActions->setCurrentMessage(copyItem);
 }
 
 void KMMainWidget::itemsFetchDone(KJob *job)
 {
     delete mShowBusySplashTimer;
     mShowBusySplashTimer = nullptr;
     if (job->error()) {
         // Unfortunately job->error() is Job::Unknown in many cases.
         // (see JobPrivate::handleResponse in akonadi/job.cpp)
         // So we show the "offline" page after checking the resource status.
         qCDebug(KMAIL_LOG) << job->error() << job->errorString();
 
         const QString resource = job->property("_resource").toString();
         const Akonadi::AgentInstance agentInstance = Akonadi::AgentManager::self()->instance(resource);
         if (!agentInstance.isOnline()) {
             // The resource is offline
             mMessagePane->show();
             if (mMsgView) {
                 mMsgView->viewer()->enableMessageDisplay();
                 mMsgView->clear(true);
                 if (kmkernel->isOffline()) {
                     showOfflinePage();
                 } else {
                     showResourceOfflinePage();
                 }
             }
         } else {
             // Some other error
             showMessageActivities(job->errorString());
         }
     }
 }
 
 QAction *KMMainWidget::akonadiStandardAction(Akonadi::StandardActionManager::Type type)
 {
     return mAkonadiStandardActionManager->action(type);
 }
 
 QAction *KMMainWidget::akonadiStandardAction(Akonadi::StandardMailActionManager::Type type)
 {
     return mAkonadiStandardActionManager->action(type);
 }
 
 StandardMailActionManager *KMMainWidget::standardMailActionManager() const
 {
     return mAkonadiStandardActionManager;
 }
 
 void KMMainWidget::slotRemoveDuplicates()
 {
     RemoveDuplicateMailJob *job = new RemoveDuplicateMailJob(mFolderTreeWidget->folderTreeView()->selectionModel(), this, this);
     job->start();
 }
 
 void KMMainWidget::slotServerSideSubscription()
 {
     if (!mCurrentCollection.isValid()) {
         return;
     }
     PimCommon::ManageServerSideSubscriptionJob *job = new PimCommon::ManageServerSideSubscriptionJob(this);
     job->setCurrentCollection(mCurrentCollection);
     job->setParentWidget(this);
     job->start();
 }
 
 void KMMainWidget::savePaneSelection()
 {
     if (mMessagePane) {
         mMessagePane->saveCurrentSelection();
     }
 }
 
 void KMMainWidget::updatePaneTagComboBox()
 {
     if (mMessagePane) {
         mMessagePane->updateTagComboBox();
     }
 }
 
 void KMMainWidget::slotCreateAddressBookContact()
 {
     CreateNewContactJob *job = new CreateNewContactJob(this, this);
     job->start();
 }
 
 void KMMainWidget::slotOpenRecentMessage(const QUrl &url)
 {
     KMOpenMsgCommand *openCommand = new KMOpenMsgCommand(this, url, overrideEncoding(), this);
     openCommand->start();
 }
 
 void KMMainWidget::addRecentFile(const QUrl &mUrl)
 {
     mOpenRecentAction->addUrl(mUrl);
     KConfigGroup grp = mConfig->group(QStringLiteral("Recent Files"));
     mOpenRecentAction->saveEntries(grp);
     grp.sync();
 }
 
 void KMMainWidget::slotMoveMessageToTrash()
 {
     if (messageView() && messageView()->viewer() && mCurrentCollection.isValid()) {
         KMTrashMsgCommand *command = new KMTrashMsgCommand(mCurrentCollection, messageView()->viewer()->messageItem(), -1);
         command->start();
     }
 }
 
 void KMMainWidget::slotArchiveMails()
 {
     if (mCurrentCollection.isValid()) {
         const Akonadi::Item::List selectedMessages = mMessagePane->selectionAsMessageItemList();
         KMKernel::self()->folderArchiveManager()->setArchiveItems(selectedMessages, mCurrentCollection.resource());
     }
 }
 
 void KMMainWidget::updateQuickSearchLineText()
 {
     //If change change shortcut
     mMessagePane->setQuickSearchClickMessage(i18nc("Show shortcut for focus quick search. Don't change it", "Search... <%1>", mQuickSearchAction->shortcut().toString()));
 }
 
 void KMMainWidget::slotChangeDisplayMessageFormat(MessageViewer::Viewer::DisplayFormatMessage format)
 {
     if (format == MessageViewer::Viewer::Html) {
         const int result = KMessageBox::warningContinueCancel(this,
                                                               // the warning text is taken from configuredialog.cpp:
                                                               i18n("Use of HTML in mail will make you more vulnerable to "
                                                                    "\"spam\" and may increase the likelihood that your system will be "
                                                                    "compromised by other present and anticipated security exploits."),
                                                               i18n("Security Warning"),
                                                               KGuiItem(i18n("Use HTML")),
                                                               KStandardGuiItem::cancel(),
                                                               QStringLiteral("OverrideHtmlWarning"), nullptr);
         if (result == KMessageBox::Cancel) {
             mDisplayMessageFormatMenu->setDisplayMessageFormat(MessageViewer::Viewer::Text);
             return;
         }
     }
     mFolderDisplayFormatPreference = format;
 
     //Update mPrefererHtmlLoadExtAction
     const bool useHtml = (mFolderDisplayFormatPreference == MessageViewer::Viewer::Html || (mHtmlGlobalSetting && mFolderDisplayFormatPreference == MessageViewer::Viewer::UseGlobalSetting));
     mPreferHtmlLoadExtAction->setEnabled(useHtml);
 
     if (mMsgView) {
         mMsgView->setDisplayFormatMessageOverwrite(mFolderDisplayFormatPreference);
         mMsgView->update(true);
     }
     writeFolderConfig();
 }
 
 void KMMainWidget::populateMessageListStatusFilterCombo()
 {
     mMessagePane->populateStatusFilterCombo();
 }
 
 void KMMainWidget::slotCollectionRemoved(const Akonadi::Collection &col)
 {
     if (mFavoritesModel) {
         mFavoritesModel->removeCollection(col);
     }
 }
 
 void KMMainWidget::slotMarkAllMessageAsReadInCurrentFolderAndSubfolder()
 {
     if (mCurrentCollection.isValid()) {
         MarkAllMessagesAsReadInFolderAndSubFolderJob *job = new MarkAllMessagesAsReadInFolderAndSubFolderJob(this);
         job->setTopLevelCollection(mCurrentCollection);
         job->start();
     }
 }
 
 void KMMainWidget::slotRemoveDuplicateRecursive()
 {
     if (mCurrentCollection.isValid()) {
         RemoveDuplicateMessageInFolderAndSubFolderJob *job = new RemoveDuplicateMessageInFolderAndSubFolderJob(this, this);
         job->setTopLevelCollection(mCurrentCollection);
         job->start();
     }
 }
 
 void KMMainWidget::slotUpdateConfig()
 {
     readFolderConfig();
     updateHtmlMenuEntry();
 }
 
 void KMMainWidget::printCurrentMessage(bool preview)
 {
     bool result = false;
     if (messageView() && messageView()->viewer()) {
         if (MessageViewer::MessageViewerSettings::self()->printSelectedText()) {
             result = messageView()->printSelectedText(preview);
         }
     }
     if (!result) {
         const bool useFixedFont = MessageViewer::MessageViewerSettings::self()->useFixedFont();
         const QString overrideEncoding = MessageCore::MessageCoreSettings::self()->overrideCharacterEncoding();
 
         const Akonadi::Item currentItem = messageView()->viewer()->messageItem();
         KMPrintCommand *command
             = new KMPrintCommand(this, currentItem,
                                  messageView()->viewer()->headerStylePlugin(),
                                  messageView()->viewer()->displayFormatMessageOverwrite(), messageView()->viewer()->htmlLoadExternal(),
                                  useFixedFont, overrideEncoding);
         command->setPrintPreview(preview);
         command->start();
     }
 }
 
 void KMMainWidget::slotRedirectCurrentMessage()
 {
     if (messageView() && messageView()->viewer()) {
         const Akonadi::Item currentItem = messageView()->viewer()->messageItem();
         if (!currentItem.hasPayload<KMime::Message::Ptr>()) {
             return;
         }
         KMCommand *command = new KMRedirectCommand(this, currentItem);
         command->start();
     }
 }
 
 void KMMainWidget::replyCurrentMessageCommand(MessageComposer::ReplyStrategy strategy)
 {
     if (messageView() && messageView()->viewer()) {
         Akonadi::Item currentItem = messageView()->viewer()->messageItem();
         if (!currentItem.hasPayload<KMime::Message::Ptr>()) {
             return;
         }
         const QString text = messageView()->copyText();
         KMReplyCommand *command = new KMReplyCommand(this, currentItem, strategy, text);
         command->start();
     }
 }
 
 void KMMainWidget::slotReplyMessageTo(const KMime::Message::Ptr &message, bool replyToAll)
 {
     Akonadi::Item item;
 
     item.setPayload<KMime::Message::Ptr>(message);
     item.setMimeType(KMime::Message::mimeType());
     KMReplyCommand *command = new KMReplyCommand(this, item, replyToAll ? MessageComposer::ReplyAll : MessageComposer::ReplyAuthor);
     command->start();
 }
 
 void KMMainWidget::showMessageActivities(const QString &str)
 {
     BroadcastStatus::instance()->setStatusMsg(str);
     PimCommon::LogActivitiesManager::self()->appendLog(str);
 }
 
 void KMMainWidget::slotCopyDecryptedTo(QAction *action)
 {
     if (action) {
         const auto index = action->data().toModelIndex();
         const auto collection = index.data(Akonadi::EntityTreeModel::CollectionRole).value<Akonadi::Collection>();
 
         auto command = new KMCopyDecryptedCommand(collection, mMessagePane->selectionAsMessageItemList());
         command->start();
     }
 }
 
 void KMMainWidget::slotSetFocusToViewer()
 {
     if (messageView() && messageView()->viewer()) {
         messageView()->viewer()->setFocus();
     }
 }
+
+void KMMainWidget::setupUnifiedMailboxChecker()
+{
+    if (!KMailSettings::self()->askEnableUnifiedMailboxes()) {
+        return;
+    }
+
+    const auto ask = [this]() {
+        if (!KMailSettings::self()->askEnableUnifiedMailboxes()) {
+            return;
+        }
+
+        if (kmkernel->accounts().count() <= 1) {
+            return;
+        }
+
+        const auto service = Akonadi::ServerManager::self()->agentServiceName(Akonadi::ServerManager::Agent, QStringLiteral("akonadi_unifiedmailbox_agent"));
+        QDBusInterface iface(service, QStringLiteral("/"), QStringLiteral("org.freedesktop.Akonadi.UnifiedMailboxAgent"),
+                             QDBusConnection::sessionBus(), this);
+        if (!iface.isValid()) {
+            return;
+        }
+
+        QDBusReply<bool> reply = iface.call(QStringLiteral("enabledAgent"));
+        if (!reply.isValid() || bool(reply)) {
+            return;
+        }
+
+        const auto answer = KMessageBox::questionYesNo(
+            this, i18n("You have more than one email account set up. Do you want to enable the Unified Mailbox feature to "
+                        "show unified content of your inbox, sent and drafts folders?\n"
+                        "You can configure unified mailboxes, create custom ones or disable the feature completely in KMail's Plugin settings."),
+            i18n("Enable Unified Mailboxes?"),
+            KGuiItem(i18n("Enable Unified Mailboxes"), QStringLiteral("dialog-ok")),
+            KGuiItem(i18n("Cancel"), QStringLiteral("dialog-cancel")));
+        if (answer == KMessageBox::Yes) {
+            iface.call(QStringLiteral("setEnableAgent"), true);
+        }
+
+        KMailSettings::self()->setAskEnableUnifiedMailboxes(false);
+    };
+
+    connect(kmkernel, &KMKernel::incomingAccountsChanged, this, ask);
+
+    // Wait for a bit before asking so we at least have the window on screen
+    QTimer::singleShot(500, this, ask);
+}
+
diff --git a/src/kmmainwidget.h b/src/kmmainwidget.h
index 760bb7d38..6f3f4612a 100644
--- a/src/kmmainwidget.h
+++ b/src/kmmainwidget.h
@@ -1,636 +1,637 @@
 /*
   This file is part of KMail, the KDE mail client.
   Copyright (c) 2002 Don Sanders <sanders@kde.org>
 
   Based on the work of Stefan Taferner <taferner@kde.org>
 
   KMail is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License, version 2, as
   published by the Free Software Foundation.
 
   KMail is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.
 
   You should have received a copy of the GNU General Public License along
   with this program; if not, write to the Free Software Foundation, Inc.,
   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
 #ifndef KMAIL_KMMAINWIDGET
 #define KMAIL_KMMAINWIDGET
 
 #include "kmail_export.h"
 #include "kmreaderwin.h" //for inline actions
 #include "kmkernel.h" // for access to config
 
 #include "mailcommon/foldertreewidget.h"
 
 #include <kxmlguiclient.h>
 #include "messageactions.h"
 #include <kactioncollection.h>
 #include <mailcommon/foldersettings.h>
 
 #include <QPointer>
 #include <QTimer>
 #include <Akonadi/KMime/StandardMailActionManager>
 #include <AkonadiCore/tag.h>
 #include <MessageList/View>
 
 namespace MailTransport {
 class Transport;
 }
 namespace Akonadi {
 class Tag;
 }
 
 namespace KMime {
 class Message;
 }
 class QUrl;
 class QVBoxLayout;
 class QSplitter;
 class KMLaunchExternalComponent;
 class DisplayMessageFormatActionMenu;
 class QAction;
 class KActionMenu;
 class KToggleAction;
 class KMMetaFilterActionCommand;
 class CollectionPane;
 class KMCommand;
 class KMMoveCommand;
 class KRecentFilesAction;
 class ManageShowCollectionProperties;
 class KActionMenuTransport;
 class KActionMenuAccount;
 
 namespace KIO {
 class Job;
 }
 
 namespace KMail {
 class SearchWindow;
 class VacationScriptIndicatorWidget;
 class TagActionManager;
 class FolderShortcutActionManager;
 }
 
 namespace KSieveUi {
 class SieveImapPasswordProvider;
 class ManageSieveScriptsDialog;
 class VacationManager;
 }
 
 namespace MailCommon {
 class FolderSelectionDialog;
 class FavoriteCollectionWidget;
 class MailFilter;
 }
 
 class KMAIL_EXPORT KMMainWidget : public QWidget
 {
     Q_OBJECT
 
 public:
     typedef QList<KMMainWidget *> PtrList;
 
     KMMainWidget(QWidget *parent, KXMLGUIClient *aGUIClient, KActionCollection *actionCollection, KSharedConfig::Ptr config = KMKernel::self()->config());
     ~KMMainWidget() override;
     void destruct();
 
     /** Read configuration options before widgets are created. */
     void readPreConfig();
 
     /** Read configuration for current folder. */
     void readFolderConfig();
 
     /** Write configuration for current folder. */
     void writeFolderConfig();
 
     /** Read configuration options after widgets are created. */
     void readConfig();
 
     /** Write configuration options. */
     void writeConfig(bool force = true);
 
     void writeReaderConfig();
 
     /** Easy access to main components of the window. */
     KMReaderWin *messageView() const;
     /** Access to the header list pane. */
     CollectionPane *messageListPane() const;
 
     Akonadi::Collection currentCollection() const;
     QSharedPointer<MailCommon::FolderSettings> currentFolder() const;
 
     static void cleanup();
     QAction *action(const QString &name);
 
     QAction *sendQueuedAction() const;
 
     KActionMenuTransport *sendQueueViaMenu() const;
 
     /**
       Returns a list of all KMMainWidgets. Warning, the list itself can be 0.
       @return the list of all main widgets, or 0 if it is not yet initialized
     */
     static const PtrList *mainWidgetList();
 
     QWidget *vacationScriptIndicator() const;
 
     MailCommon::FolderTreeView *folderTreeView() const;
 
     /** Returns the XML GUI client. */
     KXMLGUIClient *guiClient() const;
 
     KMail::TagActionManager *tagActionManager() const;
 
     KMail::FolderShortcutActionManager *folderShortcutActionManager() const;
     void savePaneSelection();
 
     void updatePaneTagComboBox();
 
     void clearViewer();
 
     void addRecentFile(const QUrl &mUrl);
     void updateQuickSearchLineText();
 
     void populateMessageListStatusFilterCombo();
     void initializePluginActions();
 
     Akonadi::Item::List currentSelection() const;
 
     QString fullCollectionPath() const;
 
     void initializeFilterActions();
     /** Clear and create actions for marked filters */
     void clearFilterActions();
     /**
      * Convenience function to get the action collection in a list.
      *
      * @return a list of action collections. The list only has one item, and
      *         that is the action collection of this main widget as returned
      *         by actionCollection().
      */
     QList<KActionCollection *> actionCollections() const;
     void refreshMessageListSelection();
     Akonadi::StandardMailActionManager *standardMailActionManager() const;
     QAction *akonadiStandardAction(Akonadi::StandardActionManager::Type type);
     QAction *akonadiStandardAction(Akonadi::StandardMailActionManager::Type type);
 
 public Q_SLOTS:
 
     /**
       Open a separate viewer window containing the specified message.
     */
     void slotMessageActivated(const Akonadi::Item &);
 
     /**
       Opens mail in the internal viewer.
     */
     void slotMessageSelected(const Akonadi::Item &);
 
     void slotItemsFetchedForActivation(KMCommand *command);
     void slotMessageStatusChangeRequest(const Akonadi::Item &, const Akonadi::MessageStatus &, const Akonadi::MessageStatus &);
 
     /** Adds if not existing/removes if existing the tag identified by @p aLabel
         in all selected messages */
     void slotUpdateMessageTagList(const Akonadi::Tag &tag);
 
     void slotSelectCollectionFolder(const Akonadi::Collection &col);
 
     void slotUpdateConfig();
 Q_SIGNALS:
     void messagesTransfered(bool);
     void captionChangeRequest(const QString &caption);
     void recreateGui();
 
 protected:
     void showEvent(QShowEvent *event) override;
 
 private:
     KMail::MessageActions *messageActions() const;
 
     KActionMenu *filterMenu() const;
 
     KActionMenu *mailingListActionMenu() const;
 
     // Moving messages around
     /**
      * This will ask for a destination folder and move the currently selected
      * messages (in MessageListView) into it.
      */
     void slotMoveSelectedMessageToFolder();
 
     // Copying messages around
 
     /**
      * This will ask for a destination folder and copy the currently selected
      * messages (in MessageListView) into it.
      */
     void slotCopySelectedMessagesToFolder();
     /**
      * Implements the "move to trash" action
      */
     void slotTrashSelectedMessages();
 
     void slotCheckMail();
     void slotCheckMailOnStartup();
 
     /** Trigger the dialog for editing out-of-office scripts.  */
     void slotEditVacation(const QString &serverName);
 
     void slotStartCheckMail();
     void slotEndCheckMail();
     void restoreCollectionFolderViewConfig();
     /** Update message actions */
     void updateMessageActions(bool fast = false);
     void updateMessageActionsDelayed();
     /**
       Update message menu
     */
     void updateMessageMenu();
 
     void slotRemoveDuplicates();
     /**
       Select the given folder
       If the folder is 0 the intro is shown
     */
     void folderSelected(const Akonadi::Collection &col);
 
     /**
       Start a timer to update message actions
     */
     void startUpdateMessageActionsTimer();
     void slotSelectMoreMessageTagList();
     void setupActions();
     void createWidgets();
     void deleteWidgets();
     void layoutSplitters();
     void newFromTemplate(const Akonadi::Item &);
     void moveSelectedMessagesToFolder(const Akonadi::Collection &dest);
     void copySelectedMessagesToFolder(const Akonadi::Collection &dest);
     KActionCollection *actionCollection() const;
     /**
       @return the correct config dialog depending on whether the parent of
       the mainWidget is a KPart or a KMMainWindow.
       When dealing with geometries, use this pointer
     */
     KSharedConfig::Ptr config();
 
     void checkAkonadiServerManagerState();
     void updateHtmlMenuEntry();
 
     void updateMoveAction(const Akonadi::CollectionStatistics &statistic);
     void updateMoveAction(bool hasUnreadMails);
 
     void updateAllToTrashAction(qint64 statistics);
 
     /** Get override character encoding. */
     QString overrideEncoding() const;
 
     void moveMessageSelected(MessageList::Core::MessageItemSetReference ref, const Akonadi::Collection &dest, bool confirmOnDeletion = true);
 
     void copyMessageSelected(const Akonadi::Item::List &selectMsg, const Akonadi::Collection &dest);
 
     /**
      * Move the messages referenced by the specified set to trash.
      * The set parameter must not be null and the ownership is passed
      * to this function.
      */
     void trashMessageSelected(MessageList::Core::MessageItemSetReference ref);
     /**
      * Set the status of the messages referenced by the specified set, eventually toggling it.
      * The set parameter must not be null and the ownership is passed to this function.
      */
     void setMessageSetStatus(const Akonadi::Item::List &select, const Akonadi::MessageStatus &status, bool toggle);
     /**
      * Toggles a tag for the messages referenced by the specified set.
      * The set parameter must not be null and the ownership is passed to this function.
      */
     void toggleMessageSetTag(const Akonadi::Item::List &select, const Akonadi::Tag &tag);
     /**
      * This applies setMessageSetStatus() on the current thread.
      */
     void setCurrentThreadStatus(const Akonadi::MessageStatus &status, bool toggle);
 
     void applyFilters(const Akonadi::Item::List &selectedMessages);
     void applyFilters(const Akonadi::Collection::List &selectedCols);
     void applyFilter(const Akonadi::Collection::List &selectedCols, const QString &filter);
 
     /**
      * Internal helper that creates the folder selection dialog used for the
      * move and copy to folder actions on demand. Only folders where items can
      * be added are listed.
      */
     MailCommon::FolderSelectionDialog *moveOrCopyToDialog();
 
     /**
      * Internal helper that creates the folder selection dialog used for
      * jumping to folders, or adding them as favourites. All folders are listed.
      */
     MailCommon::FolderSelectionDialog *selectFromAllFoldersDialog();
 
     /**
      * Internal helper that applies the current settings so the
      * favorite folder view.
      */
     void refreshFavoriteFoldersViewProperties();
 
     void openFilterDialog(const QByteArray &field, const QString &value);
 
     void showMessagePopup(const Akonadi::Item &msg, const QUrl &aUrl, const QUrl &imageUrl, const QPoint &aPoint, bool contactAlreadyExists, bool uniqueContactFound,
                           const WebEngineViewer::WebHitTestResult &result);
 
 private Q_SLOTS:
     void updateFileMenu();
     void slotFilter();
     void slotManageSieveScripts();
     void slotCompose();
     void slotPostToML();
     void slotExpireFolder();
     void slotExpireAll();
     void slotArchiveFolder();
     void slotRemoveFolder();
     void slotEmptyFolder();
     void slotClearCurrentFolder();
     void slotAddFavoriteFolder();
     void slotShowSelectedFolderInPane();
     void slotOverrideHtmlLoadExt();
     void slotUseTemplate();
     void slotTrashThread();
     void slotDeleteThread(bool confirmDelete);    // completely delete thread
     void slotUndo();
     void slotReadOn();
     void slotSaveMsg();
     void slotOpenMsg();
     void slotSaveAttachments();
     void slotJumpToFolder();
     void slotCheckVacation();
     void slotDebugSieve();
     void slotApplyFilters();
     void slotApplyFiltersOnFolder(bool recursive);
     void slotApplyFilterOnFolder(bool recursive);
     void slotExpandThread();
     void slotExpandAllThreads();
     void slotCollapseThread();
     void slotCollapseAllThreads();
     void slotSetThreadStatusUnread();
     void slotSetThreadStatusRead();
     void slotSetThreadStatusImportant();
     void slotSetThreadStatusToAct();
     void slotSetThreadStatusWatched();
     void slotSetThreadStatusIgnored();
     void slotSendQueued();
     void slotSendQueuedVia(MailTransport::Transport *transport);
     void slotOnlineStatus();
     void slotUpdateOnlineStatus(KMailSettings::EnumNetworkState::type);
     void slotMessagePopup(const Akonadi::Item &aMsg, const WebEngineViewer::WebHitTestResult &result, const QPoint &aPoint);
     void slotContactSearchJobForMessagePopupDone(KJob *job);
     void slotSelectAllMessages();
     void slotFocusQuickSearch();
 
     void slotIntro();
     void slotShowStartupFolder();
     void slotCopyDecryptedTo(QAction *action);
 
     /** Message navigation */
     void slotSelectNextMessage();
     void slotExtendSelectionToNextMessage();
     void slotSelectNextUnreadMessage();
     void slotSelectPreviousMessage();
     void slotExtendSelectionToPreviousMessage();
     void slotSelectPreviousUnreadMessage();
     void slotFocusOnNextMessage();
     void slotFocusOnPrevMessage();
     void slotSelectFirstMessage();
     void slotSelectLastMessage();
     void slotSelectFocusedMessage();
 
     void slotNextUnreadFolder();
     void slotPrevUnreadFolder();
 
     /** etc. */
     void slotDisplayCurrentMessage();
 
     void slotShowNewFromTemplate();
     void slotDelayedShowNewFromTemplate(KJob *);
     void slotNewFromTemplate(QAction *);
 
     /** Update the undo action */
     void slotUpdateUndo();
 
     /** Update html and threaded messages preferences in Folder menu. */
     void updateFolderMenu();
 
     /** Settings menu */
 
     /** XML-GUI stuff */
     void slotEditNotifications();
 
     /** Slot to reply to a message */
     void slotCustomReplyToMsg(const QString &tmpl);
     void slotCustomReplyAllToMsg(const QString &tmpl);
     void slotForwardInlineMsg();
     void slotForwardAttachedMessage();
     void slotRedirectMessage();
     void slotCustomForwardMsg(const QString &tmpl);
     void slotSubjectFilter();
     void slotFromFilter();
     void slotToFilter();
 
     void slotConfigChanged();
 
     /** Show a splash screen for the longer-lasting operation */
     void slotShowBusySplash();
 
     /**
       Show a message screen explaining that we are currently offline, when
       an online folder is selected.
     */
     void showOfflinePage();
     void showResourceOfflinePage();
     void updateVacationScriptStatus(bool active, const QString &serverName = QString());
 
     void slotItemAdded(const Akonadi::Item &, const Akonadi::Collection &col);
     void slotItemRemoved(const Akonadi::Item &);
     void slotItemMoved(const Akonadi::Item &item, const Akonadi::Collection &from, const Akonadi::Collection &to);
     void slotCollectionStatisticsChanged(Akonadi::Collection::Id, const Akonadi::CollectionStatistics &);
 
     void slotAkonadiStandardActionUpdated();
     void slotCollectionChanged(const Akonadi::Collection &, const QSet<QByteArray> &);
     void slotCreateNewTab(bool);
     void slotUpdateActionsAfterMailChecking();
     void slotCreateAddressBookContact();
     void slotOpenRecentMessage(const QUrl &url);
 
     void slotMoveMessageToTrash();
     /**
      * Called when a "move to trash" operation is completed
      */
     void slotTrashMessagesCompleted(KMMoveCommand *command);
 
     /**
      * Called when a "move" operation is completed
      */
     void slotMoveMessagesCompleted(KMMoveCommand *command);
 
     /**
      * Called when a "copy" operation is completed
      */
     void slotCopyMessagesCompleted(KMCommand *command);
 
     void slotRequestFullSearchFromQuickSearch();
     void slotFolderChanged(const Akonadi::Collection &);
     void slotCollectionFetched(int collectionId);
 
     void itemsReceived(const Akonadi::Item::List &list);
     void itemsFetchDone(KJob *job);
 
     void slotServerSideSubscription();
     void slotServerStateChanged(Akonadi::ServerManager::State state);
     void slotArchiveMails();
     void slotChangeDisplayMessageFormat(MessageViewer::Viewer::DisplayFormatMessage format);
 
     void slotCollectionRemoved(const Akonadi::Collection &col);
     void slotCcFilter();
     void slotBandwidth(bool b);
     void slotDeleteMessages();
 
     void slotMarkAllMessageAsReadInCurrentFolderAndSubfolder();
     void slotRemoveDuplicateRecursive();
     void slotRedirectCurrentMessage();
     void slotEditCurrentVacation();
     void slotReplyMessageTo(const KMime::Message::Ptr &message, bool replyToAll);
 private:
     void slotSetFocusToViewer();
     void deleteSelectedMessages(bool confirmDelete);    // completely delete message
     bool showSearchDialog();
     void clearCurrentFolder();
     void setCurrentCollection(const Akonadi::Collection &col);
     void showMessageActivities(const QString &str);
     void slotPageIsScrolledToBottom(bool isAtBottom);
     void printCurrentMessage(bool preview);
     void replyCurrentMessageCommand(MessageComposer::ReplyStrategy strategy);
+    void setupUnifiedMailboxChecker();
     QAction *filterToAction(MailCommon::MailFilter *filter);
     Akonadi::Collection::List applyFilterOnCollection(bool recursive);
 
     // Message actions
     QAction *mDeleteAction = nullptr;
     QAction *mTrashThreadAction = nullptr;
     QAction *mDeleteThreadAction = nullptr;
     QAction *mSaveAsAction = nullptr;
     QAction *mApplyAllFiltersAction = nullptr;
     QAction *mSaveAttachmentsAction = nullptr;
     QAction *mOpenAction = nullptr;
     QAction *mMoveMsgToFolderAction = nullptr;
     QAction *mCollectionProperties = nullptr;
     QAction *mSendQueued = nullptr;
     QAction *mArchiveAction = nullptr;
     QAction *mSelectAllMessages = nullptr;
     KActionMenuTransport *mSendActionMenu = nullptr;
     // Filter actions
     KActionMenu *mFilterMenu = nullptr;
     QAction *mExpireConfigAction = nullptr;
     KActionMenu *mApplyFilterFolderActionsMenu = nullptr;
     KActionMenu *mApplyFilterFolderRecursiveActionsMenu = nullptr;
     QAction *mApplyAllFiltersFolderAction = nullptr;
     QAction *mApplyAllFiltersFolderRecursiveAction = nullptr;
     // Custom template actions menu
     KActionMenu *mTemplateMenu = nullptr;
 
     KActionMenu *mThreadStatusMenu = nullptr;
     KActionMenu *mApplyFilterActionsMenu = nullptr;
     QAction *mCopyActionMenu = nullptr;
     QAction *mMoveActionMenu = nullptr;
     QAction *mCopyDecryptedActionMenu = nullptr;
     QAction *mMarkThreadAsReadAction = nullptr;
     QAction *mMarkThreadAsUnreadAction = nullptr;
     KToggleAction *mToggleThreadImportantAction = nullptr;
     KToggleAction *mToggleThreadToActAction = nullptr;
 
     KToggleAction *mWatchThreadAction = nullptr;
     KToggleAction *mIgnoreThreadAction = nullptr;
 
     MailCommon::FavoriteCollectionWidget *mFavoriteCollectionsView = nullptr;
     Akonadi::FavoriteCollectionsModel *mFavoritesModel = nullptr;
     KMReaderWin *mMsgView = nullptr;
     QSplitter *mSplitter1 = nullptr;
     QSplitter *mSplitter2 = nullptr;
     QSplitter *mFolderViewSplitter = nullptr;
     Akonadi::Collection mTemplateFolder;
     bool mLongFolderList = false;
     bool mStartupDone = false;
     bool mWasEverShown = false;
     bool mHtmlGlobalSetting = false;
     bool mHtmlLoadExtGlobalSetting = false;
     bool mFolderHtmlLoadExtPreference = false;
     bool mReaderWindowActive = false;
     bool mReaderWindowBelow = false;
     bool mEnableFavoriteFolderView = false;
     bool mEnableFolderQuickSearch = false;
 
     QPointer<KMail::SearchWindow> mSearchWin;
 
     QAction *mExpireFolderAction = nullptr;
     QAction *mFolderMailingListPropertiesAction = nullptr;
     QAction *mShowFolderShortcutDialogAction = nullptr;
     QAction *mArchiveFolderAction = nullptr;
     QAction *mMessageNewList = nullptr;
     KToggleAction *mPreferHtmlLoadExtAction = nullptr;
 
     QTimer *menutimer = nullptr;
     QTimer *mShowBusySplashTimer = nullptr;
 
     KSieveUi::VacationManager *mVacationManager = nullptr;
     KActionCollection *mActionCollection = nullptr;
     QAction *mToolbarActionSeparator = nullptr;
     QVBoxLayout *mTopLayout = nullptr;
     bool mDestructed = false;
     QList<QAction *> mFilterMenuActions;
     QList<QAction *> mFilterFolderMenuActions;
     QList<QAction *> mFilterFolderMenuRecursiveActions;
     QList<QAction *> mFilterTBarActions;
     QList<KMMetaFilterActionCommand *> mFilterCommands;
 
     KMail::TagActionManager *mTagActionManager = nullptr;
     KMail::FolderShortcutActionManager *mFolderShortcutActionManager = nullptr;
     KSharedConfig::Ptr mConfig;
     KXMLGUIClient *mGUIClient = nullptr;
 
     KMail::MessageActions *mMsgActions = nullptr;
     Akonadi::StandardMailActionManager *mAkonadiStandardActionManager = nullptr;
     CollectionPane *mMessagePane = nullptr;
     QSharedPointer<MailCommon::FolderSettings> mCurrentFolderSettings;
 
     MailCommon::FolderTreeWidget *mFolderTreeWidget = nullptr;
 
     KMail::VacationScriptIndicatorWidget *mVacationScriptIndicator = nullptr;
     bool mVacationIndicatorActive = false;
     bool mGoToFirstUnreadMessageInSelectedFolder = false;
     MessageList::Core::PreSelectionMode mPreSelectionMode;
 
     QTimer mCheckMailTimer;
 
     KSieveUi::SieveImapPasswordProvider *mSievePasswordProvider = nullptr;
     QPointer<MailCommon::FolderSelectionDialog> mMoveOrCopyToDialog;
     QPointer<MailCommon::FolderSelectionDialog> mSelectFromAllFoldersDialog;
     QAction *mServerSideSubscription = nullptr;
     KRecentFilesAction *mOpenRecentAction = nullptr;
     QPointer<KSieveUi::ManageSieveScriptsDialog> mManageSieveDialog;
     QAction *mQuickSearchAction = nullptr;
     DisplayMessageFormatActionMenu *mDisplayMessageFormatMenu = nullptr;
     MessageViewer::Viewer::DisplayFormatMessage mFolderDisplayFormatPreference = MessageViewer::Viewer::UseGlobalSetting;
     QAction *mSearchMessages = nullptr;
     KMLaunchExternalComponent *mLaunchExternalComponent = nullptr;
     ManageShowCollectionProperties *mManageShowCollectionProperties = nullptr;
     QAction *mShowIntroductionAction = nullptr;
     KToggleAction *mUseLessBandwidth = nullptr;
     QAction *mMarkAllMessageAsReadAndInAllSubFolder = nullptr;
     KActionMenuAccount *mAccountActionMenu = nullptr;
     QAction *mRemoveDuplicateRecursiveAction = nullptr;
     Akonadi::Collection mCurrentCollection;
 };
 
 #endif
diff --git a/src/settings/kmail.kcfg.cmake b/src/settings/kmail.kcfg.cmake
index ef2720d20..c94248530 100644
--- a/src/settings/kmail.kcfg.cmake
+++ b/src/settings/kmail.kcfg.cmake
@@ -1,410 +1,413 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <kcfg xmlns="http://www.kde.org/standards/kcfg/1.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.kde.org/standards/kcfg/1.0
       http://www.kde.org/standards/kcfg/1.0/kcfg.xsd" >
   <include>qtextcodec.h</include>
   <include>QFontDatabase</include>
   <include>kcolorscheme.h</include>
   <include>editor/composer.h</include>
   <include>MessageComposer/Util</include>
   <include>KCompletion</include>
   <kcfgfile name="kmail2rc"/>
   <group name="Behaviour">
       <entry name="ActionEnterFolder"  type="Enum">
         <label></label>
         <whatsthis></whatsthis>
         <choices>
           <choice name="SelectFirstUnread"/>
           <choice name="SelectLastSelected"/>
           <choice name="SelectNewest"/>
           <choice name="SelectOldest"/>
         </choices>
         <default>SelectLastSelected</default>
       </entry>
       <entry name="NetworkState"  type="Enum">
         <choices>
           <choice name="Online"/>
           <choice name="Offline"/>
         </choices>
         <default>Online</default>
       </entry>
       <entry name="LoopOnGotoUnread"  type="Enum">
         <label></label>
         <whatsthis></whatsthis>
         <choices>
           <choice name="DontLoop"/>
           <choice name="LoopInCurrentFolder"/>
           <choice name="LoopInAllFolders"/>
           <choice name="LoopInAllMarkedFolders"/>
         </choices>
         <default>DontLoop</default>
       </entry>
       <entry name="ShowPopupAfterDnD"  type="Bool">
         <label></label>
         <whatsthis></whatsthis>
         <default>true</default>
       </entry>
       <entry name="ExcludeImportantMailFromExpiry"  type="Bool">
         <label></label>
         <whatsthis>This prevents the automatic expiry of old messages in a folder from deleting (or moving to an archive folder) the messages that are marked 'Important' or 'Action Item'</whatsthis>
         <default>true</default>
       </entry>
       <entry name="AllowLocalFlags" type="Bool">
         <label>Allow local flags in read-only folders</label>
         <default>false</default>
       </entry>
 
 
       <entry name="SendOnCheck"  type="Enum">
         <label>Send queued mail on mail check</label>
         <whatsthis>&lt;qt&gt;&lt;p&gt;Select whether you want KMail to send all messages in the outbox on manual or all mail checks, or whether you do not want messages to be sent automatically at all. &lt;/p&gt;&lt;/qt&gt;</whatsthis>
         <choices>
           <choice name="DontSendOnCheck"/>
           <choice name="SendOnManualChecks"/>
           <choice name="SendOnAllChecks"/>
         </choices>
         <default>DontSendOnCheck</default>
       </entry>
     </group>
 
     <group name="FolderSelectionDialog">
       <entry name="LastSelectedFolder" type="LongLong">
         <whatsthis>The most recently selected folder in the folder selection dialog.</whatsthis>
         <default>-1</default>
       </entry>
 
     </group>
 
     <group name="General">
       <entry name="WarnBeforeExpire" type="Bool" key="warn-before-expire">
         <default>true</default>
       </entry>
       <entry name="SystemTrayEnabled" type="Bool">
         <label>Enable system tray icon</label>
         <default>false</default>
       </entry>
       <entry name="ExternalEditor" type="String" key="external-editor">
         <label>Specify e&amp;ditor:</label>
         <default>kwrite %f</default>
       </entry>
       <entry name="UseExternalEditor" type="Bool" key="use-external-editor">
         <label>Use e&amp;xternal editor instead of composer</label>
         <default>false</default>
       </entry>
       <entry name="CustomMessageHeadersCount" type="Int" key="mime-header-count">
         <label>Specifies the number of custom MIME header fields to be inserted in messages (for internal use only)</label>
       </entry>
       <entry name="CloseToQuotaThreshold" type="Int">
         <label>The threshold for when to warn the user that a folder is nearing its quota limit.</label>
          <default>80</default>
       </entry>
       <entry name="EmptyTrashOnExit" type="Bool" key="empty-trash-on-exit">
         <label>Empty the local trash folder on program exit</label>
         <default>false</default>
       </entry>
       <entry name="StartSpecificFolderAtStartup" type="Bool" key="startSpecificFolderAtStatup">
         <label>Allow to start specific folder</label>
         <default>true</default>
       </entry>
       <entry name="StartupFolder" type="LongLong" key="startupFolder">
         <label>Specify the folder to open when the program is started</label>
         <default>-1</default>
       </entry>
       <entry name="CheckCollectionsIndexing" type="Bool" key="check-collections-indexing">
         <default>true</default>
       </entry>
       <entry name="AutoExpiring" type="Bool" key="auto-expiring">
         <label>Specifies whether the folders will expire in the background (for internal use only)</label>
         <default>true</default>
       </entry>
       <entry name="FirstStart" type="Bool" key="first-start">
         <label>Specifies whether this is the very first time that the application is run (for internal use only)</label>
         <default>true</default>
       </entry>
       <entry key="ShowMenuBar" type="Bool">
         <default>true</default>
          <!-- label and whatsthis are already provided by KStandardAction::showMenubar -->
         <label></label>
         <whatsthis></whatsthis>
       </entry>
       <entry key="ComposerShowMenuBar" type="Bool">
         <default>true</default>
          <!-- label and whatsthis are already provided by KStandardAction::showMenubar -->
         <label></label>
         <whatsthis></whatsthis>
       </entry>
-
+      <entry key="AskEnableUnifiedMailboxes" type="Bool">
+        <default>true</default>
+        <label>Whether to ask if users wants to enable Unified Mailboxes if more than one email accounts are detected. We only ever ask once.</label>
+      </entry>
     </group>
 <!-- General -->
 
 
     <group name="Internal">
       <entry name="PreviousNewFeaturesMD5" type="String" hidden="true">
         <whatsthis>This value is used to decide whether the KMail Introduction should be displayed.</whatsthis>
         <default></default>
       </entry>
     </group>
 
     <group name="UserInterface">
       <entry name="EnableFolderQuickSearch" type="Bool">
         <label>Show folder quick search line edit</label>
         <default>false</default>
       </entry>
     </group>
 
     <group name="Composer">
       <entry name="ForwardingInlineByDefault" type="Bool">
         <default>false</default>
         <label>Forward Inline As Default.</label>
       </entry>
        <entry name="TooManyRecipients" type="Bool" key="too-many-recipients">
         <label>Warn if the number of recipients is more than:</label>
         <default>${WARN_TOOMANY_RECIPIENTS_DEFAULT}</default>
         <whatsthis>If the number of recipients is larger than this value, KMail will warn and ask for a confirmation before sending the mail. The warning can be turned off.</whatsthis>
       </entry>
       <entry name="RecipientThreshold" type="Int" key="recipient-threshold">
         <label></label>
         <default>5</default>
         <min>1</min>
         <max>100</max>
         <whatsthis>If the number of recipients is larger than this value, KMail will warn and ask for a confirmation before sending the mail. The warning can be turned off.</whatsthis>
      </entry>
      <entry name="PreviousIdentity" type="UInt" key="previous-identity" />
       <entry name="PreviousFcc" type="String" key="previous-fcc" />
       <entry name="PreviousDictionary" type="String" />
       <entry name="CurrentTransport" type="String" key="current-transport" />
       <entry name="UseHtmlMarkup" type="Bool" key="html-markup">
         <default>false</default>
       </entry>
       <entry name="AlwaysEncryptDrafts" type="Bool" key="always-encrypt-drafts">
         <default>true</default>
       </entry>
 
       <entry name="ConfirmBeforeSend" type="Bool" key="confirm-before-send">
         <label>Confirm &amp;before send</label>
         <default>false</default>
       </entry>
       <entry name="ConfirmBeforeSendWhenUseShortcut" type="Bool" key="confirm-before-send-when-use-shortcut">
          <default>false</default>
       </entry>
       <entry name="CheckSpellingBeforeSend" type="Bool" key="check-spelling-before-send">
       <label>Check spelling before send</label>
         <default>false</default>
       </entry>
       <entry name="RequestMDN" type="Bool" key="request-mdn">
         <label>Automatically request &amp;message disposition notifications</label>
         <whatsthis>&lt;qt&gt;&lt;p&gt;Enable this option if you want KMail to request Message Disposition Notifications (MDNs) for each of your outgoing messages.&lt;/p&gt;&lt;p&gt;This option only affects the default; you can still enable or disable MDN requesting on a per-message basis in the composer, menu item &lt;em&gt;Options&lt;/em&gt;-&gt;&lt;em&gt;Request Disposition Notification&lt;/em&gt;.&lt;/p&gt;&lt;/qt&gt;</whatsthis>
         <default>false</default>
       </entry>
       <entry name="Headers" type="Int" key="headers">
         <default>KMail::Composer::HDR_SUBJECT|KMail::Composer::HDR_FROM</default>
       </entry>
       <entry name="CompletionMode" type="Int" key="Completion Mode">
         <default code="true">KCompletion::CompletionPopup</default>
       </entry>
       <entry name="AutoSpellChecking" type="Bool" key="autoSpellChecking">
         <default>true</default>
       </entry>
       <entry name="ShowForgottenAttachmentWarning" type="Bool" key="showForgottenAttachmentWarning">
         <default>true</default>
       </entry>
       <entry name="AttachmentKeywords" type="StringList" key="attachment-keywords">
         <default code="true">
         MessageComposer::Util::AttachmentKeywords()
         </default>
       </entry>
 
       <entry name="AutosaveInterval" type="Int" key="autosave">
         <label>Autosave interval:</label>
         <whatsthis>A backup copy of the text in the composer window can be created regularly. The interval used to create the backups is set here. You can disable autosaving by setting it to the value 0.</whatsthis>
         <default>2</default>
       </entry>
 
       <entry name="CustomTemplates" type="StringList" key="CustomTemplates" />
 
       <entry name="ShowSnippetManager" type="Bool">
           <label>Show the Text Snippet Management and Insertion Panel in the composer.</label>
           <default>false</default>
       </entry>
       <entry name="SnippetSplitterPosition" type="IntList"/>
 
       <entry name="CryptoStoreEncrypted" type="Bool" key="crypto-store-encrypted">
         <label>When check, sent messages will be stored in the encrypted form</label>
         <default>true</default>
       </entry>
       <entry name="RecentUrls" type="StringList" key="recent-urls">
         <label>A list of all the recently used URLs</label>
         <default code="true">
         QStringList()
         </default>
       </entry>
       <entry name="RecentEncodings" type="StringList" key="recent-encoding">
         <label>A list of all the recently used encodings</label>
         <default code="true">
         QStringList()
         </default>
       </entry>
       <entry name="ShowCryptoLabelIndicator" type="Bool">
        <label>Show crypto label indicator</label>
        <default>true</default>
       </entry>
       <entry name="CheckSendDefaultActionShortcut" type="Bool">
        <label>Validate Send Default Shortcut</label>
        <default>false</default>
       </entry>
     </group>
 <!-- Composer -->
 
     <group name="Fonts">
       <entry name="ComposerFont" type="Font" key="composer-font">
         <default code="true">QFontDatabase::systemFont(QFontDatabase::GeneralFont)</default>
       </entry>
     </group>
 
     <group name="Geometry">
       <entry name="ComposerSize" type="Size" key="composer">
         <default>QSize(800,600)</default>
       </entry>
       <entry name="IdentityDialogSize" type="Size" key="Identity Dialog size">
         <label>The size of the identity dialog (for internal use only)</label>
         <default>QSize()</default>
       </entry>
       <entry name="SearchWidgetWidth" type="Int">
         <label>The width of the search window (for internal use only)</label>
         <default>0</default>
       </entry>
       <entry name="SearchWidgetHeight" type="Int">
         <label>The height of the search window (for internal use only)</label>
         <default>0</default>
       </entry>
       <entry name="ConfigureDialogWidth" type="Int">
         <label>The width of the Configure KMail dialog (for internal use only)</label>
         <default>0</default>
       </entry>
       <entry name="ConfigureDialogHeight" type="Int">
         <label>The height of the Configure KMail dialog (for internal use only)</label>
         <default>0</default>
       </entry>
       <entry name="FolderViewWidth" type="Int">
         <default>250</default>
       </entry>
       <entry name="FolderViewHeight" type="Int">
         <default>500</default>
       </entry>
       <entry name="FolderTreeHeight" type="Int">
         <default>400</default>
       </entry>
       <entry name="SearchAndHeaderHeight" type="Int">
         <default>180</default>
       </entry>
       <entry name="SearchAndHeaderWidth" type="Int">
         <default>450</default>
       </entry>
       <entry name="ReaderWindowWidth" type="Int">
         <default>200</default>
       </entry>
       <entry name="ReaderWindowHeight" type="Int">
         <default>320</default>
       </entry>
 
       <entry name="readerWindowMode" type="Enum">
        <label>Message Preview Pane</label>
        <choices>
          <choice name="hide">
            <label>Do not show a message preview pane</label>
          </choice>
          <choice name="below">
            <label>Show the message preview pane below the message list</label>
          </choice>
          <choice name="right">
            <label>Show the message preview pane next to the message list</label>
          </choice>
        </choices>
        <default>below</default>
       </entry>
 
       <entry name="FolderList" type="Enum">
        <label>Folder List</label>
        <choices>
          <choice name="longlist">
            <label>Long folder list</label>
          </choice>
          <choice name="shortlist">
            <label>Short folder list</label>
          </choice>
        </choices>
        <default>longlist</default>
       </entry>
     </group>
 
   <group name="GlobalTemplates">
     <entry name="TemplateNewMessage" type="String" key="TemplateNewMessage">
       <label>Message template for new message</label>
       <whatsthis></whatsthis>
       <default code="true">TemplateParser::DefaultTemplates::defaultNewMessage()</default>
     </entry>
     <entry name="TemplateReply" type="String" key="TemplateReply">
       <label>Message template for reply</label>
       <whatsthis></whatsthis>
       <default code="true">TemplateParser::DefaultTemplates::defaultReply()</default>
     </entry>
     <entry name="TemplateReplyAll" type="String" key="TemplateReplyAll">
       <label>Message template for reply to all</label>
       <whatsthis></whatsthis>
       <default code="true">TemplateParser::DefaultTemplates::defaultReplyAll()</default>
     </entry>
     <entry name="TemplateForward" type="String" key="TemplateForward">
       <label>Message template for forward</label>
       <whatsthis></whatsthis>
       <default code="true">TemplateParser::DefaultTemplates::defaultForward()</default>
     </entry>
     <entry name="QuoteString" type="String" key="QuoteString">
       <label>Quote characters</label>
       <whatsthis></whatsthis>
       <default code="true">TemplateParser::DefaultTemplates::defaultQuoteString()</default>
     </entry>
   </group>
 
  <group name="Search">
    <entry name="LastSearchCollectionId" type="LongLong">
      <default>-1</default>
    </entry>
  </group>
 
  <!-- Main Folder View settings -->
  <group name="MainFolderView">
     <entry name="ToolTipDisplayPolicy" type="Int">
       <label>Specifies the policy used when displaying policy</label>
       <default>0</default>
     </entry>
  </group>
 
  <!-- Search Dialog settings -->
  <group name="SearchDialog">
    <entry name="CollectionWidth" type="Int">
      <label>Specifies the width of the collection field in the Search Window dialog (for internal use only)</label>
      <default>150</default>
    </entry>
    <entry name="SubjectWidth" type="Int">
      <label>Specifies the width of the subject field in the Search Window dialog (for internal use only)</label>
      <default>150</default>
    </entry>
    <entry name="SenderWidth" type="Int">
      <label>Specifies the width of the sender field in the Search Window dialog (for internal use only)</label>
      <default>120</default>
    </entry>
    <entry name="ReceiverWidth" type="Int">
      <label>Specifies the width of the receiver field in the Search Window dialog (for internal use only)</label>
      <default>120</default>
    </entry>
    <entry name="DateWidth" type="Int">
      <label>Specifies the width of the date field in the Search Window dialog (for internal use only)</label>
      <default>120</default>
    </entry>
    <entry name="FolderWidth" type="Int">
      <label>Specifies the width of the folder field in the Search Window dialog (for internal use only)</label>
      <default>100</default>
    </entry>
  </group>
 </kcfg>