kmkernel.cpp

/*   */

#include "kmkernel.h"

#include "settings/kmailsettings.h"
#include "libkdepim/broadcaststatus.h"
using KPIM::BroadcastStatus;
#include "kmstartup.h"
#include "kmmainwin.h"
#include "editor/composer.h"
#include "kmreadermainwin.h"
#include "undostack.h"
#include "kmreaderwin.h"
#include "kmmainwidget.h"
#include "libkdepim/recentaddresses.h"
using KPIM::RecentAddresses;
#include "configuredialog/configuredialog.h"
#include "kmcommands.h"
#include "kmsystemtray.h"
#include <MessageCore/StringUtil>
#include "mailcommon/mailutil.h"
#include "pop3settings.h"
#include "MailCommon/FolderTreeView"
#include "MailCommon/KMFilterDialog"
#include "mailcommonsettings_base.h"
#include "PimCommon/PimUtil"
#include "folderarchive/folderarchivemanager.h"
// kdepim includes
#include "kmail-version.h"

// kdepimlibs includes
#include <KIdentityManagement/kidentitymanagement/identity.h>
#include <KIdentityManagement/kidentitymanagement/identitymanager.h>
#include <MailTransport/mailtransport/transport.h>
#include <MailTransport/mailtransport/transportmanager.h>
#include <MailTransport/mailtransport/dispatcherinterface.h>
#include <AkonadiCore/servermanager.h>

#include <kwindowsystem.h>
#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 "TemplateParser/TemplateParser"
#include "globalsettings_templateparser.h"
#include "TemplateParser/TemplatesUtil"

#include "mailcommon/foldercollection.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 <QMimeDatabase>

#include <sys/types.h>
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#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 = Q_NULLPTR;
static bool s_askingToGoOnline = false;
static QNetworkConfigurationManager *s_networkConfigMgr = 0;
/********************************************************************/
/*                     Constructor and destructor                   */
/********************************************************************/
KMKernel::KMKernel(QObject *parent) :
    QObject(parent),
    mIdentityManager(Q_NULLPTR),
    mConfigureDialog(Q_NULLPTR),
    mMailService(Q_NULLPTR),
    mSystemNetworkStatus(true),
    mSystemTray(Q_NULLPTR),
    mDebugBaloo(false)
{
    mDebugBaloo = !qEnvironmentVariableIsEmpty("KDEPIM_BALOO_DEBUG");

    if (!s_networkConfigMgr) {
        s_networkConfigMgr = new QNetworkConfigurationManager(QCoreApplication::instance());
    }
    mSystemNetworkStatus = s_networkConfigMgr->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 = Q_NULLPTR;
    the_msgSender = Q_NULLPTR;
    mFilterEditDialog = Q_NULLPTR;
    mWin = Q_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);
    mXmlGuiInstance = QStringLiteral("kmail2");

    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.
    if (mNetCodec->name().toLower() == "eucjp"
#if defined Q_OS_WIN || defined Q_OS_MACX
            || netCodec->name().toLower() == "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(), SIGNAL(collectionChanged(Akonadi::Collection,QSet<QByteArray>)),
            SLOT(slotCollectionChanged(Akonadi::Collection,QSet<QByteArray>)));

    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(s_networkConfigMgr, &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);
}

KMKernel::~KMKernel()
{
    delete mMailService;
    mMailService = Q_NULLPTR;

    mSystemTray = Q_NULLPTR;

    stopAgentInstance();
    slotSyncConfig();

    delete mAutoCorrection;
    mySelf = Q_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;
    bool mailto = false;
    bool checkMail = false;
    bool viewOnly = false;
    bool calledWithSession = false; // for ignoring '-session foo'

    // process args:
    QCommandLineParser parser;
    kmail_options(&parser);
    parser.process(args);
    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("view"))) {
        viewOnly = true;
        const QString filename =
            parser.value(QStringLiteral("view"));
        messageFile = QUrl::fromLocalFile(filename);
        if (!messageFile.isValid()) {
            messageFile = QUrl();
            messageFile.setPath(filename);
        }
    }

    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(QStringLiteral("mailto:"), Qt::CaseInsensitive)) {
                QMap<QString, QString> values = MessageCore::StringUtil::parseMailtoUrl(QUrl::fromUserInput(arg));
                if (!values.value(QStringLiteral("to")).isEmpty()) {
                    to += values.value(QStringLiteral("to")) + QStringLiteral(", ");
                }
                if (!values.value(QStringLiteral("cc")).isEmpty()) {
                    cc += values.value(QStringLiteral("cc")) + QStringLiteral(", ");
                }
                if (!values.value(QStringLiteral("bcc")).isEmpty()) {
                    bcc += values.value(QStringLiteral("bcc")) + QStringLiteral(", ");
                }
                if (!values.value(QStringLiteral("subject")).isEmpty()) {
                    subj = values.value(QStringLiteral("subject"));
                }
                if (!values.value(QStringLiteral("body")).isEmpty()) {
                    body = values.value(QStringLiteral("body"));
                }
                if (!values.value(QStringLiteral("in-reply-to")).isEmpty()) {
                    inReplyTo = values.value(QStringLiteral("in-reply-to"));
                }
                QString attach = values.value(QStringLiteral("attachment"));
                if (!attach.isEmpty()) {
                    attachURLs << makeAbsoluteUrl(attach, workingDir);
                }
                attach = values.value(QStringLiteral("attach"));
                if (!attach.isEmpty()) {
                    attachURLs << makeAbsoluteUrl(attach, workingDir);
                }

            } 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);
    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();
    foreach (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);
}

void KMKernel::setSystrayIconNotificationsEnabled(bool enabled)
{
    if (mSystemTray) {
        mSystemTray->setSystrayIconNotificationsEnabled(enabled);
    }
}

QStringList KMKernel::accounts()
{
    QStringList accountLst;
    const Akonadi::AgentInstance::List lst = MailCommon::Util::agentInstances();
    accountLst.reserve(lst.count());
    foreach (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)
{
    mWin = Q_NULLPTR;
    KMainWindow *ktmw = Q_NULLPTR;

    foreach (KMainWindow *window, KMainWindow::memberList()) {
        if (::qobject_cast<KMMainWin *>(window)) {
            ktmw = window;
            break;
        }
    }

    bool activate;
    if (ktmw) {
        mWin = static_cast<KMMainWin *>(ktmw);
        activate = !onlyCheck; // existing window: only activate if not --check
        if (activate) {
            mWin->show();
        }
    } else {
        mWin = new KMMainWin;
        mWin->show();
        activate = false; // new window: no explicit activation (#73591)
    }

    if (activate) {
        // Activate window - doing this instead of KWindowSystem::activateWindow(mWin->winId());
        // so that it also works when called from KMailApplication::newInstance()
#if defined Q_OS_X11 && ! defined K_WS_QTONLY
        KStartupInfo::setNewStartupId(mWin, KStartupInfo::startupId());
#endif
    }
}

int 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)
{
    KMail::Composer::TemplateContext context = KMail::Composer::New;
    KMime::Message::Ptr msg(new KMime::Message);
    MessageHelper::initHeader(msg, identityManager());
    msg->contentType()->setCharset("utf-8");
    if (!to.isEmpty()) {
        msg->to()->fromUnicodeString(to, "utf-8");
    }

    if (!cc.isEmpty()) {
        msg->cc()->fromUnicodeString(cc, "utf-8");
    }

    if (!bcc.isEmpty()) {
        msg->bcc()->fromUnicodeString(bcc, "utf-8");
    }

    if (!subject.isEmpty()) {
        msg->subject()->fromUnicodeString(subject, "utf-8");
    }

    if (!messageFile.isEmpty() && QFile::exists(messageFile)) {
        QFile f(messageFile);
        QByteArray str;
        if (!f.open(QIODevice::ReadOnly)) {
            qCWarning(KMAIL_LOG) << "Failed to load message: " << f.errorString();
        } else {
            str = f.readAll();
            f.close();
        }
        if (!str.isEmpty()) {
            context = KMail::Composer::NoTemplate;
            msg->setBody(QString::fromLocal8Bit(str.data(), str.size()).toUtf8());
        } else {
            TemplateParser::TemplateParser parser(msg, TemplateParser::TemplateParser::NewMessage);
            parser.setIdentityManager(KMKernel::self()->identityManager());
            parser.process(msg);
        }
    } else if (!body.isEmpty()) {
        context = KMail::Composer::NoTemplate;
        msg->setBody(body.toUtf8());
    } else {
        TemplateParser::TemplateParser parser(msg, TemplateParser::TemplateParser::NewMessage);
        parser.setIdentityManager(KMKernel::self()->identityManager());
        parser.process(msg);
    }

    if (!inReplyTo.isEmpty()) {
        KMime::Headers::InReplyTo *header = new KMime::Headers::InReplyTo;
        header->fromUnicodeString(inReplyTo, "utf-8");
        msg->setHeader(header);
    }

    msg->assemble();
    KMail::Composer *cWin = KMail::makeComposer(msg, false, false, context);
    if (!to.isEmpty()) {
        cWin->setFocusToSubject();
    }
    QList<QUrl> attachURLs = QUrl::fromStringList(attachmentPaths);
    QList<QUrl>::ConstIterator endAttachment(attachURLs.constEnd());
    for (QList<QUrl>::ConstIterator it = attachURLs.constBegin(); it != endAttachment; ++it) {
        QMimeDatabase mimeDb;
        if (mimeDb.mimeTypeForUrl(*it).name() == QLatin1String("inode/directory")) {
            if (KMessageBox::questionYesNo(Q_NULLPTR, i18n("Do you want to attach this folder \"%1\"?", (*it).toDisplayString()), i18n("Attach Folder")) == KMessageBox::No) {
                continue;
            }
        }
        cWin->addAttachment((*it), QString());
    }
    if (!replyTo.isEmpty()) {
        cWin->setCurrentReplyTo(replyTo);
    }

    if (!customHeaders.isEmpty()) {
        QMap<QByteArray, QString> extraCustomHeaders;
        QStringList::ConstIterator end = customHeaders.constEnd();
        for (QStringList::ConstIterator it = customHeaders.constBegin(); it != end; ++it) {
            if (!(*it).isEmpty()) {
                const int pos = (*it).indexOf(QLatin1Char(':'));
                if (pos > 0) {
                    const QString header = (*it).left(pos).trimmed();
                    const QString value = (*it).mid(pos + 1).trimmed();
                    if (!header.isEmpty() && !value.isEmpty()) {
                        extraCustomHeaders.insert(header.toUtf8(), value);
                    }
                }
            }
        }
        if (!extraCustomHeaders.isEmpty()) {
            cWin->addExtraCustomHeaders(extraCustomHeaders);
        }
    }
    if (!hidden) {
        cWin->show();
        // Activate window - doing this instead of KWindowSystem::activateWindow(cWin->winId());
        // so that it also works when called from KMailApplication::newInstance()
#if defined Q_OS_X11 && ! defined K_WS_QTONLY
        KStartupInfo::setNewStartupId(cWin, KStartupInfo::startupId());
#endif
    }
    return 1;
}

int 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)
{
    KMail::Composer *cWin;
    bool iCalAutoSend = fillComposer(cWin, to, cc, bcc,
                                     subject, body,
                                     attachName, attachCte, attachData,
                                     attachType, attachSubType, attachParamAttr, attachParamValue,
                                     attachContDisp, attachCharset, identity);

    if (!hidden && !iCalAutoSend) {
        cWin->show();
        // Activate window - doing this instead of KWin::activateWindow(cWin->winId());
        // so that it also works when called from KMailApplication::newInstance()
#if defined Q_WS_X11 && ! defined K_WS_QTONLY
        KStartupInfo::setNewStartupId(cWin, KStartupInfo::startupId());
#endif
    } else {

        // Always disable word wrap when we don't show the composer, since otherwise QTextEdit
        // gets the widget size wrong and wraps much too early.
        cWin->disableWordWrap();
        cWin->slotSendNow();
    }
    return 1;
}

int 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)
{
    KMail::Composer *cWin;
    fillComposer(cWin, to, cc, bcc,
                 subject, body,
                 attachName, attachCte, attachData,
                 attachType, attachSubType, attachParamAttr, attachParamValue,
                 attachContDisp, attachCharset, identity);
    cWin->show();
    // Activate window - doing this instead of KWin::activateWindow(cWin->winId());
    // so that it also works when called from KMailApplication::newInstance()
#if defined Q_WS_X11 && ! defined K_WS_QTONLY
    KStartupInfo::setNewStartupId(cWin, KStartupInfo::startupId());
#endif

    return 1;
}

bool KMKernel::fillComposer(KMail::Composer *&cWin,
                            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)
{
    KMail::Composer::TemplateContext context = KMail::Composer::New;
    KMime::Message::Ptr msg(new KMime::Message);
    KMime::Content *msgPart = Q_NULLPTR;
    MessageHelper::initHeader(msg, identityManager());
    msg->contentType()->setCharset("utf-8");
    if (!cc.isEmpty()) {
        msg->cc()->fromUnicodeString(cc, "utf-8");
    }
    if (!bcc.isEmpty()) {
        msg->bcc()->fromUnicodeString(bcc, "utf-8");
    }
    if (!subject.isEmpty()) {
        msg->subject()->fromUnicodeString(subject, "utf-8");
    }
    if (!to.isEmpty()) {
        msg->to()->fromUnicodeString(to, "utf-8");
    }
    if (identity > 0) {
        KMime::Headers::Generic *h = new KMime::Headers::Generic("X-KMail-Identity");
        h->from7BitString(QByteArray::number(identity));