diff --git a/messageviewer/src/messagepartthemes/default/defaultrenderer.cpp b/messageviewer/src/messagepartthemes/default/defaultrenderer.cpp
index 85b77616..1b6c4976 100644
--- a/messageviewer/src/messagepartthemes/default/defaultrenderer.cpp
+++ b/messageviewer/src/messagepartthemes/default/defaultrenderer.cpp
@@ -1,913 +1,913 @@
 /*
    Copyright (c) 2016 Sandro Knauß <sknauss@kde.org>
 
    This library is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public License as published by
    the Free Software Foundation; either version 2 of the License, or (at your
    option) any later version.
 
    This library is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
    License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
 */
 
 #include "defaultrenderer.h"
 
 #include "defaultrenderer_p.h"
 
 #include "messageviewer_debug.h"
 
 #include "converthtmltoplaintext.h"
 #include "messagepartrendererbase.h"
 #include "messagepartrendererfactory.h"
 #include "htmlblock.h"
 
 #include "utils/iconnamecache.h"
 #include "utils/mimetype.h"
 #include "viewer/csshelperbase.h"
 #include "messagepartrenderermanager.h"
 
 #include <MimeTreeParser/BufferedHtmlWriter>
 #include <MimeTreeParser/MessagePart>
 #include <MimeTreeParser/ObjectTreeParser>
 #include <GrantleeTheme/QtResourceTemplateLoader>
 
 #include <QGpgME/Protocol>
 
 #include <MessageCore/StringUtil>
 
 #include <KEmailAddress>
 #include <KIconLoader>
 #include <KLocalizedString>
 
 #include <QApplication>
 #include <QUrl>
 
 #include <grantlee/context.h>
 #include <grantlee/engine.h>
 #include <grantlee/metatype.h>
 #include <grantlee/templateloader.h>
 #include <grantlee/template.h>
 
 using namespace MimeTreeParser;
 using namespace MessageViewer;
 
 Q_DECLARE_METATYPE(GpgME::DecryptionResult::Recipient)
 Q_DECLARE_METATYPE(const QGpgME::Protocol *)
 
 static const int SIG_FRAME_COL_UNDEF = 99;
 #define SIG_FRAME_COL_RED    -1
 #define SIG_FRAME_COL_YELLOW  0
 #define SIG_FRAME_COL_GREEN   1
 QString sigStatusToString(const QGpgME::Protocol *cryptProto, int status_code, GpgME::Signature::Summary summary, int &frameColor, bool &showKeyInfos)
 {
     // note: At the moment frameColor and showKeyInfos are
     //       used for CMS only but not for PGP signatures
     // pending(khz): Implement usage of these for PGP sigs as well.
     showKeyInfos = true;
     QString result;
     if (cryptProto) {
         if (cryptProto == QGpgME::openpgp()) {
             // process enum according to it's definition to be read in
             // GNU Privacy Guard CVS repository /gpgme/gpgme/gpgme.h
             switch (status_code) {
             case 0: // GPGME_SIG_STAT_NONE
                 result = i18n("Error: Signature not verified");
                 break;
             case 1: // GPGME_SIG_STAT_GOOD
                 result = i18n("Good signature");
                 break;
             case 2: // GPGME_SIG_STAT_BAD
                 result = i18n("Bad signature");
                 break;
             case 3: // GPGME_SIG_STAT_NOKEY
                 result = i18n("No public key to verify the signature");
                 break;
             case 4: // GPGME_SIG_STAT_NOSIG
                 result = i18n("No signature found");
                 break;
             case 5: // GPGME_SIG_STAT_ERROR
                 result = i18n("Error verifying the signature");
                 break;
             case 6: // GPGME_SIG_STAT_DIFF
                 result = i18n("Different results for signatures");
                 break;
             /* PENDING(khz) Verify exact meaning of the following values:
             case 7: // GPGME_SIG_STAT_GOOD_EXP
             return i18n("Signature certificate is expired");
             break;
             case 8: // GPGME_SIG_STAT_GOOD_EXPKEY
             return i18n("One of the certificate's keys is expired");
             break;
             */
             default:
                 result.clear();   // do *not* return a default text here !
                 break;
             }
         } else if (cryptProto == QGpgME::smime()) {
             // process status bits according to SigStatus_...
             // definitions in kdenetwork/libkdenetwork/cryptplug.h
 
             if (summary == GpgME::Signature::None) {
                 result = i18n("No status information available.");
                 frameColor = SIG_FRAME_COL_YELLOW;
                 showKeyInfos = false;
                 return result;
             }
 
             if (summary & GpgME::Signature::Valid) {
                 result = i18n("Good signature.");
                 // Note:
                 // Here we are work differently than KMail did before!
                 //
                 // The GOOD case ( == sig matching and the complete
                 // certificate chain was verified and is valid today )
                 // by definition does *not* show any key
                 // information but just states that things are OK.
                 //           (khz, according to LinuxTag 2002 meeting)
                 frameColor = SIG_FRAME_COL_GREEN;
                 showKeyInfos = false;
                 return result;
             }
 
             // we are still there?  OK, let's test the different cases:
 
             // we assume green, test for yellow or red (in this order!)
             frameColor = SIG_FRAME_COL_GREEN;
             QString result2;
             if (summary & GpgME::Signature::KeyExpired) {
                 // still is green!
                 result2 = i18n("One key has expired.");
             }
             if (summary & GpgME::Signature::SigExpired) {
                 // and still is green!
                 result2 += i18n("The signature has expired.");
             }
 
             // test for yellow:
             if (summary & GpgME::Signature::KeyMissing) {
                 result2 += i18n("Unable to verify: key missing.");
                 // if the signature certificate is missing
                 // we cannot show information on it
                 showKeyInfos = false;
                 frameColor = SIG_FRAME_COL_YELLOW;
             }
             if (summary & GpgME::Signature::CrlMissing) {
                 result2 += i18n("CRL not available.");
                 frameColor = SIG_FRAME_COL_YELLOW;
             }
             if (summary & GpgME::Signature::CrlTooOld) {
                 result2 += i18n("Available CRL is too old.");
                 frameColor = SIG_FRAME_COL_YELLOW;
             }
             if (summary & GpgME::Signature::BadPolicy) {
                 result2 += i18n("A policy was not met.");
                 frameColor = SIG_FRAME_COL_YELLOW;
             }
             if (summary & GpgME::Signature::SysError) {
                 result2 += i18n("A system error occurred.");
                 // if a system error occurred
                 // we cannot trust any information
                 // that was given back by the plug-in
                 showKeyInfos = false;
                 frameColor = SIG_FRAME_COL_YELLOW;
             }
 
             // test for red:
             if (summary & GpgME::Signature::KeyRevoked) {
                 // this is red!
                 result2 += i18n("One key has been revoked.");
                 frameColor = SIG_FRAME_COL_RED;
             }
             if (summary & GpgME::Signature::Red) {
                 if (result2.isEmpty()) {
                     // Note:
                     // Here we are work differently than KMail did before!
                     //
                     // The BAD case ( == sig *not* matching )
                     // by definition does *not* show any key
                     // information but just states that things are BAD.
                     //
                     // The reason for this: In this case ALL information
                     // might be falsificated, we can NOT trust the data
                     // in the body NOT the signature - so we don't show
                     // any key/signature information at all!
                     //         (khz, according to LinuxTag 2002 meeting)
                     showKeyInfos = false;
                 }
                 frameColor = SIG_FRAME_COL_RED;
             } else {
                 result.clear();
             }
 
             if (SIG_FRAME_COL_GREEN == frameColor) {
                 result = i18n("Good signature.");
             } else if (SIG_FRAME_COL_RED == frameColor) {
                 result = i18n("Bad signature.");
             } else {
                 result.clear();
             }
 
             if (!result2.isEmpty()) {
                 if (!result.isEmpty()) {
                     result.append(QLatin1String("<br />"));
                 }
                 result.append(result2);
             }
         }
         /*
         // add i18n support for 3rd party plug-ins here:
         else if ( cryptPlug->libName().contains( "yetanotherpluginname", Qt::CaseInsensitive )) {
 
         }
         */
     }
     return result;
 }
 
 /** Checks whether @p str contains external references. To be precise,
     we only check whether @p str contains 'xxx="http[s]:' where xxx is
     not href. Obfuscated external references are ignored on purpose.
 */
 
 bool containsExternalReferences(const QString &str, const QString &extraHead)
 {
     const bool hasBaseInHeader = extraHead.contains(QStringLiteral(
                                                         "<base href=\""), Qt::CaseInsensitive);
     if (hasBaseInHeader && (str.contains(QStringLiteral("href=\"/"), Qt::CaseInsensitive)
                             || str.contains(QStringLiteral("<img src=\"/"), Qt::CaseInsensitive))) {
         return true;
     }
     int httpPos = str.indexOf(QLatin1String("\"http:"), Qt::CaseInsensitive);
     int httpsPos = str.indexOf(QLatin1String("\"https:"), Qt::CaseInsensitive);
 
     while (httpPos >= 0 || httpsPos >= 0) {
         // pos = index of next occurrence of "http: or "https: whichever comes first
         int pos = (httpPos < httpsPos)
                   ? ((httpPos >= 0) ? httpPos : httpsPos)
                   : ((httpsPos >= 0) ? httpsPos : httpPos);
         // look backwards for "href"
         if (pos > 5) {
             int hrefPos = str.lastIndexOf(QLatin1String("href"), pos - 5, Qt::CaseInsensitive);
             // if no 'href' is found or the distance between 'href' and '"http[s]:'
             // is larger than 7 (7 is the distance in 'href = "http[s]:') then
             // we assume that we have found an external reference
             if ((hrefPos == -1) || (pos - hrefPos > 7)) {
                 // HTML messages created by KMail itself for now contain the following:
                 // <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
                 // Make sure not to show an external references warning for this string
                 int dtdPos = str.indexOf(QLatin1String(
                                              "http://www.w3.org/TR/html4/loose.dtd"), pos + 1);
                 if (dtdPos != (pos + 1)) {
                     return true;
                 }
             }
         }
         // find next occurrence of "http: or "https:
         if (pos == httpPos) {
             httpPos = str.indexOf(QLatin1String("\"http:"), httpPos + 6, Qt::CaseInsensitive);
         } else {
             httpsPos = str.indexOf(QLatin1String("\"https:"), httpsPos + 7, Qt::CaseInsensitive);
         }
     }
     return false;
 }
 
 // FIXME this used to go through the full webkit parser to extract the body and head blocks
 // until we have that back, at least attempt to fix some of the damage
 // yes, "parsing" HTML with regexps is very very wrong, but it's still better than not filtering
 // this at all...
 QString processHtml(const QString &htmlSource, QString &extraHead)
 {
     auto s = htmlSource.trimmed();
     s = s.replace(QRegExp(QStringLiteral("^<!DOCTYPE[^>]*>"), Qt::CaseInsensitive), QString()).trimmed();
     s = s.replace(QRegExp(QStringLiteral("^<html[^>]*>"), Qt::CaseInsensitive), QString()).trimmed();
 
     // head
     s = s.replace(QRegExp(QStringLiteral("^<head/>"), Qt::CaseInsensitive), QString()).trimmed();
     if (s.startsWith(QLatin1String("<head>", Qt::CaseInsensitive))) {
         const auto idx = s.indexOf(QLatin1String("</head>"), Qt::CaseInsensitive);
         if (idx < 0) {
             return htmlSource;
         }
         extraHead = s.mid(6, idx - 6);
         s = s.mid(idx + 7).trimmed();
     }
 
     // body
     s = s.replace(QRegExp(QStringLiteral("<body[^>]*>"), Qt::CaseInsensitive), QString()).trimmed();
     s = s.replace(QRegExp(QStringLiteral("</html>$"), Qt::CaseInsensitive), QString()).trimmed();
     s = s.replace(QRegExp(QStringLiteral("</body>$"), Qt::CaseInsensitive), QString()).trimmed();
     return s;
 }
 
 DefaultRendererPrivate::DefaultRendererPrivate(const MessagePart::Ptr &msgPart, CSSHelperBase *cssHelper, HtmlWriter *writer, const MessagePartRendererFactory *rendererFactory)
     : mMsgPart(msgPart)
     , mCSSHelper(cssHelper)
     , mRendererFactory(rendererFactory)
 {
     renderFactory(mMsgPart, writer);
 }
 
 DefaultRendererPrivate::~DefaultRendererPrivate()
 {
 }
 
 CSSHelperBase *DefaultRendererPrivate::cssHelper() const
 {
     return mCSSHelper;
 }
 
 Interface::ObjectTreeSource *DefaultRendererPrivate::source() const
 {
     return mMsgPart->source();
 }
 
 void DefaultRendererPrivate::renderSubParts(const MessagePart::Ptr &msgPart, HtmlWriter *htmlWriter)
 {
     foreach (const auto &m, msgPart->subParts()) {
         renderFactory(m, htmlWriter);
     }
 }
 
 void DefaultRendererPrivate::render(const MessagePartList::Ptr &mp, HtmlWriter *htmlWriter)
 {
     HTMLBlock::Ptr rBlock;
     HTMLBlock::Ptr aBlock;
 
     if (mp->isRoot()) {
         rBlock = HTMLBlock::Ptr(new RootBlock(htmlWriter));
     }
 
     if (mp->isAttachment()) {
         aBlock = HTMLBlock::Ptr(new AttachmentMarkBlock(htmlWriter, mp->attachmentContent()));
     }
 
     renderSubParts(mp, htmlWriter);
 }
 
 void DefaultRendererPrivate::render(const MimeMessagePart::Ptr &mp, HtmlWriter *htmlWriter)
 {
     HTMLBlock::Ptr aBlock;
     HTMLBlock::Ptr rBlock;
     if (mp->isAttachment()) {
         aBlock = HTMLBlock::Ptr(new AttachmentMarkBlock(htmlWriter, mp->attachmentContent()));
     }
 
     if (mp->isRoot()) {
         rBlock = HTMLBlock::Ptr(new RootBlock(htmlWriter));
     }
 
     renderSubParts(mp, htmlWriter);
 }
 
 void DefaultRendererPrivate::render(const EncapsulatedRfc822MessagePart::Ptr &mp, HtmlWriter *htmlWriter)
 {
     if (!mp->hasSubParts()) {
         return;
     }
     Grantlee::Template t = MessagePartRendererManager::self()->loadByName(QStringLiteral(":/encapsulatedrfc822messagepart.html"));
     Grantlee::Context c = MessagePartRendererManager::self()->createContext();
     QObject block;
 
     c.insert(QStringLiteral("block"), &block);
     block.setProperty("link",
-                      mp->mOtp->nodeHelper()->asHREF(mp->mMessage.data(), QStringLiteral("body")));
+                      mp->nodeHelper()->asHREF(mp->mMessage.data(), QStringLiteral("body")));
 
     c.insert(QStringLiteral("msgHeader"), mp->source()->createMessageHeader(mp->mMessage.data()));
     c.insert(QStringLiteral("content"), QVariant::fromValue<GrantleeCallback>([this, mp, htmlWriter](Grantlee::OutputStream *) {
         renderSubParts(mp, htmlWriter);
     }));
 
     HTMLBlock::Ptr aBlock;
     if (mp->isAttachment()) {
         aBlock = HTMLBlock::Ptr(new AttachmentMarkBlock(htmlWriter, mp->attachmentContent()));
     }
     Grantlee::OutputStream s(htmlWriter->stream());
     t->render(&s, &c);
 }
 
 void DefaultRendererPrivate::render(const HtmlMessagePart::Ptr &mp, HtmlWriter *htmlWriter)
 {
     Grantlee::Template t = MessageViewer::MessagePartRendererManager::self()->loadByName(QStringLiteral(
                                                                                              ":/htmlmessagepart.html"));
     Grantlee::Context c = MessageViewer::MessagePartRendererManager::self()->createContext();
     QObject block;
 
     c.insert(QStringLiteral("block"), &block);
 
     auto preferredMode = mp->source()->preferredMode();
     bool isHtmlPreferred = (preferredMode == Util::Html) || (preferredMode == Util::MultipartHtml);
     const bool isPrinting = mp->source()->isPrinting();
     block.setProperty("htmlMail", isHtmlPreferred);
     block.setProperty("loadExternal", mp->source()->htmlLoadExternal());
     block.setProperty("isPrinting", isPrinting);
     {
         QString extraHead;
         //laurent: FIXME port to async method webengine
         QString bodyText = processHtml(mp->mBodyHTML, extraHead);
 
         if (isHtmlPreferred) {
-            mp->mOtp->nodeHelper()->setNodeDisplayedEmbedded(mp->content(), true);
+            mp->nodeHelper()->setNodeDisplayedEmbedded(mp->content(), true);
             htmlWriter->extraHead(extraHead);
         }
 
         block.setProperty("containsExternalReferences",
                           containsExternalReferences(bodyText, extraHead));
         c.insert(QStringLiteral("content"), bodyText);
     }
 
     {
         ConvertHtmlToPlainText convert;
         convert.setHtmlString(mp->mBodyHTML);
         QString plaintext = convert.generatePlainText();
         plaintext.replace(QLatin1Char('\n'), QStringLiteral("<br>"));
         c.insert(QStringLiteral("plaintext"), plaintext);
     }
     mp->source()->setHtmlMode(Util::Html, QList<Util::HtmlMode>() << Util::Html);
 
     HTMLBlock::Ptr aBlock;
     if (mp->isAttachment()) {
         aBlock = HTMLBlock::Ptr(new AttachmentMarkBlock(htmlWriter, mp->attachmentContent()));
     }
     Grantlee::OutputStream s(htmlWriter->stream());
     t->render(&s, &c);
 }
 
 void DefaultRendererPrivate::renderEncrypted(const EncryptedMessagePart::Ptr &mp, HtmlWriter *htmlWriter)
 {
     KMime::Content *node = mp->content();
     const auto metaData = *mp->partMetaData();
 
     Grantlee::Template t = MessageViewer::MessagePartRendererManager::self()->loadByName(QStringLiteral(
                                                                                              ":/encryptedmessagepart.html"));
     Grantlee::Context c = MessageViewer::MessagePartRendererManager::self()->createContext();
     QObject block;
 
     if (node || mp->hasSubParts()) {
         c.insert(QStringLiteral("content"), QVariant::fromValue<GrantleeCallback>([this, mp, htmlWriter](Grantlee::OutputStream *) {
             HTMLBlock::Ptr rBlock;
             if (mp->content() && mp->isRoot()) {
                 rBlock = HTMLBlock::Ptr(new RootBlock(htmlWriter));
             }
             renderSubParts(mp, htmlWriter);
         }));
     } else if (!metaData.inProgress) {
         c.insert(QStringLiteral("content"), QVariant::fromValue<GrantleeCallback>([this, mp, htmlWriter](Grantlee::OutputStream *) {
             renderWithFactory(QStringLiteral("MimeTreeParser::MessagePart"), mp, htmlWriter);
         }));
     }
 
     c.insert(QStringLiteral("cryptoProto"), QVariant::fromValue(mp->mCryptoProto));
     if (mp->mDecryptRecipients.size() > 0) {
         c.insert(QStringLiteral("decryptedRecipients"),
                  QVariant::fromValue(mp->mDecryptRecipients));
     }
     c.insert(QStringLiteral("block"), &block);
 
     block.setProperty("inProgress", metaData.inProgress);
     block.setProperty("isDecrypted", mp->decryptMessage());
     block.setProperty("isDecryptable", metaData.isDecryptable);
     block.setProperty("decryptIcon",
                       QUrl::fromLocalFile(IconNameCache::instance()->iconPath(QStringLiteral(
                                                                                   "document-decrypt"),
                                                                               KIconLoader::Small)).url());
     block.setProperty("errorText", metaData.errorText);
     block.setProperty("noSecKey", mp->mNoSecKey);
 
     Grantlee::OutputStream s(htmlWriter->stream());
     t->render(&s, &c);
 }
 
 void DefaultRendererPrivate::renderSigned(const SignedMessagePart::Ptr &mp, HtmlWriter *htmlWriter)
 {
     KMime::Content *node = mp->content();
     const auto metaData = *mp->partMetaData();
     auto cryptoProto = mp->mCryptoProto;
 
     const bool isSMIME = cryptoProto && (cryptoProto == QGpgME::smime());
 
     Grantlee::Template t = MessageViewer::MessagePartRendererManager::self()->loadByName(QStringLiteral(
                                                                                              ":/signedmessagepart.html"));
     Grantlee::Context c = MessageViewer::MessagePartRendererManager::self()->createContext();
     QObject block;
 
     if (node) {
         c.insert(QStringLiteral("content"), QVariant::fromValue<GrantleeCallback>([this, mp, htmlWriter](Grantlee::OutputStream *) {
             HTMLBlock::Ptr rBlock;
             if (mp->isRoot()) {
                 rBlock = HTMLBlock::Ptr(new RootBlock(htmlWriter));
             }
             renderSubParts(mp, htmlWriter);
         }));
     } else if (!metaData.inProgress) {
         c.insert(QStringLiteral("content"), QVariant::fromValue<GrantleeCallback>([this, mp, htmlWriter](Grantlee::OutputStream *) {
             renderWithFactory(QStringLiteral("MimeTreeParser::MessagePart"), mp, htmlWriter);
         }));
     }
 
     c.insert(QStringLiteral("cryptoProto"), QVariant::fromValue(cryptoProto));
     c.insert(QStringLiteral("block"), &block);
 
     block.setProperty("inProgress", metaData.inProgress);
     block.setProperty("errorText", metaData.errorText);
 
     block.setProperty("detailHeader", mp->source()->showSignatureDetails());
     block.setProperty("printing", false);
     block.setProperty("addr", metaData.signerMailAddresses.join(QLatin1Char(',')));
     block.setProperty("technicalProblem", metaData.technicalProblem);
     block.setProperty("keyId", metaData.keyId);
     if (metaData.creationTime.isValid()) {      //should be handled inside grantlee but currently not possible see: https://bugs.kde.org/363475
         block.setProperty("creationTime",
                           QLocale().toString(metaData.creationTime, QLocale::ShortFormat));
     }
     block.setProperty("isGoodSignature", metaData.isGoodSignature);
     block.setProperty("isSMIME", isSMIME);
 
     if (metaData.keyTrust == GpgME::Signature::Unknown) {
         block.setProperty("keyTrust", QStringLiteral("unknown"));
     } else if (metaData.keyTrust == GpgME::Signature::Marginal) {
         block.setProperty("keyTrust", QStringLiteral("marginal"));
     } else if (metaData.keyTrust == GpgME::Signature::Full) {
         block.setProperty("keyTrust", QStringLiteral("full"));
     } else if (metaData.keyTrust == GpgME::Signature::Ultimate) {
         block.setProperty("keyTrust", QStringLiteral("ultimate"));
     } else {
         block.setProperty("keyTrust", QStringLiteral("untrusted"));
     }
 
     QString startKeyHREF;
     {
         QString keyWithWithoutURL;
         if (cryptoProto) {
             startKeyHREF
                 = QStringLiteral("<a href=\"kmail:showCertificate#%1 ### %2 ### %3\">")
                   .arg(cryptoProto->displayName(),
                        cryptoProto->name(),
                        QString::fromLatin1(metaData.keyId));
 
             keyWithWithoutURL
                 = QStringLiteral("%1%2</a>").arg(startKeyHREF,
                                                  QString::fromLatin1(QByteArray(QByteArrayLiteral(
                                                                                     "0x")
                                                                                 + metaData.keyId)));
         } else {
             keyWithWithoutURL = QStringLiteral("0x") + QString::fromUtf8(metaData.keyId);
         }
         block.setProperty("keyWithWithoutURL", keyWithWithoutURL);
     }
 
     bool onlyShowKeyURL = false;
     bool showKeyInfos = false;
     bool cannotCheckSignature = true;
     QString signer = metaData.signer;
     QString statusStr;
     QString mClass;
     QString greenCaseWarning;
 
     if (metaData.inProgress) {
         mClass = QStringLiteral("signInProgress");
     } else {
         const QStringList &blockAddrs(metaData.signerMailAddresses);
         // note: At the moment frameColor and showKeyInfos are
         //       used for CMS only but not for PGP signatures
         // pending(khz): Implement usage of these for PGP sigs as well.
         int frameColor = SIG_FRAME_COL_UNDEF;
         statusStr = sigStatusToString(cryptoProto,
                                       metaData.status_code,
                                       metaData.sigSummary,
                                       frameColor,
                                       showKeyInfos);
         // if needed fallback to english status text
         // that was reported by the plugin
         if (statusStr.isEmpty()) {
             statusStr = metaData.status;
         }
         if (metaData.technicalProblem) {
             frameColor = SIG_FRAME_COL_YELLOW;
         }
 
         switch (frameColor) {
         case SIG_FRAME_COL_RED:
             cannotCheckSignature = false;
             break;
         case SIG_FRAME_COL_YELLOW:
             cannotCheckSignature = true;
             break;
         case SIG_FRAME_COL_GREEN:
             cannotCheckSignature = false;
             break;
         }
 
         // temporary hack: always show key information!
         showKeyInfos = true;
 
         if (isSMIME && (SIG_FRAME_COL_UNDEF != frameColor)) {
             switch (frameColor) {
             case SIG_FRAME_COL_RED:
                 mClass = QStringLiteral("signErr");
                 onlyShowKeyURL = true;
                 break;
             case SIG_FRAME_COL_YELLOW:
                 if (metaData.technicalProblem) {
                     mClass = QStringLiteral("signWarn");
                 } else {
                     mClass = QStringLiteral("signOkKeyBad");
                 }
                 break;
             case SIG_FRAME_COL_GREEN:
                 mClass = QStringLiteral("signOkKeyOk");
                 // extra hint for green case
                 // that email addresses in DN do not match fromAddress
                 QString msgFrom(KEmailAddress::extractEmailAddress(mp->mFromAddress));
                 QString certificate;
                 if (metaData.keyId.isEmpty()) {
                     certificate = i18n("certificate");
                 } else {
                     certificate = startKeyHREF + i18n("certificate") + QStringLiteral("</a>");
                 }
 
                 if (!blockAddrs.empty()) {
                     if (!blockAddrs.contains(msgFrom, Qt::CaseInsensitive)) {
                         greenCaseWarning
                             = QStringLiteral("<u>")
                               +i18nc("Start of warning message.", "Warning:")
                               +QStringLiteral("</u> ")
                               +i18n(
                             "Sender's mail address is not stored in the %1 used for signing.",
                             certificate)
                               +QStringLiteral("<br />")
                               +i18n("sender: ")
                               +msgFrom
                               +QStringLiteral("<br />")
                               +i18n("stored: ");
                         // We cannot use Qt's join() function here but
                         // have to join the addresses manually to
                         // extract the mail addresses (without '<''>')
                         // before including it into our string:
                         bool bStart = true;
                         QStringList::ConstIterator end(blockAddrs.constEnd());
                         for (QStringList::ConstIterator it = blockAddrs.constBegin();
                              it != end; ++it) {
                             if (!bStart) {
                                 greenCaseWarning.append(QStringLiteral(", <br />&nbsp; &nbsp;"));
                             }
 
                             bStart = false;
                             greenCaseWarning.append(KEmailAddress::extractEmailAddress(*it));
                         }
                     }
                 } else {
                     greenCaseWarning
                         = QStringLiteral("<u>")
                           +i18nc("Start of warning message.", "Warning:")
                           +QStringLiteral("</u> ")
                           +i18n("No mail address is stored in the %1 used for signing, "
                                 "so we cannot compare it to the sender's address %2.",
                                 certificate,
                                 msgFrom);
                 }
                 break;
             }
 
             if (showKeyInfos && !cannotCheckSignature) {
                 if (metaData.signer.isEmpty()) {
                     signer.clear();
                 } else {
                     if (!blockAddrs.empty()) {
                         const QUrl address = KEmailAddress::encodeMailtoUrl(blockAddrs.first());
                         signer
                             = QStringLiteral("<a href=\"mailto:%1\">%2</a>").arg(QLatin1String(QUrl
                                                                                                ::
                                                                                                toPercentEncoding(
                                                                                                    address
                                                                                                    .
                                                                                                    path())),
                                                                                  signer);
                     }
                 }
             }
         } else {
             if (metaData.signer.isEmpty() || metaData.technicalProblem) {
                 mClass = QStringLiteral("signWarn");
             } else {
                 // HTMLize the signer's user id and create mailto: link
                 signer = MessageCore::StringUtil::quoteHtmlChars(signer, true);
                 signer = QStringLiteral("<a href=\"mailto:%1\">%1</a>").arg(signer);
 
                 if (metaData.isGoodSignature) {
                     if (metaData.keyTrust < GpgME::Signature::Marginal) {
                         mClass = QStringLiteral("signOkKeyBad");
                     } else {
                         mClass = QStringLiteral("signOkKeyOk");
                     }
                 } else {
                     mClass = QStringLiteral("signErr");
                 }
             }
         }
     }
 
     block.setProperty("onlyShowKeyURL", onlyShowKeyURL);
     block.setProperty("showKeyInfos", showKeyInfos);
     block.setProperty("cannotCheckSignature", cannotCheckSignature);
     block.setProperty("signer", signer);
     block.setProperty("statusStr", statusStr);
     block.setProperty("signClass", mClass);
     block.setProperty("greenCaseWarning", greenCaseWarning);
 
     Grantlee::OutputStream s(htmlWriter->stream());
     t->render(&s, &c);
 }
 
 void DefaultRendererPrivate::render(const SignedMessagePart::Ptr &mp, HtmlWriter *htmlWriter)
 {
     const auto metaData = *mp->partMetaData();
     if (metaData.isSigned || metaData.inProgress) {
         HTMLBlock::Ptr aBlock;
         if (mp->isAttachment()) {
             aBlock = HTMLBlock::Ptr(new AttachmentMarkBlock(htmlWriter, mp->attachmentContent()));
         }
         renderSigned(mp, htmlWriter);
         return;
     }
 
     HTMLBlock::Ptr aBlock;
     if (mp->isAttachment()) {
         aBlock = HTMLBlock::Ptr(new AttachmentMarkBlock(htmlWriter, mp->attachmentContent()));
     }
     if (mp->hasSubParts()) {
         renderSubParts(mp, htmlWriter);
     } else if (!metaData.inProgress) {
         renderWithFactory(QStringLiteral("MimeTreeParser::MessagePart"), mp, htmlWriter);
     }
 }
 
 void DefaultRendererPrivate::render(const EncryptedMessagePart::Ptr &mp, HtmlWriter *htmlWriter)
 {
     const auto metaData = *mp->partMetaData();
 
     if (metaData.isEncrypted || metaData.inProgress) {
         HTMLBlock::Ptr aBlock;
         if (mp->isAttachment()) {
             aBlock = HTMLBlock::Ptr(new AttachmentMarkBlock(htmlWriter, mp->attachmentContent()));
         }
         renderEncrypted(mp, htmlWriter);
         return;
     }
 
     HTMLBlock::Ptr aBlock;
     if (mp->isAttachment()) {
         aBlock = HTMLBlock::Ptr(new AttachmentMarkBlock(htmlWriter, mp->attachmentContent()));
     }
 
     if (mp->hasSubParts()) {
         renderSubParts(mp, htmlWriter);
     } else if (!metaData.inProgress) {
         renderWithFactory(QStringLiteral("MimeTreeParser::MessagePart"), mp, htmlWriter);
     }
 }
 
 void DefaultRendererPrivate::render(const AlternativeMessagePart::Ptr &mp, HtmlWriter *htmlWriter)
 {
     HTMLBlock::Ptr aBlock;
     if (mp->isAttachment()) {
         aBlock = HTMLBlock::Ptr(new AttachmentMarkBlock(htmlWriter, mp->attachmentContent()));
     }
 
     auto mode = mp->preferredMode();
     if (mode == MimeTreeParser::Util::MultipartPlain && mp->text().trimmed().isEmpty()) {
         foreach (const auto m, mp->availableModes()) {
             if (m != MimeTreeParser::Util::MultipartPlain) {
                 mode = m;
                 break;
             }
         }
     }
     MimeMessagePart::Ptr part(mp->mChildParts.first());
     if (mp->mChildParts.contains(mode)) {
         part = mp->mChildParts[mode];
     }
 
     render(part, htmlWriter);
 }
 
 void DefaultRendererPrivate::render(const CertMessagePart::Ptr &mp, HtmlWriter *htmlWriter)
 {
     const GpgME::ImportResult &importResult(mp->mImportResult);
     Grantlee::Template t = MessageViewer::MessagePartRendererManager::self()->loadByName(QStringLiteral(
                                                                                              ":/certmessagepart.html"));
     Grantlee::Context c = MessageViewer::MessagePartRendererManager::self()->createContext();
     QObject block;
 
     c.insert(QStringLiteral("block"), &block);
     block.setProperty("importError", QString::fromLocal8Bit(importResult.error().asString()));
     block.setProperty("nImp", importResult.numImported());
     block.setProperty("nUnc", importResult.numUnchanged());
     block.setProperty("nSKImp", importResult.numSecretKeysImported());
     block.setProperty("nSKUnc", importResult.numSecretKeysUnchanged());
 
     QVariantList keylist;
     const auto imports = importResult.imports();
 
     auto end(imports.end());
     for (auto it = imports.begin(); it != end; ++it) {
         QObject *key(new QObject(mp.data()));
         key->setProperty("error", QString::fromLocal8Bit((*it).error().asString()));
         key->setProperty("status", (*it).status());
         key->setProperty("fingerprint", QLatin1String((*it).fingerprint()));
         keylist << QVariant::fromValue(key);
     }
 
     HTMLBlock::Ptr aBlock;
     if (mp->isAttachment()) {
         aBlock = HTMLBlock::Ptr(new AttachmentMarkBlock(htmlWriter, mp->attachmentContent()));
     }
     Grantlee::OutputStream s(htmlWriter->stream());
     t->render(&s, &c);
 }
 
 bool DefaultRendererPrivate::renderWithFactory(const QString &className, const MessagePart::Ptr &msgPart, HtmlWriter *htmlWriter)
 {
     if (!mRendererFactory) {
         return false;
     }
     for (auto r : mRendererFactory->typeRegistry(className)) {
         if (r->render(msgPart, htmlWriter, this)) {
             return true;
         }
     }
     return false;
 }
 
 void DefaultRendererPrivate::renderFactory(const MessagePart::Ptr &msgPart, HtmlWriter *htmlWriter)
 {
     const QString className = QString::fromUtf8(msgPart->metaObject()->className());
 
     if (renderWithFactory(className, msgPart, htmlWriter)) {
         return;
     }
 
     if (className == QStringLiteral("MimeTreeParser::MessagePartList")) {
         auto mp = msgPart.dynamicCast<MessagePartList>();
         if (mp) {
             render(mp, htmlWriter);
         }
     } else if (className == QStringLiteral("MimeTreeParser::MimeMessagePart")) {
         auto mp = msgPart.dynamicCast<MimeMessagePart>();
         if (mp) {
             render(mp, htmlWriter);
         }
     } else if (className == QStringLiteral("MimeTreeParser::EncapsulatedRfc822MessagePart")) {
         auto mp = msgPart.dynamicCast<EncapsulatedRfc822MessagePart>();
         if (mp) {
             render(mp, htmlWriter);
         }
     } else if (className == QStringLiteral("MimeTreeParser::HtmlMessagePart")) {
         auto mp = msgPart.dynamicCast<HtmlMessagePart>();
         if (mp) {
             render(mp, htmlWriter);
         }
     } else if (className == QStringLiteral("MimeTreeParser::SignedMessagePart")) {
         auto mp = msgPart.dynamicCast<SignedMessagePart>();
         if (mp) {
             render(mp, htmlWriter);
         }
     } else if (className == QStringLiteral("MimeTreeParser::EncryptedMessagePart")) {
         auto mp = msgPart.dynamicCast<EncryptedMessagePart>();
         if (mp) {
             render(mp, htmlWriter);
         }
     } else if (className == QStringLiteral("MimeTreeParser::AlternativeMessagePart")) {
         auto mp = msgPart.dynamicCast<AlternativeMessagePart>();
         if (mp) {
             render(mp, htmlWriter);
         }
     } else if (className == QStringLiteral("MimeTreeParser::CertMessagePart")) {
         auto mp = msgPart.dynamicCast<CertMessagePart>();
         if (mp) {
             render(mp, htmlWriter);
         }
     } else if (auto mp = msgPart.dynamicCast<LegacyPluginMessagePart>()) {
         htmlWriter->write(mp->formatOutput());
     } else {
         qCWarning(MESSAGEVIEWER_LOG) << "We got a unkonwn classname, using default behaviour for "
                                      << className;
     }
 }
 
 DefaultRenderer::DefaultRenderer(const MimeTreeParser::MessagePart::Ptr &msgPart, CSSHelperBase *cssHelper, MimeTreeParser::HtmlWriter *writer)
     : d(new MimeTreeParser::DefaultRendererPrivate(msgPart, cssHelper, writer, MessagePartRendererFactory::instance()))
 {
 }
 
 DefaultRenderer::~DefaultRenderer()
 {
     delete d;
 }
diff --git a/messageviewer/src/messagepartthemes/default/plugins/attachmentmessagepartrenderer.cpp b/messageviewer/src/messagepartthemes/default/plugins/attachmentmessagepartrenderer.cpp
index 775f9e33..b9ca39f0 100644
--- a/messageviewer/src/messagepartthemes/default/plugins/attachmentmessagepartrenderer.cpp
+++ b/messageviewer/src/messagepartthemes/default/plugins/attachmentmessagepartrenderer.cpp
@@ -1,87 +1,85 @@
 /*
    Copyright (c) 2016 Sandro Knauß <sknauss@kde.org>
 
    This library is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public License as published by
    the Free Software Foundation; either version 2 of the License, or (at your
    option) any later version.
 
    This library is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
    License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
 */
 
 #include "attachmentmessagepartrenderer.h"
 
 #include "quotehtml.h"
 
 #include "utils/mimetype.h"
 #include "../defaultrenderer_p.h"
 #include "../messagepartrenderermanager.h"
 
 #include <MessageCore/StringUtil>
 #include <MimeTreeParser/HtmlWriter>
 
 #include <KIconLoader>
 #include <KLocalizedString>
 #include <QUrl>
 
 using namespace MessageViewer;
 
 AttachmentMessagePartRenderer::AttachmentMessagePartRenderer()
 {
 }
 
 AttachmentMessagePartRenderer::~AttachmentMessagePartRenderer()
 {
 }
 
 bool AttachmentMessagePartRenderer::render(const MimeTreeParser::MessagePartPtr &msgPart, MimeTreeParser::HtmlWriter *htmlWriter, RenderContext *context) const
 {
     auto mp = msgPart.dynamicCast<AttachmentMessagePart>();
     if (!mp) {
         return false;
     }
 
     KMime::Content *node = mp->content();
-    NodeHelper *nodeHelper = mp->mOtp->nodeHelper();
-
     if (mp->isHidden()) {
         return true;
     }
 
     const auto tmpAsIcon = mp->asIcon();
 
     if (tmpAsIcon == MimeTreeParser::NoIcon) {
         return context->renderWithFactory(QStringLiteral("MimeTreeParser::TextMessagePart"), mp, htmlWriter);
     }
 
     Grantlee::Template t = MessageViewer::MessagePartRendererManager::self()->loadByName(QStringLiteral(
                                                                                              ":/asiconpart.html"));
     Grantlee::Context c = MessageViewer::MessagePartRendererManager::self()->createContext();
     c.insert(QStringLiteral("block"), msgPart.data());
 
     msgPart->setProperty("inline", (tmpAsIcon == MimeTreeParser::IconInline));
 
     QString iconPath;
     if (tmpAsIcon == MimeTreeParser::IconInline) {
-        iconPath = nodeHelper->writeNodeToTempFile(node);
+        iconPath = mp->temporaryFilePath();
     } else {
         iconPath = MessageViewer::Util::iconPathForContent(node, KIconLoader::Desktop);
         if (iconPath.right(14) == QLatin1String("mime_empty.png")) {
-            nodeHelper->magicSetType(node);
+            NodeHelper::magicSetType(node);
             iconPath = MessageViewer::Util::iconPathForContent(node, KIconLoader::Desktop);
         }
     }
     msgPart->setProperty("iconPath", QUrl::fromLocalFile(iconPath).url());
 
     Grantlee::OutputStream s(htmlWriter->stream());
     t->render(&s, &c);
     return true;
 }
diff --git a/mimetreeparser/src/bodyformatter/textplain.cpp b/mimetreeparser/src/bodyformatter/textplain.cpp
index 2cf451d3..a8cd3c2c 100644
--- a/mimetreeparser/src/bodyformatter/textplain.cpp
+++ b/mimetreeparser/src/bodyformatter/textplain.cpp
@@ -1,67 +1,66 @@
 /*
    Copyright (c) 2016 Sandro Knauß <sknauss@kde.org>
 
    This library is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public License as published by
    the Free Software Foundation; either version 2 of the License, or (at your
    option) any later version.
 
    This library is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
    License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
 */
 
 #include "textplain.h"
 
 #include "viewer/attachmentstrategy.h"
 #include "viewer/objecttreeparser.h"
 #include "viewer/messagepart.h"
 
 #include <KMime/Content>
 
 #include "mimetreeparser_debug.h"
 
 using namespace MimeTreeParser;
 
 const TextPlainBodyPartFormatter *TextPlainBodyPartFormatter::self;
 
 const Interface::BodyPartFormatter *TextPlainBodyPartFormatter::create()
 {
     if (!self) {
         self = new TextPlainBodyPartFormatter();
     }
     return self;
 }
 
 MessagePart::Ptr TextPlainBodyPartFormatter::process(Interface::BodyPart &part) const
 {
     KMime::Content *node = part.content();
     const bool isFirstTextPart = (node->topLevel()->textContent() == node);
 
     QString label = NodeHelper::fileName(node);
 
     const bool bDrawFrame = !isFirstTextPart
                             && !part.objectTreeParser()->showOnlyOneMimePart()
                             && !label.isEmpty();
-    const QString fileName = part.nodeHelper()->writeNodeToTempFile(node);
 
     TextMessagePart::Ptr mp;
     if (isFirstTextPart) {
-        mp = TextMessagePart::Ptr(new TextMessagePart(part.objectTreeParser(), node, bDrawFrame, !fileName.isEmpty(), part.source()->decryptMessage()));
+        mp = TextMessagePart::Ptr(new TextMessagePart(part.objectTreeParser(), node, bDrawFrame, part.source()->decryptMessage()));
     } else {
-        mp = TextMessagePart::Ptr(new AttachmentMessagePart(part.objectTreeParser(), node, bDrawFrame, !fileName.isEmpty(), part.source()->decryptMessage()));
+        mp = TextMessagePart::Ptr(new AttachmentMessagePart(part.objectTreeParser(), node, bDrawFrame, part.source()->decryptMessage()));
     }
 
     part.processResult()->setInlineSignatureState(mp->signatureState());
     part.processResult()->setInlineEncryptionState(mp->encryptionState());
 
     part.nodeHelper()->setNodeDisplayedEmbedded(node, true);
 
     return mp;
 }
diff --git a/mimetreeparser/src/viewer/bodypartformatter.cpp b/mimetreeparser/src/viewer/bodypartformatter.cpp
index a3128805..fb4debf5 100644
--- a/mimetreeparser/src/viewer/bodypartformatter.cpp
+++ b/mimetreeparser/src/viewer/bodypartformatter.cpp
@@ -1,187 +1,187 @@
 /*  -*- c++ -*-
     bodypartformatter.cpp
 
     This file is part of KMail, the KDE mail client.
     Copyright (c) 2003 Marc Mutz <mutz@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
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #include "mimetreeparser_debug.h"
 
 #include "bodyformatter/applicationpgpencrypted.h"
 #include "bodyformatter/applicationpkcs7mime.h"
 #include "bodyformatter/mailman.h"
 #include "bodyformatter/multipartalternative.h"
 #include "bodyformatter/multipartmixed.h"
 #include "bodyformatter/multipartencrypted.h"
 #include "bodyformatter/multipartsigned.h"
 #include "bodyformatter/texthtml.h"
 #include "bodyformatter/textplain.h"
 
 #include "interfaces/bodypartformatter.h"
 #include "interfaces/bodypart.h"
 #include "interfaces/htmlwriter.h"
 
 #include "viewer/bodypartformatterbasefactory.h"
 #include "viewer/bodypartformatterbasefactory_p.h"
 
 #include "viewer/attachmentstrategy.h"
 #include "viewer/objecttreeparser.h"
 #include "viewer/messagepart.h"
 
 #include <KMime/Content>
 
 #include <QUrl>
 
 using namespace MimeTreeParser;
 
 namespace {
 class AnyTypeBodyPartFormatter : public MimeTreeParser::Interface::BodyPartFormatter
 {
     static const AnyTypeBodyPartFormatter *self;
 public:
     MessagePart::Ptr process(Interface::BodyPart &part) const override
     {
         KMime::Content *node = part.content();
-        const auto mp = AttachmentMessagePart::Ptr(new AttachmentMessagePart(part.objectTreeParser(), node, false, true, part.source()->decryptMessage()));
+        const auto mp = AttachmentMessagePart::Ptr(new AttachmentMessagePart(part.objectTreeParser(), node, false, part.source()->decryptMessage()));
         part.processResult()->setInlineSignatureState(mp->signatureState());
         part.processResult()->setInlineEncryptionState(mp->encryptionState());
         part.processResult()->setNeverDisplayInline(true);
         mp->setNeverDisplayInline(true);
         mp->setIsImage(false);
         return mp;
     }
 
     static const MimeTreeParser::Interface::BodyPartFormatter *create()
     {
         if (!self) {
             self = new AnyTypeBodyPartFormatter();
         }
         return self;
     }
 };
 
 const AnyTypeBodyPartFormatter *AnyTypeBodyPartFormatter::self = nullptr;
 
 class ImageTypeBodyPartFormatter : public MimeTreeParser::Interface::BodyPartFormatter
 {
     static const ImageTypeBodyPartFormatter *self;
 public:
     static const MimeTreeParser::Interface::BodyPartFormatter *create()
     {
         if (!self) {
             self = new ImageTypeBodyPartFormatter();
         }
         return self;
     }
 
     MessagePart::Ptr process(Interface::BodyPart &part) const override
     {
         KMime::Content *node = part.content();
-        auto mp = AttachmentMessagePart::Ptr(new AttachmentMessagePart(part.objectTreeParser(), node, false, true, part.source()->decryptMessage()));
+        auto mp = AttachmentMessagePart::Ptr(new AttachmentMessagePart(part.objectTreeParser(), node, false, part.source()->decryptMessage()));
         mp->setIsImage(true);
         part.processResult()->setInlineSignatureState(mp->signatureState());
         part.processResult()->setInlineEncryptionState(mp->encryptionState());
 
         auto preferredMode = part.source()->preferredMode();
         bool isHtmlPreferred = (preferredMode == Util::Html) || (preferredMode == Util::MultipartHtml);
         if (node->parent() && node->parent()->contentType()->subType() == "related" && isHtmlPreferred && !part.objectTreeParser()->showOnlyOneMimePart()) {
-            QString fileName = part.nodeHelper()->writeNodeToTempFile(node);
+            QString fileName = mp->temporaryFilePath();
             QString href = QUrl::fromLocalFile(fileName).url();
             QByteArray cid = node->contentID()->identifier();
             if (part.objectTreeParser()->htmlWriter()) {
                 part.objectTreeParser()->htmlWriter()->embedPart(cid, href);
             }
             part.nodeHelper()->setNodeDisplayedEmbedded(node, true);
             part.nodeHelper()->setNodeDisplayedHidden(node, true);
             return mp;
         }
 
         // Show it inline if showOnlyOneMimePart(), which means the user clicked the image
         // in the message structure viewer manually, and therefore wants to see the full image
         if (part.objectTreeParser()->showOnlyOneMimePart() && !part.processResult()->neverDisplayInline()) {
             part.nodeHelper()->setNodeDisplayedEmbedded(node, true);
         }
 
         return mp;
     }
 };
 
 const ImageTypeBodyPartFormatter *ImageTypeBodyPartFormatter::self = nullptr;
 
 class MessageRfc822BodyPartFormatter : public MimeTreeParser::Interface::BodyPartFormatter
 {
     static const MessageRfc822BodyPartFormatter *self;
 public:
     MessagePart::Ptr process(Interface::BodyPart &) const override;
     static const MimeTreeParser::Interface::BodyPartFormatter *create();
 };
 
 const MessageRfc822BodyPartFormatter *MessageRfc822BodyPartFormatter::self;
 
 const MimeTreeParser::Interface::BodyPartFormatter *MessageRfc822BodyPartFormatter::create()
 {
     if (!self) {
         self = new MessageRfc822BodyPartFormatter();
     }
     return self;
 }
 
 MessagePart::Ptr MessageRfc822BodyPartFormatter::process(Interface::BodyPart &part) const
 {
     const KMime::Message::Ptr message = part.content()->bodyAsMessage();
     return MessagePart::Ptr(new EncapsulatedRfc822MessagePart(part.objectTreeParser(), part.content(), message));
 }
 } // anon namespace
 
 void BodyPartFormatterBaseFactoryPrivate::messageviewer_create_builtin_bodypart_formatters()
 {
     insert(QStringLiteral("application/pkcs7-mime"), ApplicationPkcs7MimeBodyPartFormatter::create());
     insert(QStringLiteral("application/x-pkcs7-mime"), ApplicationPkcs7MimeBodyPartFormatter::create());
     insert(QStringLiteral("application/pgp-encrypted"), ApplicationPGPEncryptedBodyPartFormatter::create());
 
     insert(QStringLiteral("application/octet-stream"), ApplicationPkcs7MimeBodyPartFormatter::create());
     insert(QStringLiteral("application/octet-stream"), AnyTypeBodyPartFormatter::create());
 
     insert(QStringLiteral("text/html"), TextHtmlBodyPartFormatter::create());
     insert(QStringLiteral("text/rtf"), AnyTypeBodyPartFormatter::create());
     insert(QStringLiteral("text/plain"), MailmanBodyPartFormatter::create());
     insert(QStringLiteral("text/plain"), TextPlainBodyPartFormatter::create());
 
     insert(QStringLiteral("image/png"), ImageTypeBodyPartFormatter::create());
     insert(QStringLiteral("image/jpeg"), ImageTypeBodyPartFormatter::create());
     insert(QStringLiteral("image/gif"), ImageTypeBodyPartFormatter::create());
     insert(QStringLiteral("image/svg+xml"), ImageTypeBodyPartFormatter::create());
     insert(QStringLiteral("image/bmp"), ImageTypeBodyPartFormatter::create());
     insert(QStringLiteral("image/vnd.microsoft.icon"), ImageTypeBodyPartFormatter::create());
 
     insert(QStringLiteral("message/rfc822"), MessageRfc822BodyPartFormatter::create());
 
     insert(QStringLiteral("multipart/alternative"), MultiPartAlternativeBodyPartFormatter::create());
     insert(QStringLiteral("multipart/encrypted"), MultiPartEncryptedBodyPartFormatter::create());
     insert(QStringLiteral("multipart/signed"), MultiPartSignedBodyPartFormatter::create());
     insert(QStringLiteral("multipart/mixed"), MultiPartMixedBodyPartFormatter::create());
 }
diff --git a/mimetreeparser/src/viewer/messagepart.cpp b/mimetreeparser/src/viewer/messagepart.cpp
index 6387ee72..cd08b94b 100644
--- a/mimetreeparser/src/viewer/messagepart.cpp
+++ b/mimetreeparser/src/viewer/messagepart.cpp
@@ -1,1374 +1,1389 @@
 /*
    Copyright (c) 2015 Sandro Knauß <sknauss@kde.org>
 
    This library is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public License as published by
    the Free Software Foundation; either version 2 of the License, or (at your
    option) any later version.
 
    This library is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
    License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
 */
 
 #include "messagepart.h"
 #include "mimetreeparser_debug.h"
 #include "attachmentstrategy.h"
 #include "cryptohelper.h"
 #include "objecttreeparser.h"
 #include "htmlwriter/bufferedhtmlwriter.h"
 #include "job/qgpgmejobexecutor.h"
 #include "memento/cryptobodypartmemento.h"
 #include "memento/decryptverifybodypartmemento.h"
 #include "memento/verifydetachedbodypartmemento.h"
 #include "memento/verifyopaquebodypartmemento.h"
 
 #include "bodyformatter/utils.h"
 
 #include <KMime/Content>
 
 #include <QGpgME/DN>
 #include <QGpgME/Protocol>
 #include <QGpgME/ImportJob>
 #include <QGpgME/KeyListJob>
 #include <QGpgME/VerifyDetachedJob>
 #include <QGpgME/VerifyOpaqueJob>
 
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 #include <gpgme.h>
 
 #include <KLocalizedString>
 
 #include <QTextCodec>
 
 using namespace MimeTreeParser;
 
 //------MessagePart-----------------------
 namespace MimeTreeParser {
 class MessagePartPrivate
 {
 public:
     MessagePart *mParentPart = nullptr;
     QVector<MessagePart::Ptr> mBlocks;
     KMime::Content *mNode = nullptr;
     KMime::Content *mAttachmentNode = nullptr;
     QString mText;
     PartMetaData mMetaData;
     bool mRoot = false;
 };
 }
 
 MessagePart::MessagePart(ObjectTreeParser *otp, const QString &text)
     : mOtp(otp)
     , d(new MessagePartPrivate)
 {
     d->mText = text;
 }
 
 MessagePart::~MessagePart() = default;
 
 MessagePart *MessagePart::parentPart() const
 {
     return d->mParentPart;
 }
 
 void MessagePart::setParentPart(MessagePart *parentPart)
 {
     d->mParentPart = parentPart;
 }
 
 QString MessagePart::htmlContent() const
 {
     return text();
 }
 
 QString MessagePart::plaintextContent() const
 {
     return text();
 }
 
 PartMetaData *MessagePart::partMetaData() const
 {
     return &d->mMetaData;
 }
 
 KMime::Content *MessagePart::content() const
 {
     return d->mNode;
 }
 
 void MessagePart::setContent(KMime::Content *node)
 {
     d->mNode = node;
 }
 
 KMime::Content *MessagePart::attachmentContent() const
 {
     return d->mAttachmentNode;
 }
 
 void MessagePart::setAttachmentContent(KMime::Content *node)
 {
     d->mAttachmentNode = node;
 }
 
 bool MessagePart::isAttachment() const
 {
     return d->mAttachmentNode;
 }
 
 QString MessagePart::attachmentIndex() const
 {
     return attachmentContent()->index().toString();
 }
 
 QString MessagePart::attachmentLink() const
 {
     return mOtp->nodeHelper()->asHREF(content(), QStringLiteral("body"));
 }
 
 void MessagePart::setIsRoot(bool root)
 {
     d->mRoot = root;
 }
 
 bool MessagePart::isRoot() const
 {
     return d->mRoot;
 }
 
 QString MessagePart::text() const
 {
     return d->mText;
 }
 
 void MessagePart::setText(const QString &text)
 {
     d->mText = text;
 }
 
 bool MessagePart::isHtml() const
 {
     return false;
 }
 
 bool MessagePart::isHidden() const
 {
     return false;
 }
 
 Interface::ObjectTreeSource *MessagePart::source() const
 {
     Q_ASSERT(mOtp);
     return mOtp->mSource;
 }
 
+NodeHelper* MessagePart::nodeHelper() const
+{
+    Q_ASSERT(mOtp);
+    return mOtp->nodeHelper();
+}
+
 void MessagePart::parseInternal(KMime::Content *node, bool onlyOneMimePart)
 {
     auto subMessagePart = mOtp->parseObjectTreeInternal(node, onlyOneMimePart);
     d->mRoot = subMessagePart->isRoot();
     foreach (const auto &part, subMessagePart->subParts()) {
         appendSubPart(part);
     }
 }
 
 QString MessagePart::renderInternalText() const
 {
     QString text;
     foreach (const auto &mp, subParts()) {
         text += mp->text();
     }
     return text;
 }
 
 void MessagePart::fix() const
 {
     foreach (const auto &mp, subParts()) {
         const auto m = mp.dynamicCast<MessagePart>();
         if (m) {
             m->fix();
         }
     }
 }
 
 void MessagePart::appendSubPart(const MessagePart::Ptr &messagePart)
 {
     messagePart->setParentPart(this);
     d->mBlocks.append(messagePart);
 }
 
 const QVector<MessagePart::Ptr> &MessagePart::subParts() const
 {
     return d->mBlocks;
 }
 
 bool MessagePart::hasSubParts() const
 {
     return !d->mBlocks.isEmpty();
 }
 
 //-----LegacyMessagePart--------------------
 LegacyPluginMessagePart::LegacyPluginMessagePart(ObjectTreeParser *otp)
     : MessagePart(otp, QString())
     , m_htmlWriter(new BufferedHtmlWriter)
 {
     m_htmlWriter->begin();
 }
 
 LegacyPluginMessagePart::~LegacyPluginMessagePart()
 {
 }
 
 HtmlWriter *LegacyPluginMessagePart::htmlWriter() const
 {
     return m_htmlWriter.get();
 }
 
 QString LegacyPluginMessagePart::formatOutput() const
 {
     m_htmlWriter->end();
     return QString::fromUtf8(static_cast<BufferedHtmlWriter *>(m_htmlWriter.get())->data());
 }
 
 //-----MessagePartList----------------------
 MessagePartList::MessagePartList(ObjectTreeParser *otp)
     : MessagePart(otp, QString())
 {
 }
 
 MessagePartList::~MessagePartList()
 {
 }
 
 QString MessagePartList::text() const
 {
     return renderInternalText();
 }
 
 QString MessagePartList::plaintextContent() const
 {
     return QString();
 }
 
 QString MessagePartList::htmlContent() const
 {
     return QString();
 }
 
 //-----TextMessageBlock----------------------
 
-TextMessagePart::TextMessagePart(ObjectTreeParser *otp, KMime::Content *node, bool drawFrame, bool showLink, bool decryptMessage)
+TextMessagePart::TextMessagePart(ObjectTreeParser *otp, KMime::Content *node, bool drawFrame, bool decryptMessage)
     : MessagePartList(otp)
     , mDrawFrame(drawFrame)
-    , mShowLink(showLink)
     , mDecryptMessage(decryptMessage)
     , mIsHidden(false)
 {
     if (!node) {
         qCWarning(MIMETREEPARSER_LOG) << "not a valid node";
         return;
     }
 
     setContent(node);
     mIsHidden = mOtp->nodeHelper()->isNodeDisplayedHidden(node);
 
     parseContent();
 }
 
 TextMessagePart::~TextMessagePart()
 {
 }
 
 bool TextMessagePart::decryptMessage() const
 {
     return mDecryptMessage;
 }
 
 void TextMessagePart::parseContent()
 {
     const auto aCodec = mOtp->codecFor(content());
     const QString &fromAddress = mOtp->nodeHelper()->fromAsString(content());
     mSignatureState = KMMsgNotSigned;
     mEncryptionState = KMMsgNotEncrypted;
     const auto blocks = prepareMessageForDecryption(content()->decodedContent());
 
     const auto cryptProto = QGpgME::openpgp();
 
     if (!blocks.isEmpty()) {
         /* The (overall) signature/encrypted status is broken
          * if one unencrypted part is at the beginning or in the middle
          * because mailmain adds an unencrypted part at the end this should not break the overall status
          *
          * That's why we first set the tmp status and if one crypted/signed block comes afterwards, than
          * the status is set to unencryped
          */
         bool fullySignedOrEncrypted = true;
         bool fullySignedOrEncryptedTmp = true;
 
         for (const auto &block : blocks) {
             if (!fullySignedOrEncryptedTmp) {
                 fullySignedOrEncrypted = false;
             }
 
             if (block.type() == NoPgpBlock && !block.text().trimmed().isEmpty()) {
                 fullySignedOrEncryptedTmp = false;
                 appendSubPart(MessagePart::Ptr(new MessagePart(mOtp, aCodec->toUnicode(block.text()))));
             } else if (block.type() == PgpMessageBlock) {
                 EncryptedMessagePart::Ptr mp(new EncryptedMessagePart(mOtp, QString(), cryptProto, fromAddress, nullptr));
                 mp->setDecryptMessage(decryptMessage());
                 mp->setIsEncrypted(true);
                 appendSubPart(mp);
                 if (!decryptMessage()) {
                     continue;
                 }
                 mp->startDecryption(block.text(), aCodec);
                 if (mp->partMetaData()->inProgress) {
                     continue;
                 }
             } else if (block.type() == ClearsignedBlock) {
                 SignedMessagePart::Ptr mp(new SignedMessagePart(mOtp, QString(), cryptProto, fromAddress, nullptr));
                 appendSubPart(mp);
                 mp->startVerification(block.text(), aCodec);
             } else {
                 continue;
             }
 
             const auto mp = subParts().last().staticCast<MessagePart>();
             const PartMetaData *messagePart(mp->partMetaData());
 
             if (!messagePart->isEncrypted && !messagePart->isSigned && !block.text().trimmed().isEmpty()) {
                 mp->setText(aCodec->toUnicode(block.text()));
             }
 
             if (messagePart->isEncrypted) {
                 mEncryptionState = KMMsgPartiallyEncrypted;
             }
 
             if (messagePart->isSigned) {
                 mSignatureState = KMMsgPartiallySigned;
             }
         }
 
         //Do we have an fully Signed/Encrypted Message?
         if (fullySignedOrEncrypted) {
             if (mSignatureState == KMMsgPartiallySigned) {
                 mSignatureState = KMMsgFullySigned;
             }
             if (mEncryptionState == KMMsgPartiallyEncrypted) {
                 mEncryptionState = KMMsgFullyEncrypted;
             }
         }
     }
 }
 
 KMMsgEncryptionState TextMessagePart::encryptionState() const
 {
     return mEncryptionState;
 }
 
 KMMsgSignatureState TextMessagePart::signatureState() const
 {
     return mSignatureState;
 }
 
 bool TextMessagePart::isHidden() const
 {
     return mIsHidden;
 }
 
 bool TextMessagePart::showLink() const
 {
-    return mShowLink;
+    return !temporaryFilePath().isEmpty();
 }
 
 bool TextMessagePart::showTextFrame() const
 {
     return mDrawFrame;
 }
 
+void TextMessagePart::setShowTextFrame(bool showFrame)
+{
+    mDrawFrame = showFrame;
+}
+
 QString TextMessagePart::label() const
 {
     const QString name = content()->contentType()->name();
     QString label = name.isEmpty() ? NodeHelper::fileName(content()) : name;
     if (label.isEmpty()) {
         label = i18nc("display name for an unnamed attachment", "Unnamed");
     }
     return label;
 }
 
 QString TextMessagePart::comment() const
 {
     const QString comment = content()->contentDescription()->asUnicodeString();
     if (comment == label()) {
         return {};
     }
     return comment;
 }
 
+QString TextMessagePart::temporaryFilePath() const
+{
+    return nodeHelper()->writeNodeToTempFile(content());
+}
+
 //-----AttachmentMessageBlock----------------------
 
-AttachmentMessagePart::AttachmentMessagePart(ObjectTreeParser *otp, KMime::Content *node, bool drawFrame, bool showLink, bool decryptMessage)
-    : TextMessagePart(otp, node, drawFrame, showLink, decryptMessage)
+AttachmentMessagePart::AttachmentMessagePart(ObjectTreeParser *otp, KMime::Content *node, bool drawFrame, bool decryptMessage)
+    : TextMessagePart(otp, node, drawFrame, decryptMessage)
     , mIsImage(false)
     , mNeverDisplayInline(false)
 {
 }
 
 AttachmentMessagePart::~AttachmentMessagePart()
 {
 }
 
 bool AttachmentMessagePart::neverDisplayInline() const
 {
     return mNeverDisplayInline;
 }
 
 void AttachmentMessagePart::setNeverDisplayInline(bool displayInline)
 {
     mNeverDisplayInline = displayInline;
 }
 
 bool AttachmentMessagePart::isImage() const
 {
     return mIsImage;
 }
 
 void AttachmentMessagePart::setIsImage(bool image)
 {
     mIsImage = image;
 }
 
 IconType AttachmentMessagePart::asIcon() const
 {
     const AttachmentStrategy *const as = mOtp->attachmentStrategy();
     const bool defaultHidden(as && as->defaultDisplay(content()) == AttachmentStrategy::None);
     const bool showOnlyOneMimePart(mOtp->showOnlyOneMimePart());
     auto preferredMode = source()->preferredMode();
     bool isHtmlPreferred = (preferredMode == Util::Html) || (preferredMode == Util::MultipartHtml);
 
     QByteArray mediaType("text");
     if (content()->contentType(false) && !content()->contentType()->mediaType().isEmpty()
         && !content()->contentType()->subType().isEmpty()) {
         mediaType = content()->contentType()->mediaType();
     }
     const bool isTextPart = (mediaType == QByteArrayLiteral("text"));
 
     bool defaultAsIcon = true;
     if (!neverDisplayInline()) {
         if (as) {
             defaultAsIcon = as->defaultDisplay(content()) == AttachmentStrategy::AsIcon;
         }
     }
     if (isImage() && showOnlyOneMimePart && !neverDisplayInline()) {
         defaultAsIcon = false;
     }
 
     // neither image nor text -> show as icon
     if (!isImage() && !isTextPart) {
         defaultAsIcon = true;
     }
 
     if (isTextPart) {
         if (as && as->defaultDisplay(content()) != AttachmentStrategy::Inline) {
             return MimeTreeParser::IconExternal;
         }
         return MimeTreeParser::NoIcon;
     } else {
         if (isImage() && isHtmlPreferred
             && content()->parent() && content()->parent()->contentType()->subType() == "related") {
             return MimeTreeParser::IconInline;
         }
 
         if (defaultHidden && !showOnlyOneMimePart && content()->parent()) {
             return MimeTreeParser::IconInline;
         }
 
         if (defaultAsIcon) {
             return MimeTreeParser::IconExternal;
         } else if (isImage()) {
             return MimeTreeParser::IconInline;
         } else {
             return MimeTreeParser::NoIcon;
         }
     }
 }
 
 bool AttachmentMessagePart::isHidden() const
 {
     if (mOtp->showOnlyOneMimePart()) {
         return false; // never hide when only showing one part, otherwise you'll see nothing
     }
     const AttachmentStrategy *const as = mOtp->attachmentStrategy();
     const bool defaultHidden(as && as->defaultDisplay(content()) == AttachmentStrategy::None);
     auto preferredMode = source()->preferredMode();
     bool isHtmlPreferred = (preferredMode == Util::Html) || (preferredMode == Util::MultipartHtml);
 
     QByteArray mediaType("text");
     if (content()->contentType(false) && !content()->contentType()->mediaType().isEmpty()
         && !content()->contentType()->subType().isEmpty()) {
         mediaType = content()->contentType()->mediaType();
     }
     const bool isTextPart = (mediaType == QByteArrayLiteral("text"));
 
     bool defaultAsIcon = true;
     if (!neverDisplayInline()) {
         if (as) {
             defaultAsIcon = as->defaultDisplay(content()) == AttachmentStrategy::AsIcon;
         }
     }
 
     // neither image nor text -> show as icon
     if (!isImage() && !isTextPart) {
         defaultAsIcon = true;
     }
 
     bool hidden(false);
     if (isTextPart) {
         hidden = defaultHidden;
     } else {
         if (isImage() && isHtmlPreferred
             && content()->parent() && content()->parent()->contentType()->subType() == "related") {
             hidden = true;
         } else {
             hidden = defaultHidden && content()->parent();
             hidden |= defaultAsIcon && defaultHidden;
         }
     }
     mOtp->nodeHelper()->setNodeDisplayedHidden(content(), hidden);
     return hidden;
 }
 
 //-----HtmlMessageBlock----------------------
 
 HtmlMessagePart::HtmlMessagePart(ObjectTreeParser *otp, KMime::Content *node, Interface::ObjectTreeSource *source)
     : MessagePart(otp, QString())
     , mSource(source)
 {
     if (!node) {
         qCWarning(MIMETREEPARSER_LOG) << "not a valid node";
         return;
     }
     setContent(node);
 
     const QByteArray partBody(node->decodedContent());
     mBodyHTML = mOtp->codecFor(node)->toUnicode(partBody);
     mCharset = NodeHelper::charset(node);
 }
 
 HtmlMessagePart::~HtmlMessagePart()
 {
 }
 
 void HtmlMessagePart::fix() const
 {
     mOtp->mHtmlContent += mBodyHTML;
     mOtp->mHtmlContentCharset = mCharset;
 }
 
 QString HtmlMessagePart::text() const
 {
     return mBodyHTML;
 }
 
 bool HtmlMessagePart::isHtml() const
 {
     return true;
 }
 
 //-----MimeMessageBlock----------------------
 
 MimeMessagePart::MimeMessagePart(ObjectTreeParser *otp, KMime::Content *node, bool onlyOneMimePart)
     : MessagePart(otp, QString())
     , mOnlyOneMimePart(onlyOneMimePart)
 {
     if (!node) {
         qCWarning(MIMETREEPARSER_LOG) << "not a valid node";
         return;
     }
     setContent(node);
 
     parseInternal(node, mOnlyOneMimePart);
 }
 
 MimeMessagePart::~MimeMessagePart()
 {
 }
 
 QString MimeMessagePart::text() const
 {
     return renderInternalText();
 }
 
 QString MimeMessagePart::plaintextContent() const
 {
     return QString();
 }
 
 QString MimeMessagePart::htmlContent() const
 {
     return QString();
 }
 
 //-----AlternativeMessagePart----------------------
 
 AlternativeMessagePart::AlternativeMessagePart(ObjectTreeParser *otp, KMime::Content *node, Util::HtmlMode preferredMode)
     : MessagePart(otp, QString())
     , mPreferredMode(preferredMode)
 {
     setContent(node);
     KMime::Content *dataIcal = findTypeInDirectChilds(node, "text/calendar");
     KMime::Content *dataHtml = findTypeInDirectChilds(node, "text/html");
     KMime::Content *dataText = findTypeInDirectChilds(node, "text/plain");
 
     if (!dataHtml) {
         // If we didn't find the HTML part as the first child of the multipart/alternative, it might
         // be that this is a HTML message with images, and text/plain and multipart/related are the
         // immediate children of this multipart/alternative node.
         // In this case, the HTML node is a child of multipart/related.
         dataHtml = findTypeInDirectChilds(node, "multipart/related");
 
         // Still not found? Stupid apple mail actually puts the attachments inside of the
         // multipart/alternative, which is wrong. Therefore we also have to look for multipart/mixed
         // here.
         // Do this only when prefering HTML mail, though, since otherwise the attachments are hidden
         // when displaying plain text.
         if (!dataHtml) {
             dataHtml = findTypeInDirectChilds(node, "multipart/mixed");
         }
     }
 
     if (dataIcal) {
         mChildNodes[Util::MultipartIcal] = dataIcal;
     }
 
     if (dataText) {
         mChildNodes[Util::MultipartPlain] = dataText;
     }
 
     if (dataHtml) {
         mChildNodes[Util::MultipartHtml] = dataHtml;
     }
 
     if (mChildNodes.isEmpty()) {
         qCWarning(MIMETREEPARSER_LOG) << "no valid nodes";
         return;
     }
 
     QMapIterator<Util::HtmlMode, KMime::Content *> i(mChildNodes);
     while (i.hasNext()) {
         i.next();
         mChildParts[i.key()] = MimeMessagePart::Ptr(new MimeMessagePart(mOtp, i.value(), true));
     }
 }
 
 AlternativeMessagePart::~AlternativeMessagePart()
 {
 }
 
 Util::HtmlMode AlternativeMessagePart::preferredMode() const
 {
     return mPreferredMode;
 }
 
 QList<Util::HtmlMode> AlternativeMessagePart::availableModes()
 {
     return mChildParts.keys();
 }
 
 QString AlternativeMessagePart::text() const
 {
     if (mChildParts.contains(Util::MultipartPlain)) {
         return mChildParts[Util::MultipartPlain]->text();
     }
     return QString();
 }
 
 void AlternativeMessagePart::fix() const
 {
     if (mChildParts.contains(Util::MultipartPlain)) {
         mChildParts[Util::MultipartPlain]->fix();
     }
 
     const auto mode = preferredMode();
     if (mode != Util::MultipartPlain && mChildParts.contains(mode)) {
         mChildParts[mode]->fix();
     }
 }
 
 bool AlternativeMessagePart::isHtml() const
 {
     return mChildParts.contains(Util::MultipartHtml);
 }
 
 QString AlternativeMessagePart::plaintextContent() const
 {
     return text();
 }
 
 QString AlternativeMessagePart::htmlContent() const
 {
     if (mChildParts.contains(Util::MultipartHtml)) {
         return mChildParts[Util::MultipartHtml]->text();
     } else {
         return plaintextContent();
     }
 }
 
 //-----CertMessageBlock----------------------
 
 CertMessagePart::CertMessagePart(ObjectTreeParser *otp, KMime::Content *node, const QGpgME::Protocol *cryptoProto, bool autoImport)
     : MessagePart(otp, QString())
     , mAutoImport(autoImport)
     , mCryptoProto(cryptoProto)
 {
     if (!node) {
         qCWarning(MIMETREEPARSER_LOG) << "not a valid node";
         return;
     }
     setContent(node);
 
     if (!mAutoImport) {
         return;
     }
 
     const QByteArray certData = node->decodedContent();
 
     QGpgME::ImportJob *import = mCryptoProto->importJob();
     QGpgMEJobExecutor executor;
     mImportResult = executor.exec(import, certData);
 }
 
 CertMessagePart::~CertMessagePart()
 {
 }
 
 QString CertMessagePart::text() const
 {
     return QString();
 }
 
 //-----SignedMessageBlock---------------------
 SignedMessagePart::SignedMessagePart(ObjectTreeParser *otp, const QString &text, const QGpgME::Protocol *cryptoProto, const QString &fromAddress, KMime::Content *node)
     : MessagePart(otp, text)
     , mCryptoProto(cryptoProto)
     , mFromAddress(fromAddress)
 {
     setContent(node);
     partMetaData()->technicalProblem = (mCryptoProto == nullptr);
     partMetaData()->isSigned = true;
     partMetaData()->isGoodSignature = false;
     partMetaData()->keyTrust = GpgME::Signature::Unknown;
     partMetaData()->status = i18n("Wrong Crypto Plug-In.");
     partMetaData()->status_code = GPGME_SIG_STAT_NONE;
 }
 
 SignedMessagePart::~SignedMessagePart()
 {
 }
 
 void SignedMessagePart::setIsSigned(bool isSigned)
 {
     partMetaData()->isSigned = isSigned;
 }
 
 bool SignedMessagePart::isSigned() const
 {
     return partMetaData()->isSigned;
 }
 
 bool SignedMessagePart::okVerify(const QByteArray &data, const QByteArray &signature, KMime::Content *textNode)
 {
     NodeHelper *nodeHelper = mOtp->nodeHelper();
 
     partMetaData()->isSigned = false;
     partMetaData()->technicalProblem = (mCryptoProto == nullptr);
     partMetaData()->keyTrust = GpgME::Signature::Unknown;
     partMetaData()->status = i18n("Wrong Crypto Plug-In.");
     partMetaData()->status_code = GPGME_SIG_STAT_NONE;
 
     const QByteArray mementoName = "verification";
 
     CryptoBodyPartMemento *m = dynamic_cast<CryptoBodyPartMemento *>(nodeHelper->bodyPartMemento(content(), mementoName));
     Q_ASSERT(!m || mCryptoProto); //No CryptoPlugin and having a bodyPartMemento -> there is something completely wrong
 
     if (!m && mCryptoProto) {
         if (!signature.isEmpty()) {
             QGpgME::VerifyDetachedJob *job = mCryptoProto->verifyDetachedJob();
             if (job) {
                 m = new VerifyDetachedBodyPartMemento(job, mCryptoProto->keyListJob(), signature, data);
             }
         } else {
             QGpgME::VerifyOpaqueJob *job = mCryptoProto->verifyOpaqueJob();
             if (job) {
                 m = new VerifyOpaqueBodyPartMemento(job, mCryptoProto->keyListJob(), data);
             }
         }
         if (m) {
             if (mOtp->allowAsync()) {
                 QObject::connect(m, &CryptoBodyPartMemento::update,
                                  nodeHelper, &NodeHelper::update);
                 if (m->start()) {
                     partMetaData()->inProgress = true;
                     mOtp->mHasPendingAsyncJobs = true;
                 }
             } else {
                 m->exec();
             }
             nodeHelper->setBodyPartMemento(content(), mementoName, m);
         }
     } else if (m && m->isRunning()) {
         partMetaData()->inProgress = true;
         mOtp->mHasPendingAsyncJobs = true;
     } else {
         partMetaData()->inProgress = false;
         mOtp->mHasPendingAsyncJobs = false;
     }
 
     if (m && !partMetaData()->inProgress) {
         if (!signature.isEmpty()) {
             mVerifiedText = data;
         }
         setVerificationResult(m, textNode);
     }
 
     if (!m && !partMetaData()->inProgress) {
         QString errorMsg;
         QString cryptPlugLibName;
         QString cryptPlugDisplayName;
         if (mCryptoProto) {
             cryptPlugLibName = mCryptoProto->name();
             cryptPlugDisplayName = mCryptoProto->displayName();
         }
 
         if (!mCryptoProto) {
             if (cryptPlugDisplayName.isEmpty()) {
                 errorMsg = i18n("No appropriate crypto plug-in was found.");
             } else {
                 errorMsg = i18nc("%1 is either 'OpenPGP' or 'S/MIME'",
                                  "No %1 plug-in was found.",
                                  cryptPlugDisplayName);
             }
         } else {
             errorMsg = i18n("Crypto plug-in \"%1\" cannot verify signatures.",
                             cryptPlugLibName);
         }
         partMetaData()->errorText = i18n("The message is signed, but the "
                                          "validity of the signature cannot be "
                                          "verified.<br />"
                                          "Reason: %1",
                                          errorMsg);
     }
 
     return partMetaData()->isSigned;
 }
 
 static int signatureToStatus(const GpgME::Signature &sig)
 {
     switch (sig.status().code()) {
     case GPG_ERR_NO_ERROR:
         return GPGME_SIG_STAT_GOOD;
     case GPG_ERR_BAD_SIGNATURE:
         return GPGME_SIG_STAT_BAD;
     case GPG_ERR_NO_PUBKEY:
         return GPGME_SIG_STAT_NOKEY;
     case GPG_ERR_NO_DATA:
         return GPGME_SIG_STAT_NOSIG;
     case GPG_ERR_SIG_EXPIRED:
         return GPGME_SIG_STAT_GOOD_EXP;
     case GPG_ERR_KEY_EXPIRED:
         return GPGME_SIG_STAT_GOOD_EXPKEY;
     default:
         return GPGME_SIG_STAT_ERROR;
     }
 }
 
 QString prettifyDN(const char *uid)
 {
     return QGpgME::DN(uid).prettyDN();
 }
 
 void SignedMessagePart::sigStatusToMetaData()
 {
     GpgME::Key key;
     if (partMetaData()->isSigned) {
         GpgME::Signature signature = mSignatures.front();
         partMetaData()->status_code = signatureToStatus(signature);
         partMetaData()->isGoodSignature = partMetaData()->status_code & GPGME_SIG_STAT_GOOD;
         // save extended signature status flags
         partMetaData()->sigSummary = signature.summary();
 
         if (partMetaData()->isGoodSignature && !key.keyID()) {
             // Search for the key by its fingerprint so that we can check for
             // trust etc.
             QGpgME::KeyListJob *job = mCryptoProto->keyListJob(false);    // local, no sigs
             if (!job) {
                 qCDebug(MIMETREEPARSER_LOG) << "The Crypto backend does not support listing keys. ";
             } else {
                 std::vector<GpgME::Key> found_keys;
                 // As we are local it is ok to make this synchronous
                 GpgME::KeyListResult res = job->exec(QStringList(QLatin1String(signature.fingerprint())), false, found_keys);
                 if (res.error()) {
                     qCDebug(MIMETREEPARSER_LOG) << "Error while searching key for Fingerprint: " << signature.fingerprint();
                 }
                 if (found_keys.size() > 1) {
                     // Should not Happen
                     qCDebug(MIMETREEPARSER_LOG) << "Oops: Found more then one Key for Fingerprint: " << signature.fingerprint();
                 }
                 if (found_keys.size() != 1) {
                     // Should not Happen at this point
                     qCDebug(MIMETREEPARSER_LOG) << "Oops: Found no Key for Fingerprint: " << signature.fingerprint();
                 } else {
                     key = found_keys[0];
                 }
                 delete job;
             }
         }
 
         if (key.keyID()) {
             partMetaData()->keyId = key.keyID();
         }
         if (partMetaData()->keyId.isEmpty()) {
             partMetaData()->keyId = signature.fingerprint();
         }
         partMetaData()->keyTrust = signature.validity();
         if (key.numUserIDs() > 0 && key.userID(0).id()) {
             partMetaData()->signer = prettifyDN(key.userID(0).id());
         }
         for (uint iMail = 0; iMail < key.numUserIDs(); ++iMail) {
             // The following if /should/ always result in TRUE but we
             // won't trust implicitely the plugin that gave us these data.
             if (key.userID(iMail).email()) {
                 QString email = QString::fromUtf8(key.userID(iMail).email());
                 // ### work around gpgme 0.3.QString text() const override;x / cryptplug bug where the
                 // ### email addresses are specified as angle-addr, not addr-spec:
                 if (email.startsWith(QLatin1Char('<')) && email.endsWith(QLatin1Char('>'))) {
                     email = email.mid(1, email.length() - 2);
                 }
                 if (!email.isEmpty()) {
                     partMetaData()->signerMailAddresses.append(email);
                 }
             }
         }
 
         if (signature.creationTime()) {
             partMetaData()->creationTime.setTime_t(signature.creationTime());
         } else {
             partMetaData()->creationTime = QDateTime();
         }
         if (partMetaData()->signer.isEmpty()) {
             if (key.numUserIDs() > 0 && key.userID(0).name()) {
                 partMetaData()->signer = prettifyDN(key.userID(0).name());
             }
             if (!partMetaData()->signerMailAddresses.empty()) {
                 if (partMetaData()->signer.isEmpty()) {
                     partMetaData()->signer = partMetaData()->signerMailAddresses.front();
                 } else {
                     partMetaData()->signer += QLatin1String(" <") + partMetaData()->signerMailAddresses.front() + QLatin1Char('>');
                 }
             }
         }
     }
 }
 
 void SignedMessagePart::startVerification(const QByteArray &text, const QTextCodec *aCodec)
 {
     startVerificationDetached(text, nullptr, QByteArray());
 
     if (!content() && partMetaData()->isSigned) {
         setText(aCodec->toUnicode(mVerifiedText));
     }
 }
 
 void SignedMessagePart::startVerificationDetached(const QByteArray &text, KMime::Content *textNode, const QByteArray &signature)
 {
     partMetaData()->isEncrypted = false;
     partMetaData()->isDecryptable = false;
 
     if (textNode) {
         parseInternal(textNode, false);
     }
 
     okVerify(text, signature, textNode);
 
     if (!partMetaData()->isSigned) {
         partMetaData()->creationTime = QDateTime();
     }
 }
 
 void SignedMessagePart::setVerificationResult(const CryptoBodyPartMemento *m, KMime::Content *textNode)
 {
     {
         const auto vm = dynamic_cast<const VerifyDetachedBodyPartMemento *>(m);
         if (vm) {
             mSignatures = vm->verifyResult().signatures();
         }
     }
     {
         const auto vm = dynamic_cast<const VerifyOpaqueBodyPartMemento *>(m);
         if (vm) {
             mVerifiedText = vm->plainText();
             mSignatures = vm->verifyResult().signatures();
         }
     }
     {
         const auto vm = dynamic_cast<const DecryptVerifyBodyPartMemento *>(m);
         if (vm) {
             mVerifiedText = vm->plainText();
             mSignatures = vm->verifyResult().signatures();
         }
     }
     partMetaData()->auditLogError = m->auditLogError();
     partMetaData()->auditLog = m->auditLogAsHtml();
     partMetaData()->isSigned = !mSignatures.empty();
 
     if (partMetaData()->isSigned) {
         sigStatusToMetaData();
         if (content()) {
             mOtp->nodeHelper()->setSignatureState(content(), KMMsgFullySigned);
             if (!textNode) {
                 mOtp->nodeHelper()->setPartMetaData(content(), *partMetaData());
 
                 if (!mVerifiedText.isEmpty()) {
                     auto tempNode = new KMime::Content();
                     tempNode->setContent(KMime::CRLFtoLF(mVerifiedText.constData()));
                     tempNode->parse();
 
                     if (!tempNode->head().isEmpty()) {
                         tempNode->contentDescription()->from7BitString("signed data");
                     }
                     mOtp->nodeHelper()->attachExtraContent(content(), tempNode);
 
                     parseInternal(tempNode, false);
                 }
             }
         }
     }
 }
 
 QString SignedMessagePart::plaintextContent() const
 {
     if (!content()) {
         return MessagePart::text();
     } else {
         return QString();
     }
 }
 
 QString SignedMessagePart::htmlContent() const
 {
     if (!content()) {
         return MessagePart::text();
     } else {
         return QString();
     }
 }
 
 //-----CryptMessageBlock---------------------
 EncryptedMessagePart::EncryptedMessagePart(ObjectTreeParser *otp, const QString &text, const QGpgME::Protocol *cryptoProto, const QString &fromAddress, KMime::Content *node)
     : MessagePart(otp, text)
     , mPassphraseError(false)
     , mNoSecKey(false)
     , mCryptoProto(cryptoProto)
     , mFromAddress(fromAddress)
     , mDecryptMessage(false)
 {
     setContent(node);
     partMetaData()->technicalProblem = (mCryptoProto == nullptr);
     partMetaData()->isSigned = false;
     partMetaData()->isGoodSignature = false;
     partMetaData()->isEncrypted = false;
     partMetaData()->isDecryptable = false;
     partMetaData()->keyTrust = GpgME::Signature::Unknown;
     partMetaData()->status = i18n("Wrong Crypto Plug-In.");
     partMetaData()->status_code = GPGME_SIG_STAT_NONE;
 }
 
 EncryptedMessagePart::~EncryptedMessagePart()
 {
 }
 
 void EncryptedMessagePart::setDecryptMessage(bool decrypt)
 {
     mDecryptMessage = decrypt;
 }
 
 bool EncryptedMessagePart::decryptMessage() const
 {
     return mDecryptMessage;
 }
 
 void EncryptedMessagePart::setIsEncrypted(bool encrypted)
 {
     partMetaData()->isEncrypted = encrypted;
 }
 
 bool EncryptedMessagePart::isEncrypted() const
 {
     return partMetaData()->isEncrypted;
 }
 
 bool EncryptedMessagePart::isDecryptable() const
 {
     return partMetaData()->isDecryptable;
 }
 
 bool EncryptedMessagePart::passphraseError() const
 {
     return mPassphraseError;
 }
 
 void EncryptedMessagePart::startDecryption(const QByteArray &text, const QTextCodec *aCodec)
 {
     KMime::Content *content = new KMime::Content;
     content->setBody(text);
     content->parse();
 
     startDecryption(content);
 
     if (!partMetaData()->inProgress && partMetaData()->isDecryptable) {
         if (hasSubParts()) {
             auto _mp = (subParts()[0]).dynamicCast<SignedMessagePart>();
             if (_mp) {
                 _mp->setText(aCodec->toUnicode(mDecryptedData));
             } else {
                 setText(aCodec->toUnicode(mDecryptedData));
             }
         } else {
             setText(aCodec->toUnicode(mDecryptedData));
         }
     }
 }
 
 bool EncryptedMessagePart::okDecryptMIME(KMime::Content &data)
 {
     mPassphraseError = false;
     partMetaData()->inProgress = false;
     partMetaData()->errorText.clear();
     partMetaData()->auditLogError = GpgME::Error();
     partMetaData()->auditLog.clear();
     bool bDecryptionOk = false;
     bool cannotDecrypt = false;
     NodeHelper *nodeHelper = mOtp->nodeHelper();
 
     Q_ASSERT(decryptMessage());
 
     // Check whether the memento contains a result from last time:
     const DecryptVerifyBodyPartMemento *m
         = dynamic_cast<DecryptVerifyBodyPartMemento *>(nodeHelper->bodyPartMemento(&data, "decryptverify"));
 
     Q_ASSERT(!m || mCryptoProto); //No CryptoPlugin and having a bodyPartMemento -> there is something completely wrong
 
     if (!m && mCryptoProto) {
         QGpgME::DecryptVerifyJob *job = mCryptoProto->decryptVerifyJob();
         if (!job) {
             cannotDecrypt = true;
         } else {
             const QByteArray ciphertext = data.decodedContent();
             DecryptVerifyBodyPartMemento *newM
                 = new DecryptVerifyBodyPartMemento(job, ciphertext);
             if (mOtp->allowAsync()) {
                 QObject::connect(newM, &CryptoBodyPartMemento::update,
                                  nodeHelper, &NodeHelper::update);
                 if (newM->start()) {
                     partMetaData()->inProgress = true;
                     mOtp->mHasPendingAsyncJobs = true;
                 } else {
                     m = newM;
                 }
             } else {
                 newM->exec();
                 m = newM;
             }
             nodeHelper->setBodyPartMemento(&data, "decryptverify", newM);
         }
     } else if (m && m->isRunning()) {
         partMetaData()->inProgress = true;
         mOtp->mHasPendingAsyncJobs = true;
         m = nullptr;
     }
 
     if (m) {
         const QByteArray &plainText = m->plainText();
         const GpgME::DecryptionResult &decryptResult = m->decryptResult();
         const GpgME::VerificationResult &verifyResult = m->verifyResult();
         partMetaData()->isSigned = verifyResult.signatures().size() > 0;
 
         if (verifyResult.signatures().size() > 0) {
             auto subPart = SignedMessagePart::Ptr(new SignedMessagePart(mOtp, MessagePart::text(), mCryptoProto, mFromAddress, content()));
             subPart->setVerificationResult(m, nullptr);
             appendSubPart(subPart);
         }
 
         mDecryptRecipients = decryptResult.recipients();
         bDecryptionOk = !decryptResult.error();
 //        std::stringstream ss;
 //        ss << decryptResult << '\n' << verifyResult;
 //        qCDebug(MIMETREEPARSER_LOG) << ss.str().c_str();
 
         if (!bDecryptionOk && partMetaData()->isSigned) {
             //Only a signed part
             partMetaData()->isEncrypted = false;
             bDecryptionOk = true;
             mDecryptedData = plainText;
         } else {
             mPassphraseError = decryptResult.error().isCanceled() || decryptResult.error().code() == GPG_ERR_NO_SECKEY;
             partMetaData()->isEncrypted = decryptResult.error().code() != GPG_ERR_NO_DATA;
             partMetaData()->errorText = QString::fromLocal8Bit(decryptResult.error().asString());
             if (partMetaData()->isEncrypted && decryptResult.numRecipients() > 0) {
                 partMetaData()->keyId = decryptResult.recipient(0).keyID();
             }
 
             if (bDecryptionOk) {
                 mDecryptedData = plainText;
             } else {
                 mNoSecKey = true;
                 foreach (const GpgME::DecryptionResult::Recipient &recipient, decryptResult.recipients()) {
                     mNoSecKey &= (recipient.status().code() == GPG_ERR_NO_SECKEY);
                 }
                 if (!mPassphraseError && !mNoSecKey) {          // GpgME do not detect passphrase error correctly
                     mPassphraseError = true;
                 }
             }
         }
     }
 
     if (!bDecryptionOk) {
         QString cryptPlugLibName;
         if (mCryptoProto) {
             cryptPlugLibName = mCryptoProto->name();
         }
 
         if (!mCryptoProto) {
             partMetaData()->errorText = i18n("No appropriate crypto plug-in was found.");
         } else if (cannotDecrypt) {
             partMetaData()->errorText = i18n("Crypto plug-in \"%1\" cannot decrypt messages.",
                                              cryptPlugLibName);
         } else if (!passphraseError()) {
             partMetaData()->errorText = i18n("Crypto plug-in \"%1\" could not decrypt the data.", cryptPlugLibName)
                                         + QLatin1String("<br />")
                                         + i18n("Error: %1", partMetaData()->errorText);
         }
     }
     return bDecryptionOk;
 }
 
 void EncryptedMessagePart::startDecryption(KMime::Content *data)
 {
     if (!content() && !data) {
         return;
     }
 
     if (!data) {
         data = content();
     }
 
     partMetaData()->isEncrypted = true;
 
     bool bOkDecrypt = okDecryptMIME(*data);
 
     if (partMetaData()->inProgress) {
         return;
     }
     partMetaData()->isDecryptable = bOkDecrypt;
 
     if (!partMetaData()->isDecryptable) {
         setText(QString::fromUtf8(mDecryptedData.constData()));
     }
 
     if (partMetaData()->isEncrypted && !decryptMessage()) {
         partMetaData()->isDecryptable = true;
     }
 
     if (content() && !partMetaData()->isSigned) {
         mOtp->nodeHelper()->setPartMetaData(content(), *partMetaData());
 
         if (decryptMessage()) {
             auto tempNode = new KMime::Content();
             tempNode->setContent(KMime::CRLFtoLF(mDecryptedData.constData()));
             tempNode->parse();
 
             if (!tempNode->head().isEmpty()) {
                 tempNode->contentDescription()->from7BitString("encrypted data");
             }
             mOtp->nodeHelper()->attachExtraContent(content(), tempNode);
 
             parseInternal(tempNode, false);
         }
     }
 }
 
 QString EncryptedMessagePart::plaintextContent() const
 {
     if (!content()) {
         return MessagePart::text();
     } else {
         return QString();
     }
 }
 
 QString EncryptedMessagePart::htmlContent() const
 {
     if (!content()) {
         return MessagePart::text();
     } else {
         return QString();
     }
 }
 
 QString EncryptedMessagePart::text() const
 {
     if (hasSubParts()) {
         auto _mp = (subParts()[0]).dynamicCast<SignedMessagePart>();
         if (_mp) {
             return _mp->text();
         } else {
             return MessagePart::text();
         }
     } else {
         return MessagePart::text();
     }
 }
 
 EncapsulatedRfc822MessagePart::EncapsulatedRfc822MessagePart(ObjectTreeParser *otp, KMime::Content *node, const KMime::Message::Ptr &message)
     : MessagePart(otp, QString())
     , mMessage(message)
 {
     setContent(node);
     partMetaData()->isEncrypted = false;
     partMetaData()->isSigned = false;
     partMetaData()->isEncapsulatedRfc822Message = true;
 
     mOtp->nodeHelper()->setNodeDisplayedEmbedded(node, true);
     mOtp->nodeHelper()->setPartMetaData(node, *partMetaData());
 
     if (!mMessage) {
         qCWarning(MIMETREEPARSER_LOG) << "Node is of type message/rfc822 but doesn't have a message!";
         return;
     }
 
     // The link to "Encapsulated message" is clickable, therefore the temp file needs to exists,
     // since the user can click the link and expect to have normal attachment operations there.
     mOtp->nodeHelper()->writeNodeToTempFile(message.data());
 
     parseInternal(message.data(), false);
 }
 
 EncapsulatedRfc822MessagePart::~EncapsulatedRfc822MessagePart()
 {
 }
 
 QString EncapsulatedRfc822MessagePart::text() const
 {
     return renderInternalText();
 }
 
 void EncapsulatedRfc822MessagePart::fix() const
 {
 }
diff --git a/mimetreeparser/src/viewer/messagepart.h b/mimetreeparser/src/viewer/messagepart.h
index 8fefd706..8734b04e 100644
--- a/mimetreeparser/src/viewer/messagepart.h
+++ b/mimetreeparser/src/viewer/messagepart.h
@@ -1,431 +1,433 @@
 /*
    Copyright (c) 2015 Sandro Knauß <sknauss@kde.org>
 
    This library is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public License as published by
    the Free Software Foundation; either version 2 of the License, or (at your
    option) any later version.
 
    This library is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
    License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
 */
 
 #ifndef __MIMETREEPARSER_MESSAGEPART_H__
 #define __MIMETREEPARSER_MESSAGEPART_H__
 
 #include "mimetreeparser_export.h"
 
 #include "mimetreeparser/bodypartformatter.h"
 #include "mimetreeparser/util.h"
 
 #include <KMime/Message>
 
 #include <gpgme++/verificationresult.h>
 #include <gpgme++/decryptionresult.h>
 #include <gpgme++/importresult.h>
 
 #include <QString>
 #include <QSharedPointer>
 
 #include <memory>
 
 class QTextCodec;
 namespace MessageViewer {
 class AttachmentMessagePartRenderer;
 }
 
 namespace GpgME {
 class ImportResult;
 }
 
 namespace QGpgME {
 class Protocol;
 }
 
 namespace KMime {
 class Content;
 }
 
 namespace MimeTreeParser {
 class ObjectTreeParser;
 class HtmlWriter;
 class CryptoBodyPartMemento;
 class MessagePartPrivate;
 class MultiPartAlternativeBodyPartFormatter;
 namespace Interface {
 class ObjectTreeSource;
 }
 
 class MIMETREEPARSER_EXPORT MessagePart : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QString plaintextContent READ plaintextContent)
     Q_PROPERTY(QString htmlContent READ htmlContent)
     Q_PROPERTY(bool isAttachment READ isAttachment)
     Q_PROPERTY(bool root READ isRoot)
     Q_PROPERTY(bool isHtml READ isHtml)
     Q_PROPERTY(bool isHidden READ isHidden)
     Q_PROPERTY(QString attachmentIndex READ attachmentIndex CONSTANT)
     Q_PROPERTY(QString link READ attachmentLink CONSTANT)
 public:
     typedef QSharedPointer<MessagePart> Ptr;
     MessagePart(ObjectTreeParser *otp, const QString &text);
     ~MessagePart();
 
     void setParentPart(MessagePart *parentPart);
     MessagePart *parentPart() const;
 
     virtual QString text() const;
     void setText(const QString &text);
 
     virtual QString plaintextContent() const;
     virtual QString htmlContent() const;
 
     /** The KMime::Content* node that's represented by this part.
      *  Can be @c nullptr, e.g. for sub-parts of an inline signed body part.
      */
     KMime::Content *content() const;
     void setContent(KMime::Content *node);
 
     /** The KMime::Content* node that's the source of this part.
      *  This is not necessarily the same as content(), for example for
      *  broken-up multipart nodes.
      */
     KMime::Content *attachmentContent() const;
     void setAttachmentContent(KMime::Content *node);
     bool isAttachment() const;
     /** @see KMime::Content::index() */
     QString attachmentIndex() const;
     /** @see NodeHelper::asHREF */
     QString attachmentLink() const;
 
     void setIsRoot(bool root);
     bool isRoot() const;
 
     virtual bool isHtml() const;
     virtual bool isHidden() const;
 
     PartMetaData *partMetaData() const;
 
     /* only a function that should be removed if the refactoring is over */
     virtual void fix() const;
 
     void appendSubPart(const MessagePart::Ptr &messagePart);
     const QVector<MessagePart::Ptr> &subParts() const;
     bool hasSubParts() const;
 
     Interface::ObjectTreeSource *source() const;
+    NodeHelper* nodeHelper() const;
 
 protected:
     void parseInternal(KMime::Content *node, bool onlyOneMimePart);
     QString renderInternalText() const;
 
     ObjectTreeParser *mOtp = nullptr;
 
 private:
     std::unique_ptr<MessagePartPrivate> d;
 };
 
 // TODO remove once all plugins are ported away from BPF::format()
 class MIMETREEPARSER_DEPRECATED_EXPORT LegacyPluginMessagePart : public MessagePart
 {
     Q_OBJECT
 public:
     LegacyPluginMessagePart(MimeTreeParser::ObjectTreeParser *otp);
     ~LegacyPluginMessagePart();
 
     HtmlWriter *htmlWriter() const;
     QString formatOutput() const;
 
 private:
     std::unique_ptr<HtmlWriter> m_htmlWriter;
 };
 
 class MIMETREEPARSER_EXPORT MimeMessagePart : public MessagePart
 {
     Q_OBJECT
 public:
     typedef QSharedPointer<MimeMessagePart> Ptr;
     MimeMessagePart(MimeTreeParser::ObjectTreeParser *otp, KMime::Content *node, bool onlyOneMimePart);
     virtual ~MimeMessagePart();
 
     QString text() const override;
 
     QString plaintextContent() const override;
     QString htmlContent() const override;
 private:
     bool mOnlyOneMimePart;
 
     friend class AlternativeMessagePart;
 };
 
 class MIMETREEPARSER_EXPORT MessagePartList : public MessagePart
 {
     Q_OBJECT
 public:
     typedef QSharedPointer<MessagePartList> Ptr;
     MessagePartList(MimeTreeParser::ObjectTreeParser *otp);
     virtual ~MessagePartList();
 
     QString text() const override;
 
     QString plaintextContent() const override;
     QString htmlContent() const override;
 };
 
 enum IconType {
     NoIcon = 0,
     IconExternal,
     IconInline
 };
 
 class MIMETREEPARSER_EXPORT TextMessagePart : public MessagePartList
 {
     Q_OBJECT
     Q_PROPERTY(bool showTextFrame READ showTextFrame CONSTANT)
     Q_PROPERTY(bool showLink READ showLink CONSTANT)
     Q_PROPERTY(QString label READ label CONSTANT)
     Q_PROPERTY(QString comment READ comment CONSTANT)
 public:
     typedef QSharedPointer<TextMessagePart> Ptr;
-    TextMessagePart(MimeTreeParser::ObjectTreeParser *otp, KMime::Content *node, bool drawFrame, bool showLink, bool decryptMessage);
+    TextMessagePart(MimeTreeParser::ObjectTreeParser *otp, KMime::Content *node, bool drawFrame, bool decryptMessage);
     virtual ~TextMessagePart();
 
     KMMsgSignatureState signatureState() const;
     KMMsgEncryptionState encryptionState() const;
 
     bool decryptMessage() const;
 
     bool isHidden() const override;
 
     bool showLink() const;
     bool showTextFrame() const;
+    void setShowTextFrame(bool showFrame);
 
     /** The attachment filename, or the closest approximation thereof we have. */
     QString label() const;
     /** A description of this attachment, if provided. */
     QString comment() const;
+    /** Temporary file containing the part content. */
+    QString temporaryFilePath() const;
 
 private:
     void parseContent();
 
     KMMsgSignatureState mSignatureState;
     KMMsgEncryptionState mEncryptionState;
     bool mDrawFrame;
-    bool mShowLink;
     bool mDecryptMessage;
     bool mIsHidden;
 
-    friend class MessageViewer::AttachmentMessagePartRenderer;
     friend class ObjectTreeParser;
 };
 
 class MIMETREEPARSER_EXPORT AttachmentMessagePart : public TextMessagePart
 {
     Q_OBJECT
 public:
     typedef QSharedPointer<AttachmentMessagePart> Ptr;
-    AttachmentMessagePart(MimeTreeParser::ObjectTreeParser *otp, KMime::Content *node, bool drawFrame, bool showLink, bool decryptMessage);
+    AttachmentMessagePart(MimeTreeParser::ObjectTreeParser *otp, KMime::Content *node, bool drawFrame, bool decryptMessage);
     virtual ~AttachmentMessagePart();
 
     IconType asIcon() const;
     bool neverDisplayInline() const;
     void setNeverDisplayInline(bool displayInline);
     bool isImage() const;
     void setIsImage(bool image);
 
     bool isHidden() const override;
 
 private:
     bool mIsImage;
     bool mNeverDisplayInline;
 };
 
 class MIMETREEPARSER_EXPORT HtmlMessagePart : public MessagePart
 {
     Q_OBJECT
 public:
     typedef QSharedPointer<HtmlMessagePart> Ptr;
     HtmlMessagePart(MimeTreeParser::ObjectTreeParser *otp, KMime::Content *node, MimeTreeParser::Interface::ObjectTreeSource *source);
     virtual ~HtmlMessagePart();
 
     QString text() const override;
 
     void fix() const override;
     bool isHtml() const override;
 
 private:
     Interface::ObjectTreeSource *mSource;
     QString mBodyHTML;
     QByteArray mCharset;
 
     friend class DefaultRendererPrivate;
 };
 
 class MIMETREEPARSER_EXPORT AlternativeMessagePart : public MessagePart
 {
     Q_OBJECT
 public:
     typedef QSharedPointer<AlternativeMessagePart> Ptr;
     AlternativeMessagePart(MimeTreeParser::ObjectTreeParser *otp, KMime::Content *node, Util::HtmlMode preferredMode);
     virtual ~AlternativeMessagePart();
 
     QString text() const override;
 
     Util::HtmlMode preferredMode() const;
 
     bool isHtml() const override;
 
     QString plaintextContent() const override;
     QString htmlContent() const override;
 
     QList<Util::HtmlMode> availableModes();
 
     void fix() const override;
 private:
     Util::HtmlMode mPreferredMode;
 
     QMap<Util::HtmlMode, KMime::Content *> mChildNodes;
     QMap<Util::HtmlMode, MimeMessagePart::Ptr> mChildParts;
 
     friend class DefaultRendererPrivate;
     friend class ObjectTreeParser;
     friend class MultiPartAlternativeBodyPartFormatter;
 };
 
 class MIMETREEPARSER_EXPORT CertMessagePart : public MessagePart
 {
     Q_OBJECT
 public:
     typedef QSharedPointer<CertMessagePart> Ptr;
     CertMessagePart(MimeTreeParser::ObjectTreeParser *otp, KMime::Content *node, const QGpgME::Protocol *cryptoProto, bool autoImport);
     virtual ~CertMessagePart();
 
     QString text() const override;
 
 private:
     bool mAutoImport;
     GpgME::ImportResult mImportResult;
     const QGpgME::Protocol *mCryptoProto;
     friend class DefaultRendererPrivate;
 };
 
 class MIMETREEPARSER_EXPORT EncapsulatedRfc822MessagePart : public MessagePart
 {
     Q_OBJECT
 public:
     typedef QSharedPointer<EncapsulatedRfc822MessagePart> Ptr;
     EncapsulatedRfc822MessagePart(MimeTreeParser::ObjectTreeParser *otp, KMime::Content *node, const KMime::Message::Ptr &message);
     virtual ~EncapsulatedRfc822MessagePart();
 
     QString text() const override;
 
     void fix() const override;
 private:
     const KMime::Message::Ptr mMessage;
 
     friend class DefaultRendererPrivate;
 };
 
 class MIMETREEPARSER_EXPORT EncryptedMessagePart : public MessagePart
 {
     Q_OBJECT
     Q_PROPERTY(bool decryptMessage READ decryptMessage WRITE setDecryptMessage)
     Q_PROPERTY(bool isEncrypted READ isEncrypted)
     Q_PROPERTY(bool passphraseError READ passphraseError)
 public:
     typedef QSharedPointer<EncryptedMessagePart> Ptr;
     EncryptedMessagePart(ObjectTreeParser *otp, const QString &text, const QGpgME::Protocol *cryptoProto, const QString &fromAddress, KMime::Content *node);
 
     virtual ~EncryptedMessagePart();
 
     QString text() const override;
 
     void setDecryptMessage(bool decrypt);
     bool decryptMessage() const;
 
     void setIsEncrypted(bool encrypted);
     bool isEncrypted() const;
 
     bool isDecryptable() const;
 
     bool passphraseError() const;
 
     void startDecryption(const QByteArray &text, const QTextCodec *aCodec);
     void startDecryption(KMime::Content *data = nullptr);
 
     QByteArray mDecryptedData;
 
     QString plaintextContent() const override;
     QString htmlContent() const override;
 
 private:
     /** Handles the dectyptioon of a given content
      * returns true if the decryption was successfull
      * if used in async mode, check if mMetaData.inProgress is true, it inicates a running decryption process.
      */
     bool okDecryptMIME(KMime::Content &data);
 
 protected:
     bool mPassphraseError;
     bool mNoSecKey;
     const QGpgME::Protocol *mCryptoProto;
     QString mFromAddress;
     bool mDecryptMessage;
     QByteArray mVerifiedText;
     std::vector<GpgME::DecryptionResult::Recipient> mDecryptRecipients;
 
     friend class DefaultRendererPrivate;
 };
 
 class MIMETREEPARSER_EXPORT SignedMessagePart : public MessagePart
 {
     Q_OBJECT
     Q_PROPERTY(bool isSigned READ isSigned)
 public:
     typedef QSharedPointer<SignedMessagePart> Ptr;
     SignedMessagePart(ObjectTreeParser *otp, const QString &text, const QGpgME::Protocol *cryptoProto, const QString &fromAddress, KMime::Content *node);
 
     virtual ~SignedMessagePart();
 
     void setIsSigned(bool isSigned);
     bool isSigned() const;
 
     void startVerification(const QByteArray &text, const QTextCodec *aCodec);
     void startVerificationDetached(const QByteArray &text, KMime::Content *textNode, const QByteArray &signature);
 
     QByteArray mDecryptedData;
     std::vector<GpgME::Signature> mSignatures;
 
     QString plaintextContent() const override;
     QString htmlContent() const override;
 
 private:
     /** Handles the verification of data
      * If signature is empty it is handled as inline signature otherwise as detached signature mode.
      * Returns true if the verfication was successfull and the block is signed.
      * If used in async mode, check if mMetaData.inProgress is true, it inicates a running verification process.
      */
     bool okVerify(const QByteArray &data, const QByteArray &signature, KMime::Content *textNode);
 
     void sigStatusToMetaData();
 
     void setVerificationResult(const CryptoBodyPartMemento *m, KMime::Content *textNode);
 protected:
     const QGpgME::Protocol *mCryptoProto;
     QString mFromAddress;
     QByteArray mVerifiedText;
 
     friend EncryptedMessagePart;
     friend class DefaultRendererPrivate;
 };
 }
 
 #endif //__MIMETREEPARSER_MESSAGEPART_H__
diff --git a/mimetreeparser/src/viewer/nodehelper.h b/mimetreeparser/src/viewer/nodehelper.h
index a6f3cc6f..1906d659 100644
--- a/mimetreeparser/src/viewer/nodehelper.h
+++ b/mimetreeparser/src/viewer/nodehelper.h
@@ -1,281 +1,281 @@
 /*
   Copyright (C) 2009 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.net
   Copyright (c) 2009 Andras Mantia <andras@kdab.net>
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License along
   with this program; if not, write to the Free Software Foundation, Inc.,
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
 #ifndef __MIMETREEPARSER_NODEHELPER_H__
 #define __MIMETREEPARSER_NODEHELPER_H__
 
 #include "mimetreeparser_export.h"
 
 #include "mimetreeparser/partmetadata.h"
 #include "mimetreeparser/enums.h"
 
 #include <KMime/Message>
 
 #include <QList>
 #include <QMap>
 #include <QSet>
 
 class QUrl;
 class QTextCodec;
 
 namespace MimeTreeParser {
 class AttachmentTemporaryFilesDirs;
 namespace Interface {
 class BodyPartMemento;
 }
 }
 
 namespace MimeTreeParser {
 /**
  * @author Andras Mantia <andras@kdab.net>
  */
 class MIMETREEPARSER_EXPORT NodeHelper : public QObject
 {
     Q_OBJECT
 public:
     NodeHelper();
 
     ~NodeHelper();
 
     void setNodeProcessed(KMime::Content *node, bool recurse);
     void setNodeUnprocessed(KMime::Content *node, bool recurse);
     bool nodeProcessed(KMime::Content *node) const;
     void clear();
     void forceCleanTempFiles();
 
     void setEncryptionState(const KMime::Content *node, const KMMsgEncryptionState state);
     KMMsgEncryptionState encryptionState(const KMime::Content *node) const;
 
     void setSignatureState(const KMime::Content *node, const KMMsgSignatureState state);
     KMMsgSignatureState signatureState(const KMime::Content *node) const;
 
     KMMsgSignatureState overallSignatureState(KMime::Content *node) const;
     KMMsgEncryptionState overallEncryptionState(KMime::Content *node) const;
 
     void setPartMetaData(KMime::Content *node, const PartMetaData &metaData);
     PartMetaData partMetaData(KMime::Content *node);
 
     /**
      *  Set the 'Content-Type' by mime-magic from the contents of the body.
      *  If autoDecode is true the decoded body will be used for mime type
      *  determination (this does not change the body itself).
      */
-    void magicSetType(KMime::Content *node, bool autoDecode = true);
+    static void magicSetType(KMime::Content *node, bool autoDecode = true);
 
     /**
      *  Return this mails subject, with all "forward" and "reply"
      *  prefixes removed
      */
     static QString cleanSubject(KMime::Message *message);
 
     /** Attach an extra node to an existing node */
     void attachExtraContent(KMime::Content *topLevelNode, KMime::Content *content);
 
     /** Get the extra nodes attached to the @param topLevelNode and all sub-nodes of @param topLevelNode */
     QList<KMime::Content *> extraContents(KMime::Content *topLevelNode) const;
 
     /** Return a modified message (node tree) starting from @param topLevelNode that has the original nodes and the extra nodes.
         The caller has the responsibility to delete the new message.
      */
     KMime::Message *messageWithExtraContent(KMime::Content *topLevelNode);
 
     /** Get a QTextCodec suitable for this message part */
     const QTextCodec *codec(KMime::Content *node);
 
     /** Set the charset the user selected for the message to display */
     void setOverrideCodec(KMime::Content *node, const QTextCodec *codec);
 
     Interface::BodyPartMemento *bodyPartMemento(KMime::Content *node, const QByteArray &which) const;
 
     void setBodyPartMemento(KMime::Content *node, const QByteArray &which, Interface::BodyPartMemento *memento);
 
     // A flag to remember if the node was embedded. This is useful for attachment nodes, the reader
     // needs to know if they were displayed inline or not.
     bool isNodeDisplayedEmbedded(KMime::Content *node) const;
     void setNodeDisplayedEmbedded(KMime::Content *node, bool displayedEmbedded);
 
     // Same as above, but this time determines if the node was hidden or not
     bool isNodeDisplayedHidden(KMime::Content *node) const;
     void setNodeDisplayedHidden(KMime::Content *node, bool displayedHidden);
 
     /**
      * Writes the given message part to a temporary file and returns the
      * name of this file or QString() if writing failed.
      */
     QString writeNodeToTempFile(KMime::Content *node);
 
     /**
      * Returns the temporary file path and name where this node was saved, or an empty url
      * if it wasn't saved yet with writeNodeToTempFile()
      */
     QUrl tempFileUrlFromNode(const KMime::Content *node);
 
     /**
      * Creates a temporary dir for saving attachments, etc.
      * Will be automatically deleted when another message is viewed.
      * @param param Optional part of the directory name.
      */
     QString createTempDir(const QString &param = QString());
 
     /**
      * Cleanup the attachment temp files
      */
     void removeTempFiles();
 
     /**
      * Add a file to the list of managed temporary files
      */
     void addTempFile(const QString &file);
 
     // Get a href in the form attachment:<nodeId>?place=<place>, used by ObjectTreeParser and
     // UrlHandlerManager.
     QString asHREF(const KMime::Content *node, const QString &place) const;
     KMime::Content *fromHREF(const KMime::Message::Ptr &mMessage, const QUrl &href) const;
 
     /**
      * @return true if this node is a child or an encapsulated message
      */
     static bool isInEncapsulatedMessage(KMime::Content *node);
 
     /**
      * Returns the charset for the given node. If no charset is specified
      * for the node, the defaultCharset() is returned.
      */
     static QByteArray charset(KMime::Content *node);
 
     /**
      * Check for prefixes @p prefixRegExps in @p str. If none
      * is found, @p newPrefix + ' ' is prepended to @p str and the
      * resulting string is returned. If @p replace is true, any
      * sequence of whitespace-delimited prefixes at the beginning of
      * @p str is replaced by @p newPrefix.
      */
     static QString replacePrefixes(const QString &str, const QStringList &prefixRegExps, bool replace, const QString &newPrefix);
 
     /**
      * Return a QTextCodec for the specified charset.
      * This function is a bit more tolerant, than QTextCodec::codecForName
      */
     static const QTextCodec *codecForName(const QByteArray &_str);
 
     /**
      * Returns a usable filename for a node, that can be the filename from the
      * content disposition header, or if that one is empty, the name from the
      * content type header.
      */
     static QString fileName(const KMime::Content *node);
 
     /**
      * Fixes an encoding received by a KDE function and returns the proper,
      * MIME-compilant encoding name instead.
      * @see encodingForName
      */
     static QString fixEncoding(const QString &encoding);   //TODO(Andras) move to a utility class?
 
     /**
      * Drop-in replacement for KCharsets::encodingForName(). The problem with
      * the KCharsets function is that it returns "human-readable" encoding names
      * like "ISO 8859-15" instead of valid encoding names like "ISO-8859-15".
      * This function fixes this by replacing whitespace with a hyphen.
      */
     static QString encodingForName(const QString &descriptiveName);   //TODO(Andras) move to a utility class?
 
     /**
      * Return a list of the supported encodings
      * @param usAscii if true, US-Ascii encoding will be prepended to the list.
      */
     static QStringList supportedEncodings(bool usAscii);   //TODO(Andras) move to a utility class?
 
     QString fromAsString(KMime::Content *node) const;
 
     KMime::Content *decryptedNodeForContent(KMime::Content *content) const;
 
     /**
      * This function returns the unencrypted message that is based on @p originalMessage.
      * All encrypted MIME parts are removed and replaced by their decrypted plain-text versions.
      * Encrypted parts that are within signed parts are not replaced, since that would invalidate
      * the signature.
      *
      * This only works if the message was run through ObjectTreeParser::parseObjectTree() with the
      * currrent NodeHelper before, because parseObjectTree() actually decrypts the message and stores
      * the decrypted nodes by calling attachExtraContent().
      *
      * @return the unencrypted message or an invalid pointer if the original message didn't contain
      *         a part that needed to be modified.
      */
     KMime::Message::Ptr unencryptedMessage(const KMime::Message::Ptr &originalMessage);
 
     /**
      * Returns a list of attachments of attached extra content nodes.
      * This is mainly useful is order to get attachments of encrypted messages.
      * Note that this does not include attachments from the primary node tree.
      * @see KMime::Content::attachments().
      */
     QVector<KMime::Content *> attachmentsOfExtraContents() const;
 
 Q_SIGNALS:
     void update(MimeTreeParser::UpdateMode);
 
 private:
     Q_DISABLE_COPY(NodeHelper)
     bool unencryptedMessage_helper(KMime::Content *node, QByteArray &resultingData, bool addHeaders, int recursionLevel = 1);
 
     /** Check for prefixes @p prefixRegExps in #subject(). If none
         is found, @p newPrefix + ' ' is prepended to the subject and the
         resulting string is returned. If @p replace is true, any
         sequence of whitespace-delimited prefixes at the beginning of
         #subject() is replaced by @p newPrefix
     **/
     static QString cleanSubject(KMime::Message *message, const QStringList &prefixRegExps, bool replace, const QString &newPrefix);
 
     void mergeExtraNodes(KMime::Content *node);
     void cleanFromExtraNodes(KMime::Content *node);
 
     /** Creates a persistent index string that bridges the gap between the
         permanent nodes and the temporary ones.
 
         Used internally for robust indexing.
     **/
     QString persistentIndex(const KMime::Content *node) const;
 
     /** Translates the persistentIndex into a node back
 
         node: any node of the actually message to what the persistentIndex is interpreded
     **/
     KMime::Content *contentFromIndex(KMime::Content *node, const QString &persistentIndex) const;
 
 private:
     QList<KMime::Content *> mProcessedNodes;
     QList<KMime::Content *> mNodesUnderProcess;
     QMap<const KMime::Content *, KMMsgEncryptionState> mEncryptionState;
     QMap<const KMime::Content *, KMMsgSignatureState> mSignatureState;
     QSet<KMime::Content *> mDisplayEmbeddedNodes;
     QSet<KMime::Content *> mDisplayHiddenNodes;
     QTextCodec *mLocalCodec = nullptr;
     QMap<KMime::Content *, const QTextCodec *> mOverrideCodecs;
     QMap<QString, QMap<QByteArray, Interface::BodyPartMemento *> > mBodyPartMementoMap;
     QMap<KMime::Content *, PartMetaData> mPartMetaDatas;
     QMap<KMime::Message::Content *, QList<KMime::Content *> > mExtraContents;
     AttachmentTemporaryFilesDirs *mAttachmentFilesDir = nullptr;
 
     friend class NodeHelperTest;
 };
 }
 
 #endif