diff --git a/messagecore/src/attachment/attachmentpropertiesdialog.cpp b/messagecore/src/attachment/attachmentpropertiesdialog.cpp
index f3ff5c99..122fac70 100644
--- a/messagecore/src/attachment/attachmentpropertiesdialog.cpp
+++ b/messagecore/src/attachment/attachmentpropertiesdialog.cpp
@@ -1,394 +1,390 @@
 /*
   Copyright (c) 2009 Constantin Berzan <exit3219@gmail.com>
 
   Based on KMail code by various authors (kmmsgpartdlg).
 
   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 "attachmentpropertiesdialog.h"
 
 #include "attachmentfrommimecontentjob.h"
 #include "ui_attachmentpropertiesdialog.h"
 #include "ui_attachmentpropertiesdialog_readonly.h"
 
 #include <KAboutData>
 #include "messagecore_debug.h"
 #include <KIconLoader>
 #include <PimCommon/PimUtil>
 
 #include <kmime/kmime_content.h>
 #include <kmime/kmime_headers.h>
 
 #include <KLocalizedString>
 #include <KFormat>
 #include <QMimeDatabase>
 #include <QMimeType>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 
 using namespace MessageCore;
 
 class Q_DECL_HIDDEN MessageCore::AttachmentPropertiesDialog::Private
 {
 public:
     Private(AttachmentPropertiesDialog *qq)
         : q(qq)
     {
     }
 
     ~Private()
     {
         delete ui;
         delete uiReadOnly;
     }
 
     void init(const AttachmentPart::Ptr &part, bool readOnly);
     void polishUi();
     void mimeTypeChanged(const QString &type);   // slot
     void populateEncodings();
     void populateMimeTypes();
     void populateWhatsThis();
     void loadFromPart();
     void saveToPart();
 
     AttachmentPropertiesDialog *const q;
     AttachmentPart::Ptr mPart;
 
     Ui::AttachmentPropertiesDialog *ui = nullptr;
     Ui::AttachmentPropertiesDialogReadOnly *uiReadOnly = nullptr;
     QVBoxLayout *mainLayout = nullptr;
     bool mReadOnly = false;
 };
 
 void AttachmentPropertiesDialog::Private::init(const AttachmentPart::Ptr &part, bool readOnly)
 {
     mReadOnly = readOnly;
     mPart = part;
 
     QWidget *widget = new QWidget(q);
     mainLayout = new QVBoxLayout;
     q->setLayout(mainLayout);
 
     mainLayout->addWidget(widget);
     if (mReadOnly) {
         uiReadOnly = new Ui::AttachmentPropertiesDialogReadOnly;
         uiReadOnly->setupUi(widget);
     } else {
         ui = new Ui::AttachmentPropertiesDialog;
         ui->setupUi(widget);
     }
     polishUi();
     q->setModal(true);
 
     loadFromPart();
 }
 
 void AttachmentPropertiesDialog::Private::polishUi()
 {
     // Tweak the dialog, depending on whether it is read-only or not.
     QDialogButtonBox *buttonBox = nullptr;
 
     if (mReadOnly) {
         buttonBox = new QDialogButtonBox(QDialogButtonBox::Help | QDialogButtonBox::Close, q);
     } else {
         // Update the icon when the selected mime type changes.
 
         connect(ui->mimeType, qOverload<const QString &>(&QComboBox::currentTextChanged),
                 q, [this](const QString &str) {
             mimeTypeChanged(str);
         });
         populateMimeTypes();
         populateEncodings();
         buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel | QDialogButtonBox::Help, q);
         QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
         okButton->setDefault(true);
         okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
     }
     q->connect(buttonBox->button(QDialogButtonBox::Help), &QAbstractButton::clicked, q, &AttachmentPropertiesDialog::slotHelp);
     q->connect(buttonBox, &QDialogButtonBox::accepted, q, &QDialog::accept);
     q->connect(buttonBox, &QDialogButtonBox::rejected, q, &QDialog::reject);
     mainLayout->addWidget(buttonBox);
     populateWhatsThis();
 }
 
 void AttachmentPropertiesDialog::Private::mimeTypeChanged(const QString &type)
 {
     QMimeDatabase db;
     const QMimeType mimeType = db.mimeTypeForName(type);
-    QPixmap pix;
-    if (mimeType.isValid()) {
-        pix = KIconLoader::global()->loadMimeTypeIcon(mimeType.iconName(), KIconLoader::Desktop);
-    } else {
-        pix = QIcon::fromTheme(QStringLiteral("unknown")).pixmap(q->style()->pixelMetric(QStyle::PM_MessageBoxIconSize));
-    }
+    QPixmap pix = QIcon::fromTheme(mimeType.iconName(), QIcon::fromTheme(QStringLiteral("unknown"))).pixmap(q->style()->pixelMetric(QStyle::PM_MessageBoxIconSize));
+
     if (mReadOnly) {
         uiReadOnly->mimeIcon->setPixmap(pix);
     } else {
         ui->mimeIcon->setPixmap(pix);
     }
 }
 
 void AttachmentPropertiesDialog::Private::populateWhatsThis()
 {
     // FIXME These are such a mess... Make them straightforward and pretty.
 
     const QString msgMimeType = i18n("<p>The <em>MIME type</em> of the file:</p>"
                                      "<p>Normally, you do not need to touch this setting, since the "
                                      "type of the file is automatically checked; but, sometimes, %1 "
                                      "may not detect the type correctly -- here is where you can fix "
                                      "that.</p>", KAboutData::applicationData().componentName());
 
     const QString msgSize = i18n("<p>The estimated size of the attachment:</p>"
                                  "<p>Note that, in an email message, a binary file encoded with "
                                  "base64 will take up four thirds the actual size of the file.</p>");
 
     const QString msgName = i18n("<p>The file name of the part:</p>"
                                  "<p>Although this defaults to the name of the attached file, "
                                  "it does not specify the file to be attached; rather, it "
                                  "suggests a file name to be used by the recipient's mail agent "
                                  "when saving the part to disk.</p>");
 
     const QString msgDescription = i18n("<p>A description of the part:</p>"
                                         "<p>This is just an informational description of the part, "
                                         "much like the Subject is for the whole message; most "
                                         "mail agents will show this information in their message "
                                         "previews alongside the attachment's icon.</p>");
 
     const QString msgEncoding = i18n("<p>The transport encoding of this part:</p>"
                                      "<p>Normally, you do not need to change this, since %1 will use "
                                      "a decent default encoding, depending on the MIME type; yet, "
                                      "sometimes, you can significantly reduce the size of the "
                                      "resulting message, e.g. if a PostScript file does not contain "
                                      "binary data, but consists of pure text -- in this case, choosing "
                                      "\"quoted-printable\" over the default \"base64\" will save up "
                                      "to 25% in resulting message size.</p>",
                                      KAboutData::applicationData().componentName());
 
     const QString msgAutoDisplay = i18n("<p>Check this option if you want to suggest to the "
                                         "recipient the automatic (inline) display of this part in the "
                                         "message preview, instead of the default icon view;</p>"
                                         "<p>Technically, this is carried out by setting this part's "
                                         "<em>Content-Disposition</em> header field to \"inline\" "
                                         "instead of the default \"attachment\".</p>");
 
     const QString msgSign = i18n("<p>Check this option if you want this message part to be "
                                  "signed.</p>"
                                  "<p>The signature will be made with the key that you associated "
                                  "with the currently-selected identity.</p>");
 
     const QString msgEncrypt = i18n("<p>Check this option if you want this message part to be "
                                     "encrypted.</p>"
                                     "<p>The part will be encrypted for the recipients of this "
                                     "message.</p>");
 
     if (mReadOnly) {
         uiReadOnly->size->setWhatsThis(msgSize);
         uiReadOnly->name->setWhatsThis(msgName);
         uiReadOnly->encoding->setWhatsThis(msgEncoding);
     } else {
         ui->mimeType->setWhatsThis(msgMimeType);
         ui->size->setWhatsThis(msgSize);
         ui->name->setWhatsThis(msgName);
         ui->encrypt->setWhatsThis(msgEncrypt);
         ui->sign->setWhatsThis(msgSign);
         ui->autoDisplay->setWhatsThis(msgAutoDisplay);
         ui->encoding->setWhatsThis(msgEncoding);
         ui->description->setWhatsThis(msgDescription);
     }
 }
 
 void AttachmentPropertiesDialog::Private::populateEncodings()
 {
     using namespace KMime;
     using namespace KMime::Headers;
 
     ui->encoding->clear();
     ui->encoding->addItem(nameForEncoding(CE7Bit), int(CE7Bit));
     ui->encoding->addItem(nameForEncoding(CE8Bit), int(CE8Bit));
     ui->encoding->addItem(nameForEncoding(CEquPr), int(CEquPr));
     ui->encoding->addItem(nameForEncoding(CEbase64), int(CEbase64));
 
     // TODO 8bit should be disabled if it is disabled in Settings.
     // Also, if it's a message/* part, base64 and qp should be disabled.
     // But since this is a dialog for power users anyway, let them shoot
     // themselves in the foot.  (The AttachmentJob will fail when they
     // try to compose the message.)
 }
 
 void AttachmentPropertiesDialog::Private::populateMimeTypes()
 {
     const QStringList list = QStringList() << QStringLiteral("text/html")
                                            << QStringLiteral("text/plain")
                                            << QStringLiteral("image/gif")
                                            << QStringLiteral("image/jpeg")
                                            << QStringLiteral("image/png")
                                            << QStringLiteral("application/octet-stream")
                                            << QStringLiteral("application/x-gunzip")
                                            << QStringLiteral("application/zip");
 
     ui->mimeType->addItems(list);
 }
 
 void AttachmentPropertiesDialog::Private::loadFromPart()
 {
     Q_ASSERT(mPart);
 
     if (mReadOnly) {
         uiReadOnly->mimeType->setText(QString::fromLatin1(mPart->mimeType()));
         mimeTypeChanged(QString::fromLatin1(mPart->mimeType()));
         uiReadOnly->size->setText(KFormat().formatByteSize(mPart->size()));
         uiReadOnly->name->setText(mPart->name().isEmpty() ? mPart->fileName() : mPart->name());
         if (mPart->description().isEmpty()) {
             uiReadOnly->description->hide();
             uiReadOnly->descriptionLabel->hide();
         } else {
             uiReadOnly->description->setText(mPart->description());
         }
         uiReadOnly->encoding->setText(KMime::nameForEncoding(mPart->encoding()));
     } else {
         const QString mimeType = QString::fromLatin1(mPart->mimeType());
         const int index = ui->mimeType->findText(mimeType);
         if (index == -1) {
             ui->mimeType->insertItem(0, mimeType);
             ui->mimeType->setCurrentIndex(0);
         } else {
             ui->mimeType->setCurrentIndex(index);
         }
         ui->size->setText(KFormat().formatByteSize(mPart->size()));
         ui->name->setText(mPart->name().isEmpty() ? mPart->fileName() : mPart->name());
         ui->description->setText(mPart->description());
         ui->encoding->setCurrentIndex(int(mPart->encoding()));
         ui->autoDisplay->setChecked(mPart->isInline());
         ui->encrypt->setChecked(mPart->isEncrypted());
         ui->sign->setChecked(mPart->isSigned());
     }
 }
 
 static QString removeNewlines(const QString &input)
 {
     QString ret(input);
     ret.replace(QLatin1Char('\n'), QLatin1Char(' '));
     return ret;
 }
 
 void AttachmentPropertiesDialog::Private::saveToPart()
 {
     Q_ASSERT(mPart);
     Q_ASSERT(!mReadOnly);
 
     if (mReadOnly) {
         return;
     }
     mPart->setMimeType(ui->mimeType->currentText().toLatin1());
     const QString name = removeNewlines(ui->name->text());
     mPart->setName(name);
     mPart->setFileName(name);
     mPart->setDescription(removeNewlines(ui->description->text()));
     mPart->setInline(ui->autoDisplay->isChecked());
     mPart->setSigned(ui->sign->isChecked());
     mPart->setEncrypted(ui->encrypt->isChecked());
     mPart->setInline(ui->autoDisplay->isChecked());
 
     if (ui->mimeType->currentText().startsWith(QLatin1String("message"))
         && ui->encoding->itemData(ui->encoding->currentIndex()) != KMime::Headers::CE7Bit
         && ui->encoding->itemData(ui->encoding->currentIndex()) != KMime::Headers::CE8Bit) {
         qCWarning(MESSAGECORE_LOG) << "Encoding on message/rfc822 must be \"7bit\" or \"8bit\".";
     }
 
     mPart->setEncoding(KMime::Headers::contentEncoding(
                            ui->encoding->itemData(ui->encoding->currentIndex()).toInt()));
 }
 
 AttachmentPropertiesDialog::AttachmentPropertiesDialog(const AttachmentPart::Ptr &part, bool readOnly, QWidget *parent)
     : QDialog(parent)
     , d(new Private(this))
 {
     d->init(part, readOnly);
     setWindowTitle(i18nc("@title:window", "Attachment Properties"));
 }
 
 AttachmentPropertiesDialog::AttachmentPropertiesDialog(const KMime::Content *content, QWidget *parent)
     : QDialog(parent)
     , d(new Private(this))
 {
     AttachmentFromMimeContentJob *job = new AttachmentFromMimeContentJob(content, this);
     job->exec();
     if (job->error()) {
         qCCritical(MESSAGECORE_LOG) << "AttachmentFromMimeContentJob failed." << job->errorString();
     }
 
     const AttachmentPart::Ptr part = job->attachmentPart();
     d->init(part, true);
     setWindowTitle(i18nc("@title:window", "Attachment Properties"));
 }
 
 AttachmentPropertiesDialog::~AttachmentPropertiesDialog()
 {
     delete d;
 }
 
 AttachmentPart::Ptr AttachmentPropertiesDialog::attachmentPart() const
 {
     return d->mPart;
 }
 
 bool AttachmentPropertiesDialog::isEncryptEnabled() const
 {
     if (d->ui) {
         return d->ui->encrypt->isEnabled();
     }
     return false;
 }
 
 void AttachmentPropertiesDialog::setEncryptEnabled(bool enabled)
 {
     if (d->ui) {
         d->ui->encrypt->setEnabled(enabled);
     }
 }
 
 bool AttachmentPropertiesDialog::isSignEnabled() const
 {
     if (d->ui) {
         return d->ui->sign->isEnabled();
     }
     return false;
 }
 
 void AttachmentPropertiesDialog::setSignEnabled(bool enabled)
 {
     if (d->ui) {
         d->ui->sign->setEnabled(enabled);
     }
 }
 
 void AttachmentPropertiesDialog::accept()
 {
     if (!d->mReadOnly) {
         d->saveToPart();
     }
 
     QDialog::accept();
 }
 
 void AttachmentPropertiesDialog::slotHelp()
 {
     PimCommon::Util::invokeHelp(QStringLiteral("kmail2/the-composer-window.html"), QStringLiteral("attachments"));
 }
 
 #include "moc_attachmentpropertiesdialog.cpp"