nodehelper.h

Go to the documentation of this file.

/* -*- mode: C++; c-file-style: "gnu" -*-
  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 _MESSAGEVIEWER_NODEHELPER_H
#define _MESSAGEVIEWER_NODEHELPER_H
#include "messageviewer_export.h"

#include "partmetadata.h"

#include <KMime/Message>

#include <KIconLoader>

#include <QList>
#include <QMap>
#include <QSet>

class KUrl;
class QTextCodec;

namespace MessageViewer {
  namespace Interface {
    class BodyPartMemento;
  }
}

namespace PimCommon
{
class AttachmentTemporaryFilesDirs;

}
namespace MessageViewer {

typedef enum
{
    KMMsgEncryptionStateUnknown=' ',
    KMMsgNotEncrypted='N',
    KMMsgPartiallyEncrypted='P',
    KMMsgFullyEncrypted='F',
    KMMsgEncryptionProblematic='X'
} KMMsgEncryptionState;

typedef enum
{
    KMMsgSignatureStateUnknown=' ',
    KMMsgNotSigned='N',
    KMMsgPartiallySigned='P',
    KMMsgFullySigned='F',
    KMMsgSignatureProblematic='X'
} KMMsgSignatureState;


class MESSAGEVIEWER_EXPORT NodeHelper {
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( KMime::Content* node, const KMMsgEncryptionState state );
    KMMsgEncryptionState encryptionState( KMime::Content *node ) const;

    void setSignatureState( KMime::Content* node, const KMMsgSignatureState state );
    KMMsgSignatureState signatureState( 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 );

    static QString iconName( KMime::Content *node, int size = KIconLoader::Desktop );

    void magicSetType( KMime::Content *node, bool autoDecode=true );


    static QString cleanSubject( KMime::Message *message );

    void attachExtraContent( KMime::Content *topLevelNode, KMime::Content* content );
    void removeAllExtraContent( KMime::Content *topLevelNode );

    QList<KMime::Content*> extraContents( KMime::Content *topLevelNode ) const;

    KMime::Message *messageWithExtraContent( KMime::Content* topLevelNode );

    bool isPermanentWithExtraContent( KMime::Content* node ) const;

    const QTextCodec * codec( KMime::Content* node );

    void setOverrideCodec( KMime::Content* node, const QTextCodec* codec );

    const QTextCodec * localCodec() const { return mLocalCodec;}

    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 );

    QString writeNodeToTempFile( KMime::Content* node );

    KUrl tempFileUrlFromNode( const KMime::Content *node );

    QString createTempDir( const QString &param = QString() );

    void removeTempFiles();

    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 );

    static bool isToltecMessage( KMime::Content* node );

    static bool isInEncapsulatedMessage( KMime::Content* node );

    static QByteArray charset( KMime::Content *node );

    static QString replacePrefixes( const QString& str,
                                  const QStringList& prefixRegExps,
                                  bool replace,
                                  const QString& newPrefix );

    static const QTextCodec* codecForName(const QByteArray& _str);

    static QString fileName( const KMime::Content *node );

    static QString fixEncoding( const QString &encoding ); //TODO(Andras) move to a utility class?

    static QString encodingForName( const QString &descriptiveName ); //TODO(Andras) move to a utility class?

    static QStringList supportedEncodings( bool usAscii ); //TODO(Andras) move to a utility class?

    static QByteArray autoDetectCharset(const QByteArray &_encoding, const QStringList &encodingList, const QString &text);
    static QByteArray toUsAscii(const QString& _str, bool *ok);

    static QString fromAsString( KMime::Content* node );

    struct AttachmentDisplayInfo
    {
      QString label;
      QString icon;
      bool displayInHeader;
    };

    static AttachmentDisplayInfo attachmentDisplayInfo( KMime::Content *node );

    KMime::Content * decryptedNodeForContent( KMime::Content * content ) const;

    KMime::Message::Ptr unencryptedMessage( const KMime::Message::Ptr &originalMessage );

private:

    bool unencryptedMessage_helper( KMime::Content *node, QByteArray &resultingData, bool addHeaders,
                                    int recursionLevel = 1 );

    static QString cleanSubject( KMime::Message *message, const QStringList& prefixRegExps,
                                 bool replace, const QString& newPrefix );

    void mergeExtraNodes( KMime::Content *node );
    void cleanFromExtraNodes( KMime::Content *node );

    QString persistentIndex( const KMime::Content * node ) const;

private:
    QList<KMime::Content*> mProcessedNodes;
    QList<KMime::Content*> mNodesUnderProcess;
    QMap<KMime::Content *, KMMsgEncryptionState> mEncryptionState;
    QMap<KMime::Content *, KMMsgSignatureState> mSignatureState;
    QSet<KMime::Content *> mDisplayEmbeddedNodes;
    QSet<KMime::Content *> mDisplayHiddenNodes;
    QTextCodec *mLocalCodec;
    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;
    PimCommon::AttachmentTemporaryFilesDirs *mAttachmentFilesDir;
};

}

#endif