No OneTemporary
Actions

Size

61 KB

Subscribers

None

View Options

	diff --git a/autotests/widgets/messageviewertest.cpp b/autotests/widgets/messageviewertest.cpp
	index a6e9f26..ceef80c 100644
	--- a/autotests/widgets/messageviewertest.cpp
	+++ b/autotests/widgets/messageviewertest.cpp
	@@ -1,51 +1,51 @@
	// SPDX-FileCopyrightText: 2023 g10 Code GmbH
	// SPDX-FileContributor: Carl Schwan <carl@carlschwan.eu>
	// SPDX-License-Identifier: LGPL-2.0-or-later

	#include "../../src/widgets/messagecontainerwidget_p.h"
	#include <KMessageWidget>
	#include <MimeTreeParserCore/FileOpener>
	#include <MimeTreeParserWidgets/MessageViewer>
	#include <QTest>
	#include <QVBoxLayout>

	using namespace MimeTreeParser::Widgets;

	class MessageViewerTest : public QObject
	{
	Q_OBJECT

	private Q_SLOTS:

	void messageViewerSMimeEncrypted()
	{
	auto messages =
	MimeTreeParser::Core::FileOpener::openFile(QLatin1StringView(MAIL_DATA_DIR) + QLatin1Char('/') + QLatin1StringView("smime-encrypted.mbox"));
	QCOMPARE(messages.count(), 1);
	MessageViewer viewer;
	viewer.setMessage(messages[0]);

	auto layout = viewer.findChild<QVBoxLayout *>(QStringLiteral("PartLayout"));
	QVERIFY(layout);

	QCOMPARE(layout->count(), 2);
	auto container = qobject_cast<MessageWidgetContainer *>(layout->itemAt(0)->widget());
	QVERIFY(container);

	auto encryptionMessage = container->findChild<KMessageWidget *>(QStringLiteral("EncryptionMessage"));
	QCOMPARE(encryptionMessage->messageType(), KMessageWidget::Positive);
	QCOMPARE(encryptionMessage->text(), QStringLiteral("This message is encrypted. <a href=\"messageviewer:showDetails\">Details</a>"));

	encryptionMessage->linkActivated(QStringLiteral("messageviewer:showDetails"));

	QCOMPARE(encryptionMessage->text(),
	- QStringLiteral("This message is encrypted. The message is encrypted for the following certificates:<ul><li>unittest cert - KDAB (<a "
	+ QStringLiteral("This message is encrypted. The message is encrypted for the following recipients:<ul><li>unittest cert - KDAB (<a "
	"href=\"messageviewer:showCertificate#gpgsm ### SMIME ### 4CC658E3212B49DC\">4CC6 58E3 212B 49DC</a>)</li></ul>"));

	auto signatureMessage = container->findChild<KMessageWidget *>(QStringLiteral("SignatureMessage"));
	QVERIFY(!signatureMessage);
	}
	};

	QTEST_MAIN(MessageViewerTest)
	#include "messageviewertest.moc"
	diff --git a/src/core/partmodel.cpp b/src/core/partmodel.cpp
	index 7b9dad8..a14fa1c 100644
	--- a/src/core/partmodel.cpp
	+++ b/src/core/partmodel.cpp
	@@ -1,596 +1,596 @@
	// SPDX-FileCopyrightText: 2016 Sandro Knauß <knauss@kolabsys.com>
	// SPDX-License-Identifier: LGPL-2.0-or-later

	#include "partmodel.h"

	#include "htmlutils.h"
	#include "objecttreeparser.h"
	#include "utils.h"

	#include <KLocalizedString>

	#include <QDebug>
	#include <QGpgME/Protocol>
	#include <QRegularExpression>
	#include <QStringLiteral>
	#include <QTextDocument>

	// We return a pair containing the trimmed string, as well as a boolean indicating whether the string was trimmed or not
	std::pair<QString, bool> PartModel::trim(const QString &text)
	{
	// The delimiters have <p>.? prefixed including the .? because sometimes we get a byte order mark <feff> (seen with user-agent:
	// Microsoft-MacOutlook/10.1d.0.190908) We match both regulard withspace with \s and non-breaking spaces with \u00A0
	const QList<QRegularExpression> delimiters{
	// English
	QRegularExpression{QStringLiteral("<p>.?-+Original(\\s\|\u00A0)Message-+"), QRegularExpression::CaseInsensitiveOption},
	// The remainder is not quoted
	QRegularExpression{QStringLiteral("<p>.?On.*wrote:"), QRegularExpression::CaseInsensitiveOption},
	// The remainder is quoted
	QRegularExpression{QStringLiteral("> On.*wrote:"), QRegularExpression::CaseInsensitiveOption},

	// German
	// Forwarded
	QRegularExpression{QStringLiteral("<p>.?Von:.*</p>"), QRegularExpression::CaseInsensitiveOption},
	// Reply
	QRegularExpression{QStringLiteral("<p>.?Am.schrieb.:</p>"), QRegularExpression::CaseInsensitiveOption},
	// Signature
	QRegularExpression{QStringLiteral("<p>.?--(\\s\|\u00A0)<br>"), QRegularExpression::CaseInsensitiveOption},
	};

	for (const auto &expression : delimiters) {
	auto i = expression.globalMatchView(text);
	while (i.hasNext()) {
	const auto match = i.next();
	const int startOffset = match.capturedStart(0);
	// This is a very simplistic detection for an inline reply where we would have the patterns before the actual message content.
	// We simply ignore anything we find within the first few lines.
	if (startOffset >= 5) {
	return {text.mid(0, startOffset), true};
	} else {
	// Search for the next delimiter
	continue;
	}
	}
	}

	return {text, false};
	}

	static QString addCss(const QString &s)
	{
	// Get the default font from QApplication
	static const QString fontFamily = QFont{}.family();
	// overflow:hidden ensures no scrollbars are ever shown.
	static const QString css = QStringLiteral("<style>\n")
	+ QStringLiteral(
	"body {\n"
	" overflow:hidden;\n"
	" font-family: \"%1\" ! important;\n"
	" color: #31363b ! important;\n"
	" background-color: #fcfcfc ! important\n"
	"}\n")
	.arg(fontFamily)
	+ QStringLiteral("blockquote { \n"
	" border-left: 2px solid #bdc3c7 ! important;\n"
	"}\n")
	+ QStringLiteral("</style>");

	const QString header = QLatin1StringView(
	"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n"
	"<html><head><title></title>")
	+ css + QLatin1StringView("</head>\n<body>\n");
	return header + s + QStringLiteral("</body></html>");
	}

	class PartModelPrivate
	{
	public:
	PartModelPrivate(PartModel *q_ptr, const std::shared_ptr<MimeTreeParser::ObjectTreeParser> &parser)
	: q(q_ptr)
	, mParser(parser)
	{
	collectContents();
	}

	~PartModelPrivate() = default;

	void checkPart(const MimeTreeParser::MessagePart::Ptr part)
	{
	mMimeTypeCache[part.data()] = part->mimeType();
	// Extract the content of the part and
	mContents.insert(part.data(), extractContent(part.data()));
	}

	// Recursively find encapsulated messages
	void findEncapsulated(const MimeTreeParser::EncapsulatedRfc822MessagePart::Ptr &e)
	{
	mEncapsulatedParts[e.data()] = mParser->collectContentParts(e);
	for (const auto &subPart : std::as_const(mEncapsulatedParts[e.data()])) {
	checkPart(subPart);
	mParents[subPart.data()] = e.data();
	if (auto encapsulatedSub = subPart.dynamicCast<MimeTreeParser::EncapsulatedRfc822MessagePart>()) {
	findEncapsulated(encapsulatedSub);
	}
	}
	}

	QVariant extractContent(MimeTreeParser::MessagePart *messagePart)
	{
	if (auto alternativePart = dynamic_cast<MimeTreeParser::AlternativeMessagePart *>(messagePart)) {
	if (alternativePart->availableModes().contains(MimeTreeParser::AlternativeMessagePart::MultipartIcal)) {
	return alternativePart->icalContent();
	}
	}

	auto preprocessPlaintext = [&](const QString &text) {
	// Reduce consecutive new lines to never exceed 2
	auto cleaned = text;
	cleaned.replace(QRegularExpression(QStringLiteral("[\n\r]{2,}")), QStringLiteral("\n\n"));

	// We always do rich text (so we get highlighted links and stuff).
	const auto html = Qt::convertFromPlainText(cleaned, Qt::WhiteSpaceNormal);
	if (trimMail) {
	const auto result = PartModel::trim(html);
	isTrimmed = result.second;
	Q_EMIT q->trimMailChanged();
	return MimeTreeParser::linkify(result.first);
	}
	return MimeTreeParser::linkify(html);
	};

	if (messagePart->isHtml()) {
	if (dynamic_cast<MimeTreeParser::AlternativeMessagePart *>(messagePart)) {
	containsHtmlAndPlain = true;
	Q_EMIT q->containsHtmlChanged();
	if (!showHtml) {
	return preprocessPlaintext(messagePart->plaintextContent());
	}
	}
	return addCss(mParser->resolveCidLinks(messagePart->htmlContent()));
	}

	if (auto attachmentPart = dynamic_cast<MimeTreeParser::AttachmentMessagePart *>(messagePart)) {
	auto node = attachmentPart->node();
	if (node && mMimeTypeCache[attachmentPart] == QByteArrayLiteral("text/calendar")) {
	return messagePart->text();
	}
	}

	return preprocessPlaintext(messagePart->text());
	}

	QVariant contentForPart(MimeTreeParser::MessagePart *messagePart) const
	{
	return mContents.value(messagePart);
	}

	void collectContents()
	{
	mEncapsulatedParts.clear();
	mParents.clear();
	mContents.clear();
	containsHtmlAndPlain = false;
	isTrimmed = false;

	const auto parts = mParser->collectContentParts();
	MimeTreeParser::MessagePart::List filteredParts;

	for (const auto &part : parts) {
	if (part->node()) {
	const auto contentType = part->node()->contentType();
	if (contentType && contentType->hasParameter(QStringLiteral("protected-headers"))) {
	const auto contentDisposition = part->node()->contentDisposition();
	if (contentDisposition && contentDisposition->disposition() == KMime::Headers::CDinline) {
	continue;
	}
	}
	}

	filteredParts << part;
	}

	for (const auto &part : std::as_const(filteredParts)) {
	checkPart(part);
	if (auto encapsulatedPart = part.dynamicCast<MimeTreeParser::EncapsulatedRfc822MessagePart>()) {
	findEncapsulated(encapsulatedPart);
	}
	}

	for (const auto &part : std::as_const(filteredParts)) {
	if (mMimeTypeCache[part.data()] == QByteArrayLiteral("text/calendar")) {
	mParts.prepend(part);
	} else {
	mParts.append(part);
	}
	}
	}

	PartModel *q;
	MimeTreeParser::MessagePart::List mParts;
	QHash<MimeTreeParser::MessagePart *, QByteArray> mMimeTypeCache;
	QHash<MimeTreeParser::MessagePart *, MimeTreeParser::MessagePart::List> mEncapsulatedParts;
	QHash<MimeTreeParser::MessagePart , MimeTreeParser::MessagePart > mParents;
	QMap<MimeTreeParser::MessagePart *, QVariant> mContents;
	std::shared_ptr<MimeTreeParser::ObjectTreeParser> mParser;
	bool showHtml{false};
	bool containsHtmlAndPlain{false};
	bool trimMail{false};
	bool isTrimmed{false};
	};

	PartModel::PartModel(std::shared_ptr<MimeTreeParser::ObjectTreeParser> parser)
	: d(std::unique_ptr<PartModelPrivate>(new PartModelPrivate(this, parser)))
	{
	}

	PartModel::~PartModel()
	{
	}

	void PartModel::setShowHtml(bool html)
	{
	if (d->showHtml != html) {
	beginResetModel();
	d->showHtml = html;
	d->collectContents();
	endResetModel();
	Q_EMIT showHtmlChanged();
	}
	}

	bool PartModel::showHtml() const
	{
	return d->showHtml;
	}

	void PartModel::setTrimMail(bool trim)
	{
	if (d->trimMail != trim) {
	beginResetModel();
	d->trimMail = trim;
	d->collectContents();
	endResetModel();
	Q_EMIT trimMailChanged();
	}
	}

	bool PartModel::trimMail() const
	{
	return d->trimMail;
	}

	bool PartModel::isTrimmed() const
	{
	return d->isTrimmed;
	}

	bool PartModel::containsHtml() const
	{
	return d->containsHtmlAndPlain;
	}

	QHash<int, QByteArray> PartModel::roleNames() const
	{
	QHash<int, QByteArray> roles;
	roles[TypeRole] = QByteArrayLiteral("type");
	roles[ContentRole] = QByteArrayLiteral("content");
	roles[IsEmbeddedRole] = QByteArrayLiteral("embedded");
	roles[IsEncryptedRole] = QByteArrayLiteral("encrypted");
	roles[IsSignedRole] = QByteArrayLiteral("signed");
	roles[SecurityLevelRole] = QByteArrayLiteral("securityLevel");
	roles[EncryptionSecurityLevelRole] = QByteArrayLiteral("encryptionSecurityLevel");
	roles[SignatureSecurityLevelRole] = QByteArrayLiteral("signatureSecurityLevel");
	roles[ErrorType] = QByteArrayLiteral("errorType");
	roles[ErrorString] = QByteArrayLiteral("errorString");
	roles[IsErrorRole] = QByteArrayLiteral("error");
	roles[SenderRole] = QByteArrayLiteral("sender");
	roles[SignatureDetails] = QByteArrayLiteral("signatureDetails");
	roles[EncryptionDetails] = QByteArrayLiteral("encryptionDetails");
	roles[DateRole] = QByteArrayLiteral("date");
	return roles;
	}

	QModelIndex PartModel::index(int row, int column, const QModelIndex &parent) const
	{
	if (row < 0 \|\| column != 0) {
	return QModelIndex();
	}
	if (parent.isValid()) {
	const auto part = static_cast<MimeTreeParser::MessagePart *>(parent.internalPointer());
	auto encapsulatedPart = dynamic_cast<MimeTreeParser::EncapsulatedRfc822MessagePart *>(part);

	if (encapsulatedPart) {
	const auto parts = d->mEncapsulatedParts[encapsulatedPart];
	if (row < parts.size()) {
	return createIndex(row, column, parts.at(row).data());
	}
	}
	return QModelIndex();
	}
	if (row < d->mParts.size()) {
	return createIndex(row, column, d->mParts.at(row).data());
	}
	return QModelIndex();
	}

	SignatureInfo encryptionInfo(MimeTreeParser::MessagePart *messagePart)
	{
	SignatureInfo signatureInfo;
	const auto encryptions = messagePart->encryptions();
	if (encryptions.size() > 1) {
	qWarning() << "Can't deal with more than one encryption";
	}
	for (const auto &encryptionPart : encryptions) {
	signatureInfo.keyId = encryptionPart->partMetaData()->keyId;
	signatureInfo.cryptoProto = encryptionPart->cryptoProto();
	signatureInfo.decryptRecipients = encryptionPart->decryptRecipients();
	}
	return signatureInfo;
	};

	SignatureInfo signatureInfo(MimeTreeParser::MessagePart *messagePart)
	{
	SignatureInfo signatureInfo;
	const auto signatures = messagePart->signatures();
	if (signatures.size() > 1) {
	qWarning() << "Can't deal with more than one signature";
	}
	for (const auto &signaturePart : signatures) {
	signatureInfo.keyId = signaturePart->partMetaData()->keyId;
	signatureInfo.cryptoProto = signaturePart->cryptoProto();
	signatureInfo.keyMissing = signaturePart->partMetaData()->sigSummary & GpgME::Signature::KeyMissing;
	signatureInfo.keyExpired = signaturePart->partMetaData()->sigSummary & GpgME::Signature::KeyExpired;
	signatureInfo.keyRevoked = signaturePart->partMetaData()->sigSummary & GpgME::Signature::KeyRevoked;
	signatureInfo.sigExpired = signaturePart->partMetaData()->sigSummary & GpgME::Signature::SigExpired;
	signatureInfo.crlMissing = signaturePart->partMetaData()->sigSummary & GpgME::Signature::CrlMissing;
	signatureInfo.crlTooOld = signaturePart->partMetaData()->sigSummary & GpgME::Signature::CrlTooOld;
	signatureInfo.signer = signaturePart->partMetaData()->signer;
	signatureInfo.isCompliant = signaturePart->partMetaData()->isCompliant;
	signatureInfo.signerMailAddresses = signaturePart->partMetaData()->signerMailAddresses;
	signatureInfo.signatureIsGood = signaturePart->partMetaData()->isGoodSignature;
	signatureInfo.keyTrust = signaturePart->partMetaData()->keyTrust;
	}
	return signatureInfo;
	}

	QVariant PartModel::data(const QModelIndex &index, int role) const
	{
	if (!index.isValid()) {
	return QVariant();
	}

	if (index.internalPointer()) {
	const auto messagePart = static_cast<MimeTreeParser::MessagePart *>(index.internalPointer());
	// qWarning() << "Found message part " << messagePart->metaObject()->className() << messagePart->partMetaData()->status << messagePart->error();
	Q_ASSERT(messagePart);
	switch (role) {
	case Qt::DisplayRole:
	return QStringLiteral("Content%1");
	case SenderRole: {
	if (auto e = dynamic_cast<MimeTreeParser::EncapsulatedRfc822MessagePart *>(messagePart)) {
	return e->from();
	}
	return {};
	}
	case DateRole: {
	if (auto e = dynamic_cast<MimeTreeParser::EncapsulatedRfc822MessagePart *>(messagePart)) {
	return e->date();
	}
	return {};
	}
	case TypeRole: {
	if (messagePart->error()) {
	return QVariant::fromValue(Types::Error);
	}
	if (dynamic_cast<MimeTreeParser::EncapsulatedRfc822MessagePart *>(messagePart)) {
	return QVariant::fromValue(Types::Encapsulated);
	}
	if (auto alternativePart = dynamic_cast<MimeTreeParser::AlternativeMessagePart *>(messagePart)) {
	if (alternativePart->availableModes().contains(MimeTreeParser::AlternativeMessagePart::MultipartIcal)) {
	return QVariant::fromValue(Types::Ical);
	}
	}
	if (auto attachmentPart = dynamic_cast<MimeTreeParser::AttachmentMessagePart *>(messagePart)) {
	auto node = attachmentPart->node();
	if (!node) {
	qWarning() << "no content for attachment";
	return {};
	}
	if (d->mMimeTypeCache[attachmentPart] == QByteArrayLiteral("text/calendar")) {
	return QVariant::fromValue(Types::Ical);
	}
	}
	if (!d->showHtml && d->containsHtmlAndPlain) {
	return QVariant::fromValue(Types::Plain);
	}
	// For simple html we don't need a browser
	auto complexHtml = [&] {
	if (messagePart->isHtml()) {
	const auto text = messagePart->htmlContent();
	if (text.contains(QStringLiteral("<!DOCTYPE html PUBLIC"))) {
	// We can probably deal with this if it adheres to the strict dtd
	//(that's what our composer produces as well)
	if (!text.contains(QStringLiteral("http://www.w3.org/TR/REC-html40/strict.dtd"))) {
	return true;
	}
	}
	// Blockquotes don't support any styling which would be necessary so they become readable.
	if (text.contains(QStringLiteral("blockquote"))) {
	return true;
	}
	// Media queries are too advanced
	if (text.contains(QStringLiteral("@media"))) {
	return true;
	}
	// auto css properties are not supported e.g margin-left: auto;
	if (text.contains(QStringLiteral(": auto;"))) {
	return true;
	}
	return false;
	} else {
	return false;
	}
	}();
	if (complexHtml) {
	return QVariant::fromValue(Types::Html);
	}
	return QVariant::fromValue(Types::Plain);
	}
	case IsEmbeddedRole:
	return false;
	case IsErrorRole:
	return messagePart->error();
	case ContentRole:
	return d->contentForPart(messagePart);
	case IsEncryptedRole:
	return messagePart->encryptionState() != MimeTreeParser::KMMsgNotEncrypted;
	case IsSignedRole:
	return messagePart->signatureState() != MimeTreeParser::KMMsgNotSigned;
	case SecurityLevelRole: {
	auto signature = messagePart->signatureState();
	auto encryption = messagePart->encryptionState();
	bool messageIsSigned = signature == MimeTreeParser::KMMsgPartiallySigned \|\| signature == MimeTreeParser::KMMsgFullySigned;
	bool messageIsEncrypted = encryption == MimeTreeParser::KMMsgPartiallyEncrypted \|\| encryption == MimeTreeParser::KMMsgFullyEncrypted;

	if (messageIsSigned) {
	const auto sigInfo = signatureInfo(messagePart);
	if (!sigInfo.signatureIsGood) {
	if (sigInfo.keyMissing \|\| sigInfo.keyExpired) {
	return SecurityLevel::NotSoGood;
	}
	return SecurityLevel::Bad;
	}
	}
	// All good
	if ((messageIsSigned \|\| messageIsEncrypted) && !messagePart->error()) {
	return SecurityLevel::Good;
	}
	// No info
	return SecurityLevel::Unknow;
	}
	case EncryptionSecurityLevelRole: {
	auto encryption = messagePart->encryptionState();
	bool messageIsEncrypted = encryption == MimeTreeParser::KMMsgPartiallyEncrypted \|\| encryption == MimeTreeParser::KMMsgFullyEncrypted;
	if (messagePart->error()) {
	return SecurityLevel::Bad;
	}
	// All good
	if (messageIsEncrypted) {
	return SecurityLevel::Good;
	}
	// No info
	return SecurityLevel::Unknow;
	}
	case SignatureSecurityLevelRole: {
	auto signature = messagePart->signatureState();
	bool messageIsSigned = signature == MimeTreeParser::KMMsgPartiallySigned \|\| signature == MimeTreeParser::KMMsgFullySigned;
	if (messageIsSigned) {
	const auto sigInfo = signatureInfo(messagePart);
	if (!sigInfo.signatureIsGood) {
	if (sigInfo.keyMissing \|\| sigInfo.keyExpired) {
	return SecurityLevel::NotSoGood;
	}
	return SecurityLevel::Bad;
	}
	return SecurityLevel::Good;
	}
	// No info
	return SecurityLevel::Unknow;
	}
	case SignatureDetails:
	return QVariant::fromValue(signatureInfo(messagePart));
	case EncryptionDetails:
	return QVariant::fromValue(encryptionInfo(messagePart));
	case ErrorType:
	return messagePart->error();
	case ErrorString: {
	switch (messagePart->error()) {
	case MimeTreeParser::MessagePart::NoKeyError: {
	if (auto encryptedMessagePart = dynamic_cast<MimeTreeParser::EncryptedMessagePart *>(messagePart)) {
	if (encryptedMessagePart->isNoSecKey()) {
	QString errorMessage;
	if (encryptedMessagePart->cryptoProto() == QGpgME::smime()) {
	errorMessage +=
	- i18ndc("mimetreeparser", "@info:status", "This message cannot be decrypted with any S/MIME certificate in your keyring.");
	+ i18ndc("mimetreeparser", "@info:status", "You cannot decrypt this message.");
	} else {
	errorMessage +=
	- i18ndc("mimetreeparser", "@info:status", "This message cannot be decrypted with any OpenPGP certificate in your keyring.");
	+ i18ndc("mimetreeparser", "@info:status", "You cannot decrypt this message.");
	}
	if (!encryptedMessagePart->decryptRecipients().empty()) {
	errorMessage += QLatin1Char(' ')
	+ i18ndcp("mimetreeparser",
	"@info:status",
	- "The message is encrypted for the following certificate:",
	- "The message is encrypted for the following certificates:",
	+ "The message is encrypted for the following recipient:",
	+ "The message is encrypted for the following recipients:",
	encryptedMessagePart->decryptRecipients().size());
	errorMessage +=
	MimeTreeParser::decryptRecipientsToHtml(encryptedMessagePart->decryptRecipients(), encryptedMessagePart->cryptoProto());
	}
	return errorMessage;
	}
	}
	}

	return messagePart->errorString();

	case MimeTreeParser::MessagePart::PassphraseError:
	return i18ndc("mimetreeparser", "@info:status", "Wrong passphrase.");
	case MimeTreeParser::MessagePart::UnknownError:
	break;
	default:
	break;
	}
	return messagePart->errorString();
	}
	}
	}
	return QVariant();
	}

	QModelIndex PartModel::parent(const QModelIndex &index) const
	{
	if (index.isValid()) {
	if (auto indexPart = static_cast<MimeTreeParser::MessagePart *>(index.internalPointer())) {
	for (const auto &part : std::as_const(d->mParts)) {
	if (part.data() == indexPart) {
	return QModelIndex();
	}
	}
	const auto parentPart = d->mParents[indexPart];
	Q_ASSERT(parentPart);
	int row = 0;
	const auto parts = d->mEncapsulatedParts[parentPart];
	for (const auto &part : parts) {
	if (part.data() == indexPart) {
	break;
	}
	row++;
	}
	return createIndex(row, 0, parentPart);
	}
	return {};
	}
	return {};
	}

	int PartModel::rowCount(const QModelIndex &parent) const
	{
	if (parent.isValid()) {
	const auto part = static_cast<MimeTreeParser::MessagePart *>(parent.internalPointer());
	auto encapsulatedPart = dynamic_cast<MimeTreeParser::EncapsulatedRfc822MessagePart *>(part);

	if (encapsulatedPart) {
	const auto parts = d->mEncapsulatedParts[encapsulatedPart];
	return parts.size();
	}
	return 0;
	}
	return d->mParts.count();
	}

	int PartModel::columnCount(const QModelIndex &) const
	{
	return 1;
	}

	#include "moc_partmodel.cpp"
	diff --git a/src/quick/qml/private/MailPartModel.qml b/src/quick/qml/private/MailPartModel.qml
	index 6f89d73..3e01012 100644
	--- a/src/quick/qml/private/MailPartModel.qml
	+++ b/src/quick/qml/private/MailPartModel.qml
	@@ -1,170 +1,170 @@
	// SPDX-FileCopyrightText: 2016 Michael Bohlender <michael.bohlender@kdemail.net>
	// SPDX-FileCopyrightText: 2022 Carl Schwan <carl@carlschwan.eu>
	// SPDX-License-Identifier: GPL-2.0-or-later

	import QtQuick 2.15
	import QtQuick.Controls 2.15 as QQC2
	import QtQuick.Layouts 1.15
	import QtQml.Models 2.2
	import org.kde.pim.mimetreeparser 1.0
	import org.kde.kirigami 2.19 as Kirigami

	DelegateModel {
	id: root

	property string searchString: ""
	property bool autoLoadImages: false
	property int padding: Kirigami.Units.largeSpacing
	property url icalCustomComponent

	delegate: RowLayout {
	id: partColumn

	width: ListView.view.width - Kirigami.Units.largeSpacing
	x: Kirigami.Units.smallSpacing

	function getType(securityLevel) {
	if (securityLevel === PartModel.Good) {
	return Kirigami.MessageType.Positive
	}
	if (securityLevel === PartModel.Bad) {
	return Kirigami.MessageType.Error
	}
	if (securityLevel === PartModel.NotSoGood) {
	return Kirigami.MessageType.Warning
	}
	return Kirigami.MessageType.Information
	}

	function getColor(securityLevel) {
	if (securityLevel === PartModel.Good) {
	return Kirigami.Theme.positiveTextColor
	}
	if (securityLevel === PartModel.Bad) {
	return Kirigami.Theme.negativeTextColor
	}
	if (securityLevel === PartModel.NotSoGood) {
	return Kirigami.Theme.neutralTextColor
	}
	return "transparent"
	}

	function getDetails(signatureDetails) {
	let details = "";
	if (signatureDetails.keyMissing) {
	- details += i18ndc("mimetreeparser", "@label", "This message has been signed using the certificate %1.", signatureDetails.keyId) + "\n";
	- details += i18ndc("mimetreeparser", "@label", "The certificate details are not available.")
	+ details += i18ndc("mimetreeparser", "@info", "This message was signed with certificate %1.", signatureDetails.keyId) + "\n";
	+ details += i18ndc("mimetreeparser", "@info", "The certificate details are not available.")
	} else {
	- details += i18ndc("mimetreeparser", "@label", "This message has been signed using the certificate %1 by %2.", signatureDetails.keyId, signatureDetails.signer) + "\n";
	+ details += i18ndc("mimetreeparser", "@info", "This message was signed by %1 with certificate %2.", signatureDetails.signer, signatureDetails.keyId) + "\n";
	if (signatureDetails.keyRevoked) {
	- details += "\n" + i18ndc("mimetreeparser", "@label", "The certificate was revoked.")
	+ details += "\n" + i18ndc("mimetreeparser", "@info", "The certificate was revoked.")
	}
	if (signatureDetails.keyExpired) {
	- details += "\n" + i18ndc("mimetreeparser", "@label", "The certificate has expired.")
	+ details += "\n" + i18ndc("mimetreeparser", "@info", "The certificate has expired.")
	}
	if (signatureDetails.keyIsTrusted) {
	- details += "\n" + i18ndc("mimetreeparser", "@label", "You are trusting this certificate.")
	+ details += "\n" + i18ndc("mimetreeparser", "@info", "The certificate is certified.")
	}
	if (!signatureDetails.signatureIsGood && !signatureDetails.keyRevoked && !signatureDetails.keyExpired && !signatureDetails.keyIsTrusted) {
	- details += "\n" + i18ndc("mimetreeparser", "@label", "The signature is invalid.")
	+ details += "\n" + i18ndc("mimetreeparser", "@info", "The signature is invalid.")
	}
	}
	return details
	}

	QQC2.Control {
	Layout.preferredWidth: Kirigami.Units.smallSpacing
	Layout.fillHeight: true

	visible: model.encrypted

	background: Rectangle {
	id: border

	color: getColor(model.securityLevel)
	opacity: 0.5
	}

	QQC2.ToolTip.text: getDetails(model.encryptionSecurityLevel)
	QQC2.ToolTip.visible: hovered
	QQC2.ToolTip.delay: Kirigami.Units.toolTipDelay
	}

	ColumnLayout {
	Banner {
	iconName: "mail-encrypted"
	type: getType(model.encryptionSecurityLevel)
	visible: model.encrypted
	- text: !model.encryptionDetails.keyId ? i18n("This message is encrypted but we don't have the certificate for it.") : i18n("This message is encrypted to the certificate: %1", model.encryptionDetails.keyId);
	+ text: !model.encryptionDetails.keyId ? i18n("This message is encrypted but you don't have a matching secret key.") : i18n("This message is encrypted for: %1", model.encryptionDetails.keyId);

	Layout.fillWidth: true
	}

	Banner {
	iconName: 'mail-signed'
	visible: model.signed
	type: getType(model.signatureSecurityLevel)
	text: getDetails(model.signatureDetails)

	Layout.fillWidth: true
	}

	Loader {
	id: partLoader

	Layout.preferredHeight: item ? item.contentHeight : 0
	Layout.fillWidth: true
	Layout.leftMargin: root.padding
	Layout.rightMargin: root.padding

	Component.onCompleted: {
	switch (model.type + 0) {
	case PartModel.Plain:
	partLoader.setSource("TextPart.qml", {
	content: model.content,
	embedded: model.embedded,
	})
	break
	case PartModel.Html:
	partLoader.setSource("HtmlPart.qml", {
	content: model.content,
	})
	break;
	case PartModel.Error:
	partLoader.setSource("ErrorPart.qml", {
	errorType: model.errorType,
	errorString: model.errorString,
	})
	break;
	case PartModel.Encapsulated:
	partLoader.setSource("MailPart.qml", {
	rootIndex: root.modelIndex(index),
	model: root.model,
	sender: model.sender,
	date: model.date,
	})
	break;
	case PartModel.Ical:
	partLoader.setSource(root.icalCustomComponent ? root.icalCustomComponent : "ICalPart.qml", {
	content: model.content,
	})
	break;
	}
	}

	Binding {
	target: partLoader.item
	property: "searchString"
	value: root.searchString
	when: partLoader.status === Loader.Ready
	}
	Binding {
	target: partLoader.item
	property: "autoLoadImages"
	value: root.autoLoadImages
	when: partLoader.status === Loader.Ready
	}
	}
	}
	}
	}
	diff --git a/src/widgets/messagecontainerwidget.cpp b/src/widgets/messagecontainerwidget.cpp
	index e938303..0b403c3 100644
	--- a/src/widgets/messagecontainerwidget.cpp
	+++ b/src/widgets/messagecontainerwidget.cpp
	@@ -1,268 +1,268 @@
	// SPDX-FileCopyrightText: 2023 g10 Code GmbH
	// SPDX-FileContributor: Carl Schwan <carl.schwan@gnupg.com>
	// SPDX-License-Identifier: LGPL-2.0-or-later

	#include "../core/utils.h"
	#include "messagecontainerwidget_p.h"
	#include "urlhandler_p.h"

	#include <KLocalizedString>
	#include <KMessageWidget>
	#include <Libkleo/Compliance>
	#include <Libkleo/Formatting>
	#include <QGpgME/Protocol>

	#include <QLabel>
	#include <QPaintEvent>
	#include <QPainter>
	#include <QVBoxLayout>

	namespace
	{

	const int borderWidth = 5;

	QColor getColor(PartModel::SecurityLevel securityLevel)
	{
	const static QHash<PartModel::SecurityLevel, QColor> colors{
	{PartModel::Good, QColor(39, 174, 96)}, // Window: ForegroundPositive
	{PartModel::Bad, QColor(218, 68, 83)}, // Window: ForegroundNegative
	{PartModel::NotSoGood, QColor(246, 116, 0)}, // Window: ForegroundNeutral
	};

	return colors.value(securityLevel, QColor());
	}

	KMessageWidget::MessageType getType(PartModel::SecurityLevel securityLevel)
	{
	const static QHash<PartModel::SecurityLevel, KMessageWidget::MessageType> messageTypes{
	{PartModel::Good, KMessageWidget::MessageType::Positive},
	{PartModel::Bad, KMessageWidget::MessageType::Error},
	{PartModel::NotSoGood, KMessageWidget::MessageType::Warning},
	};

	return messageTypes.value(securityLevel, KMessageWidget::MessageType::Information);
	}

	QString getDetails(const SignatureInfo &signatureDetails)
	{
	QString href;
	if (signatureDetails.cryptoProto) {
	href = QStringLiteral("messageviewer:showCertificate#%1 ### %2 ### %3")
	.arg(signatureDetails.cryptoProto->displayName(), signatureDetails.cryptoProto->name(), QString::fromLatin1(signatureDetails.keyId));
	}

	QString details;
	if (signatureDetails.keyMissing) {
	if (Kleo::DeVSCompliance::isCompliant() && signatureDetails.isCompliant) {
	details += i18ndc("mimetreeparser",
	- "@label",
	+ "@info",
	"This message has been signed VS-NfD compliant using the certificate <a href=\"%1\">%2</a>.",
	href,
	Kleo::Formatting::prettyID(signatureDetails.keyId.toStdString().data()))
	+ QLatin1Char('\n');
	} else {
	details += i18ndc("mimetreeparser",
	- "@label",
	+ "@info",
	"This message has been signed using the certificate <a href=\"%1\">%2</a>.",
	href,
	Kleo::Formatting::prettyID(signatureDetails.keyId.toStdString().data()))
	+ QLatin1Char('\n');
	}
	- details += i18ndc("mimetreeparser", "@label", "The certificate details are not available.");
	+ details += i18ndc("mimetreeparser", "@info", "The certificate details are not available.");
	} else {
	QString signerDisplayName = signatureDetails.signer.toHtmlEscaped();
	if (signatureDetails.cryptoProto == QGpgME::smime()) {
	Kleo::DN dn(signatureDetails.signer);
	signerDisplayName = MimeTreeParser::dnToDisplayName(dn).toHtmlEscaped();
	}
	if (Kleo::DeVSCompliance::isCompliant() && signatureDetails.isCompliant) {
	- details += i18ndc("mimetreeparser", "@label", "This message has been signed VS-NfD compliant by %1.", signerDisplayName);
	+ details += i18ndc("mimetreeparser", "@info", "This message has been signed VS-NfD compliant by %1.", signerDisplayName);
	} else {
	- details += i18ndc("mimetreeparser", "@label", "This message has been signed by %1.", signerDisplayName);
	+ details += i18ndc("mimetreeparser", "@info", "This message has been signed by %1.", signerDisplayName);
	}
	if (signatureDetails.keyRevoked) {
	- details += QLatin1Char('\n') + i18ndc("mimetreeparser", "@label", "The <a href=\"%1\">certificate</a> was revoked.", href);
	+ details += QLatin1Char('\n') + i18ndc("mimetreeparser", "@info", "The <a href=\"%1\">certificate</a> was revoked.", href);
	}
	if (signatureDetails.keyExpired) {
	- details += QLatin1Char('\n') + i18ndc("mimetreeparser", "@label", "The <a href=\"%1\">certificate</a> was expired.", href);
	+ details += QLatin1Char('\n') + i18ndc("mimetreeparser", "@info", "The <a href=\"%1\">certificate</a> is expired.", href);
	}

	if (signatureDetails.keyTrust == GpgME::Signature::Unknown) {
	details += QLatin1Char(' ')
	- + i18ndc("mimetreeparser", "@label", "The signature is valid, but the <a href=\"%1\">certificate</a>'s validity is unknown.", href);
	+ + i18ndc("mimetreeparser", "@info", "The signature is valid, but the <a href=\"%1\">certificate</a>'s validity is unknown.", href);
	} else if (signatureDetails.keyTrust == GpgME::Signature::Marginal) {
	details += QLatin1Char(' ')
	- + i18ndc("mimetreeparser", "@label", "The signature is valid and the <a href=\"%1\">certificate</a> is marginally trusted.", href);
	+ + i18ndc("mimetreeparser", "@info", "The signature is valid and the <a href=\"%1\">certificate</a> is marginally trusted.", href);
	} else if (signatureDetails.keyTrust == GpgME::Signature::Full) {
	details +=
	- QLatin1Char(' ') + i18ndc("mimetreeparser", "@label", "The signature is valid and the <a href=\"%1\">certificate</a> is fully trusted.", href);
	+ QLatin1Char(' ') + i18ndc("mimetreeparser", "@info", "The signature is valid and the <a href=\"%1\">certificate</a> is fully trusted.", href);
	} else if (signatureDetails.keyTrust == GpgME::Signature::Ultimate) {
	details += QLatin1Char(' ')
	- + i18ndc("mimetreeparser", "@label", "The signature is valid and the <a href=\"%1\">certificate</a> is ultimately trusted.", href);
	+ + i18ndc("mimetreeparser", "@info", "The signature is valid and the <a href=\"%1\">certificate</a> is ultimately trusted.", href);
	} else {
	details +=
	- QLatin1Char(' ') + i18ndc("mimetreeparser", "@label", "The signature is valid, but the <a href=\"%1\">certificate</a> is untrusted.", href);
	+ QLatin1Char(' ') + i18ndc("mimetreeparser", "@info", "The signature is valid, but the <a href=\"%1\">certificate</a> is not certified.", href);
	}
	if (!signatureDetails.signatureIsGood && !signatureDetails.keyRevoked && !signatureDetails.keyExpired
	&& signatureDetails.keyTrust != GpgME::Signature::Unknown) {
	- details += QLatin1Char(' ') + i18ndc("mimetreeparser", "@label", "The signature is invalid.");
	+ details += QLatin1Char(' ') + i18ndc("mimetreeparser", "@info", "The signature is invalid.");
	}
	}
	return details;
	}

	}

	MessageWidgetContainer::MessageWidgetContainer(bool isSigned,
	const SignatureInfo &signatureInfo,
	PartModel::SecurityLevel signatureSecurityLevel,
	bool displaySignatureInfo,
	bool isEncrypted,
	const SignatureInfo &encryptionInfo,
	PartModel::SecurityLevel encryptionSecurityLevel,
	bool displayEncryptionInfo,
	UrlHandler *urlHandler,
	QWidget *parent)
	: QFrame(parent)
	, m_isSigned(isSigned)
	, m_signatureInfo(signatureInfo)
	, m_signatureSecurityLevel(signatureSecurityLevel)
	, m_displaySignatureInfo(displaySignatureInfo)
	, m_isEncrypted(isEncrypted)
	, m_encryptionInfo(encryptionInfo)
	, m_encryptionSecurityLevel(encryptionSecurityLevel)
	, m_displayEncryptionInfo(displayEncryptionInfo)
	, m_urlHandler(urlHandler)
	{
	createLayout();
	}

	MessageWidgetContainer::~MessageWidgetContainer() = default;

	void MessageWidgetContainer::paintEvent(QPaintEvent *event)
	{
	Q_UNUSED(event)

	if (!m_isSigned && !m_isEncrypted) {
	return;
	}

	QPainter painter(this);
	if (layoutDirection() == Qt::RightToLeft) {
	auto r = rect();
	r.setX(width() - borderWidth);
	r.setWidth(borderWidth);
	const QColor color = getColor(PartModel::SecurityLevel::Good);
	painter.setRenderHint(QPainter::Antialiasing);
	painter.setBrush(QColor(color));
	painter.setPen(QPen(Qt::NoPen));
	painter.drawRect(r);
	} else {
	auto r = rect();
	r.setWidth(borderWidth);
	const QColor color = getColor(PartModel::SecurityLevel::Good);
	painter.setRenderHint(QPainter::Antialiasing);
	painter.setBrush(QColor(color));
	painter.setPen(QPen(Qt::NoPen));
	painter.drawRect(r);
	}
	}

	bool MessageWidgetContainer::event(QEvent *event)
	{
	if (event->type() == QEvent::Polish && !layout()) {
	createLayout();
	}

	return QFrame::event(event);
	}

	void MessageWidgetContainer::createLayout()
	{
	delete layout();

	auto vLayout = new QVBoxLayout(this);

	if (m_isSigned \|\| m_isEncrypted) {
	if (layoutDirection() == Qt::RightToLeft) {
	layout()->setContentsMargins(0, 0, borderWidth * 2, 0);
	} else {
	layout()->setContentsMargins(borderWidth * 2, 0, 0, 0);
	}
	}

	if (m_isEncrypted && m_displayEncryptionInfo) {
	auto encryptionMessage = new KMessageWidget(this);
	encryptionMessage->setObjectName(QLatin1StringView("EncryptionMessage"));
	encryptionMessage->setCloseButtonVisible(false);

	QString text;
	if (m_encryptionInfo.keyId.isEmpty()) {
	encryptionMessage->setIcon(QIcon::fromTheme(QStringLiteral("data-error")));
	encryptionMessage->setMessageType(KMessageWidget::Error);
	if (Kleo::DeVSCompliance::isCompliant() && m_encryptionInfo.isCompliant) {
	- text = i18n("This message is VS-NfD compliant encrypted but we don't have the certificate for it.", QString::fromUtf8(m_encryptionInfo.keyId));
	+ text = i18n("This message is VS-NfD compliant encrypted but you don't have a matching secret key.", QString::fromUtf8(m_encryptionInfo.keyId));
	} else {
	- text = i18n("This message is encrypted but we don't have the certificate for it.");
	+ text = i18n("This message is encrypted but you don't have a matching secret key.");
	}
	} else {
	encryptionMessage->setIcon(QIcon::fromTheme(QStringLiteral("mail-encrypted")));
	encryptionMessage->setMessageType(KMessageWidget::Positive);
	if (Kleo::DeVSCompliance::isCompliant() && m_encryptionInfo.isCompliant) {
	text = i18n("This message is VS-NfD compliant encrypted.");
	} else {
	text = i18n("This message is encrypted.");
	}
	}

	encryptionMessage->setText(text + QLatin1Char(' ') + QStringLiteral("<a href=\"messageviewer:showDetails\">Details</a>"));

	connect(encryptionMessage, &KMessageWidget::linkActivated, this, [this, encryptionMessage, text](const QString &link) {
	QUrl url(link);
	if (url.path() == QStringLiteral("showDetails")) {
	- QString newText = text + QLatin1Char(' ') + i18n("The message is encrypted for the following certificates:");
	+ QString newText = text + QLatin1Char(' ') + i18n("The message is encrypted for the following recipients:");

	newText += MimeTreeParser::decryptRecipientsToHtml(m_encryptionInfo.decryptRecipients, m_encryptionInfo.cryptoProto);

	encryptionMessage->setText(newText);
	return;
	}

	if (url.path() == QStringLiteral("showCertificate")) {
	m_urlHandler->handleClick(QUrl(link), window()->windowHandle());
	}
	});

	vLayout->addWidget(encryptionMessage);
	}

	if (m_isSigned && m_displaySignatureInfo) {
	auto signatureMessage = new KMessageWidget(this);
	signatureMessage->setObjectName(QStringLiteral("SignatureMessage"));
	signatureMessage->setCloseButtonVisible(false);
	signatureMessage->setText(getDetails(m_signatureInfo));
	connect(signatureMessage, &KMessageWidget::linkActivated, this, [this](const QString &link) {
	m_urlHandler->handleClick(QUrl(link), window()->windowHandle());
	});
	signatureMessage->setMessageType(getType(m_signatureSecurityLevel));
	switch (m_signatureSecurityLevel) {
	case PartModel::Good:
	signatureMessage->setIcon(QIcon::fromTheme(QStringLiteral("mail-signed")));
	break;
	case PartModel::Bad:
	signatureMessage->setIcon(QIcon::fromTheme(QStringLiteral("data-error")));
	break;
	case PartModel::NotSoGood:
	signatureMessage->setIcon(QIcon::fromTheme(QStringLiteral("data-warning")));
	break;
	default:
	break;
	}
	signatureMessage->setWordWrap(true);

	vLayout->addWidget(signatureMessage);
	}
	}

	#include "moc_messagecontainerwidget_p.cpp"
	diff --git a/src/widgets/messageviewerdialog.cpp b/src/widgets/messageviewerdialog.cpp
	index ee89ce7..f086aa1 100644
	--- a/src/widgets/messageviewerdialog.cpp
	+++ b/src/widgets/messageviewerdialog.cpp
	@@ -1,365 +1,365 @@
	// SPDX-FileCopyrightText: 2023 g10 Code GmbH
	// SPDX-FileContributor: Carl Schwan <carl.schwan@gnupg.com>
	// SPDX-License-Identifier: GPL-2.0-or-later

	#include "messageviewerdialog.h"

	#include "messageviewer.h"
	#include <MimeTreeParserCore/CryptoHelper>
	#include <MimeTreeParserCore/FileOpener>

	#include <KLocalizedString>
	#include <KMessageBox>
	#include <KMessageWidget>

	#include <QDialogButtonBox>
	#include <QFileDialog>
	#include <QMenuBar>
	#include <QPainter>
	#include <QPrintDialog>
	#include <QPrintPreviewDialog>
	#include <QPrinter>
	#include <QPushButton>
	#include <QRegularExpression>
	#include <QSaveFile>
	#include <QStandardPaths>
	#include <QStyle>
	#include <QToolBar>
	#include <QVBoxLayout>

	using namespace MimeTreeParser::Widgets;

	namespace
	{

	inline QString changeExtension(const QString &fileName, const QString &extension)
	{
	auto renamedFileName = fileName;
	renamedFileName.replace(QRegularExpression(QStringLiteral("\\.(mbox\|p7m\|asc)$")), extension);

	// In case the file name didn't contain any of the expected extension: mbox, p7m, asc and eml
	// or doesn't contains an extension at all.
	if (!renamedFileName.endsWith(extension)) {
	renamedFileName += extension;
	}

	return renamedFileName;
	}

	#define SLASHES "/\\"

	inline QString changeFileName(const QString &fileName, const QString &subject)
	{
	if (subject.isEmpty()) {
	return fileName;
	}

	if (fileName.isEmpty()) {
	return subject;
	}

	auto cleanedSubject = subject;

	static const char notAllowedChars[] = ",^@={}[]~!?:&*\"\|#%<>$\"'();`'/\\.";
	static const char *notAllowedSubStrings[] = {"..", " "};

	for (const char c = notAllowedChars; c; c++) {
	cleanedSubject.replace(QLatin1Char(*c), QStringLiteral(" "));
	}

	const int notAllowedSubStringCount = sizeof(notAllowedSubStrings) / sizeof(const char *);
	for (int s = 0; s < notAllowedSubStringCount; s++) {
	const QLatin1StringView notAllowedSubString(notAllowedSubStrings[s]);
	cleanedSubject.replace(notAllowedSubString, QStringLiteral(" "));
	}

	QStringList splitedFileName = fileName.split(QLatin1Char('/'));
	splitedFileName[splitedFileName.count() - 1] = cleanedSubject;
	return splitedFileName.join(QLatin1Char('/'));
	}
	}

	class MessageViewerDialog::Private
	{
	public:
	Private(MessageViewerDialog *dialog)
	: q(dialog)
	{
	}

	MessageViewerDialog *const q;
	int currentIndex = 0;
	QList<KMime::Message::Ptr> messages;
	QString fileName;
	MimeTreeParser::Widgets::MessageViewer *messageViewer = nullptr;
	QAction *nextAction = nullptr;
	QAction *previousAction = nullptr;
	QToolBar *toolBar = nullptr;

	void setCurrentIndex(int currentIndex);
	QMenuBar createMenuBar(QWidget parent);

	private:
	void save(QWidget *parent);
	void saveDecrypted(QWidget *parent);
	void print(QWidget *parent);
	void printPreview(QWidget *parent);
	void printInternal(QPrinter *printer);
	};

	void MessageViewerDialog::Private::setCurrentIndex(int index)
	{
	Q_ASSERT(index >= 0);
	Q_ASSERT(index < messages.count());

	currentIndex = index;
	messageViewer->setMessage(messages[currentIndex]);
	q->setWindowTitle(messageViewer->subject());

	previousAction->setEnabled(currentIndex != 0);
	nextAction->setEnabled(currentIndex != messages.count() - 1);
	}

	QMenuBar MessageViewerDialog::Private::createMenuBar(QWidget parent)
	{
	const auto menuBar = new QMenuBar(parent);

	// File menu
	const auto fileMenu = menuBar->addMenu(i18nc("@action:inmenu", "&File"));

	const auto saveAction = new QAction(QIcon::fromTheme(QStringLiteral("document-save")), i18nc("@action:inmenu", "&Save"));
	QObject::connect(saveAction, &QAction::triggered, parent, [parent, this] {
	save(parent);
	});
	fileMenu->addAction(saveAction);

	const auto saveDecryptedAction = new QAction(QIcon::fromTheme(QStringLiteral("document-save")), i18nc("@action:inmenu", "Save Decrypted"));
	QObject::connect(saveDecryptedAction, &QAction::triggered, parent, [parent, this] {
	saveDecrypted(parent);
	});
	fileMenu->addAction(saveDecryptedAction);

	const auto printPreviewAction = new QAction(QIcon::fromTheme(QStringLiteral("document-print-preview")), i18nc("@action:inmenu", "Print Preview"));
	QObject::connect(printPreviewAction, &QAction::triggered, parent, [parent, this] {
	printPreview(parent);
	});
	fileMenu->addAction(printPreviewAction);

	const auto printAction = new QAction(QIcon::fromTheme(QStringLiteral("document-print")), i18nc("@action:inmenu", "&Print"));
	QObject::connect(printAction, &QAction::triggered, parent, [parent, this] {
	print(parent);
	});
	fileMenu->addAction(printAction);

	// Navigation menu
	const auto navigationMenu = menuBar->addMenu(i18nc("@action:inmenu", "&Navigation"));
	previousAction = new QAction(QIcon::fromTheme(QStringLiteral("go-previous")), i18nc("@action:button Previous email", "Previous Message"), parent);
	previousAction->setEnabled(false);
	navigationMenu->addAction(previousAction);

	nextAction = new QAction(QIcon::fromTheme(QStringLiteral("go-next")), i18nc("@action:button Next email", "Next Message"), parent);
	nextAction->setEnabled(false);
	navigationMenu->addAction(nextAction);

	return menuBar;
	}

	void MessageViewerDialog::Private::save(QWidget *parent)
	{
	QString extension;
	QString alternatives;
	auto message = messages[currentIndex];
	bool wasEncrypted = false;
	GpgME::Protocol protocol;
	auto decryptedMessage = CryptoUtils::decryptMessage(message, wasEncrypted, protocol);
	Q_UNUSED(decryptedMessage); // we save the message without modifying it

	if (wasEncrypted) {
	extension = QStringLiteral(".mime");
	if (protocol == GpgME::OpenPGP) {
	alternatives = i18nc("File dialog accepted files", "Email files (.eml .mbox *.mime)");
	} else {
	alternatives = i18nc("File dialog accepted files", "Encrypted S/MIME files (*.p7m)");
	}
	} else {
	extension = QStringLiteral(".eml");
	alternatives = i18nc("File dialog accepted files", "Email files (.eml .mbox *.mime)");
	}

	const QString location = QFileDialog::getSaveFileName(parent,
	i18nc("@title:window", "Save File"),
	changeExtension(changeFileName(fileName, messageViewer->subject()), extension),
	alternatives);

	QSaveFile file(location);
	if (!file.open(QIODevice::WriteOnly)) {
	KMessageBox::error(parent, i18n("File %1 could not be created.", location), i18n("Error saving message"));
	return;
	}
	file.write(messages[currentIndex]->encodedContent());
	file.commit();
	}

	void MessageViewerDialog::Private::saveDecrypted(QWidget *parent)
	{
	const QString location = QFileDialog::getSaveFileName(parent,
	i18nc("@title:window", "Save Decrypted File"),
	changeExtension(changeFileName(fileName, messageViewer->subject()), QStringLiteral(".eml")),
	i18nc("File dialog accepted files", "Email files (.eml .mbox *.mime)"));

	QSaveFile file(location);
	if (!file.open(QIODevice::WriteOnly)) {
	KMessageBox::error(parent, i18nc("Error message", "File %1 could not be created.", location), i18n("Error saving message"));
	return;
	}
	auto message = messages[currentIndex];
	bool wasEncrypted = false;
	GpgME::Protocol protocol;
	auto decryptedMessage = CryptoUtils::decryptMessage(message, wasEncrypted, protocol);
	if (!wasEncrypted) {
	decryptedMessage = message;
	}
	file.write(decryptedMessage->encodedContent());

	file.commit();
	}

	void MessageViewerDialog::Private::print(QWidget *parent)
	{
	QPrinter printer;
	QPrintDialog dialog(&printer, parent);
	- dialog.setWindowTitle(i18nc("@title:window", "Print Document"));
	+ dialog.setWindowTitle(i18nc("@title:window", "Print"));
	if (dialog.exec() != QDialog::Accepted)
	return;

	printInternal(&printer);
	}

	void MessageViewerDialog::Private::printPreview(QWidget *parent)
	{
	auto dialog = new QPrintPreviewDialog(parent);
	dialog->setAttribute(Qt::WA_DeleteOnClose);
	dialog->resize(800, 750);
	- dialog->setWindowTitle(i18nc("@title:window", "Print Document"));
	+ dialog->setWindowTitle(i18nc("@title:window", "Print Preview"));
	QObject::connect(dialog, &QPrintPreviewDialog::paintRequested, parent, [this](QPrinter *printer) {
	printInternal(printer);
	});
	dialog->open();
	}

	void MessageViewerDialog::Private::printInternal(QPrinter *printer)
	{
	QPainter painter;
	painter.begin(printer);
	const auto pageLayout = printer->pageLayout();
	const auto pageRect = pageLayout.paintRectPixels(printer->resolution());
	const double xscale = pageRect.width() / double(messageViewer->width());
	const double yscale = pageRect.height() / double(messageViewer->height());
	const double scale = qMin(qMin(xscale, yscale), 1.);
	painter.translate(pageRect.x(), pageRect.y());
	painter.scale(scale, scale);
	messageViewer->print(&painter, pageRect.width());
	}

	MessageViewerDialog::MessageViewerDialog(const QList<KMime::Message::Ptr> &messages, QWidget *parent)
	: QDialog(parent)
	, d(std::make_unique<Private>(this))
	{
	d->messages += messages;
	initGUI();
	}

	MessageViewerDialog::MessageViewerDialog(const QString &fileName, QWidget *parent)
	: QDialog(parent)
	, d(std::make_unique<Private>(this))
	{
	d->fileName = fileName;
	d->messages += MimeTreeParser::Core::FileOpener::openFile(fileName);
	initGUI();
	}

	void MessageViewerDialog::initGUI()
	{
	const auto mainLayout = new QVBoxLayout(this);
	mainLayout->setContentsMargins({});
	mainLayout->setSpacing(0);

	const auto layout = new QVBoxLayout;

	const auto menuBar = d->createMenuBar(this);
	mainLayout->setMenuBar(menuBar);

	if (d->messages.isEmpty()) {
	auto errorMessage = new KMessageWidget(this);
	errorMessage->setMessageType(KMessageWidget::Error);
	errorMessage->setText(i18nc("@info", "Unable to read file"));
	layout->addWidget(errorMessage);
	return;
	}

	const bool multipleMessages = d->messages.length() > 1;
	d->toolBar = new QToolBar(this);

	if (multipleMessages) {
	#ifdef Q_OS_UNIX
	d->toolBar->setToolButtonStyle(Qt::ToolButtonFollowStyle);
	#else
	// on other platforms the default is IconOnly which is bad for
	// accessibility and can't be changed by the user.
	d->toolBar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
	#endif

	d->toolBar->addAction(d->previousAction);
	connect(d->previousAction, &QAction::triggered, this, [this] {
	d->setCurrentIndex(d->currentIndex - 1);
	});

	const auto spacer = new QWidget(this);
	spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
	d->toolBar->addWidget(spacer);

	d->toolBar->addAction(d->nextAction);
	connect(d->nextAction, &QAction::triggered, this, [this] {
	d->setCurrentIndex(d->currentIndex + 1);
	});
	d->nextAction->setEnabled(true);

	mainLayout->addWidget(d->toolBar);
	} else {
	mainLayout->addWidget(d->toolBar);
	d->toolBar->hide();
	}

	mainLayout->addLayout(layout);

	d->messageViewer = new MimeTreeParser::Widgets::MessageViewer(this);
	d->messageViewer->setMessage(d->messages[0]);
	setWindowTitle(d->messageViewer->subject());
	layout->addWidget(d->messageViewer);

	auto buttonBox = new QDialogButtonBox(this);
	buttonBox->setContentsMargins(style()->pixelMetric(QStyle::PM_LayoutLeftMargin, nullptr, this),
	style()->pixelMetric(QStyle::PM_LayoutTopMargin, nullptr, this),
	style()->pixelMetric(QStyle::PM_LayoutRightMargin, nullptr, this),
	style()->pixelMetric(QStyle::PM_LayoutBottomMargin, nullptr, this));
	auto closeButton = buttonBox->addButton(QDialogButtonBox::Close);
	connect(closeButton, &QPushButton::pressed, this, &QDialog::accept);
	layout->addWidget(buttonBox);

	setMinimumSize(300, 300);
	resize(600, 600);
	}

	MessageViewerDialog::~MessageViewerDialog() = default;

	QToolBar *MessageViewerDialog::toolBar() const
	{
	return d->toolBar;
	}

	QList<KMime::Message::Ptr> MessageViewerDialog::messages() const
	{
	return d->messages;
	}

	#include "moc_messageviewerdialog.cpp"

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jul 17, 12:51 AM (1 d, 6 h)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 6d/79/64116d49e6551af2f97326e4bf69

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions