kmime_content.h

Go to the documentation of this file.

/*
    kmime_content.h

    KMime, the KDE Internet mail/usenet news message library.
    Copyright (c) 2001 the KMime authors.
    See file AUTHORS for details
    Copyright (c) 2006 Volker Krause <vkrause@kde.org>
    Copyright (c) 2009 Constantin Berzan <exit3219@gmail.com>

    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 __KMIME_CONTENT_H__
#define __KMIME_CONTENT_H__

#include "kmime_export.h"
#include "kmime_contentindex.h"
#include "kmime_util.h"
#include "kmime_headers.h"

#include <QtCore/QTextStream>
#include <QtCore/QByteArray>
#include <QtCore/QList>

#include <boost/shared_ptr.hpp>


namespace KMime {

class ContentPrivate;
class Message;

/*
  KDE5:
  * Do not convert singlepart <-> multipart automatically.
  * A bunch of methods probably don't need to be virtual (since they're not needed
    in either Message or NewsArticle).
*/
class KMIME_EXPORT Content
{
  public:

    typedef QList<KMime::Content*> List;

    Content();

    explicit Content( Content* parent ); // KDE5: Merge with the above.

    Content( const QByteArray &head, const QByteArray &body );

    // KDE5: Merge with the above.
    Content( const QByteArray &head, const QByteArray &body, Content *parent );

    virtual ~Content();

    bool hasContent() const;

    void setContent( const QList<QByteArray> &l );

    void setContent( const QByteArray &s );

    virtual void parse();

    bool isFrozen() const;

    void setFrozen( bool frozen = true );

    virtual void assemble();

    // KDE5: make non-virtual.
    virtual void clear();

    void clearContents( bool del = true );

    QByteArray head() const;

    void setHead( const QByteArray &head );

    KMIME_DEPRECATED Headers::Generic *getNextHeader( QByteArray &head );

    // KDE5: Remove this. This method has nothing to do with *this object.
    KMIME_DEPRECATED Headers::Generic *nextHeader( QByteArray &head );

    // KDE5: Make non-virtual.
    KMIME_DEPRECATED virtual Headers::Base *getHeaderByType( const char *type );

    // KDE5: Make non-virtual.
    virtual Headers::Base *headerByType( const char *type );

    template <typename T> T *header( bool create = false );

    virtual QList<Headers::Base*> headersByType( const char *type );

    // KDE5: make non-virtual.
    virtual void setHeader( Headers::Base *h );

    void appendHeader( Headers::Base *h );

    void prependHeader( Headers::Base *h );

    // TODO probably provide removeHeader<T>() too.
    // KDE5: make non-virtual.
    virtual bool removeHeader( const char *type );

    // TODO probably provide hasHeader<T>() too.
    // TODO: KDE5: make const
    bool hasHeader( const char *type );

    Headers::ContentType *contentType( bool create = true );

    Headers::ContentTransferEncoding *contentTransferEncoding( bool create = true );

    Headers::ContentDisposition *contentDisposition( bool create = true );

    Headers::ContentDescription *contentDescription( bool create = true );

    Headers::ContentLocation *contentLocation( bool create = true );

    Headers::ContentID *contentID( bool create = true );

    int size();

    int storageSize() const;

    int lineCount() const;

    QByteArray body() const;

    void setBody( const QByteArray &body );

    QByteArray preamble() const;

    void setPreamble( const QByteArray &preamble );

    QByteArray epilogue() const;

    void setEpilogue( const QByteArray &epilogue );

    QByteArray encodedContent( bool useCrLf = false );

    QByteArray encodedBody();

    // TODO: KDE5: BIC: Rename this to decodedBody(), since only the body is returned.
    // In contrast, setContent() sets the head and the body!
    // Also, try to make this const.
    QByteArray decodedContent();

    // TODO: KDE5: BIC: Convert to enums. Also, what if trimText = true but removeTrailingNewlines
    //                  is false?
    QString decodedText( bool trimText = false,
                         bool removeTrailingNewlines = false );

    void fromUnicodeString( const QString &s );

    Content *textContent();

    List attachments( bool incAlternatives = false );

    List contents() const;

    // KDE5: Do not convert single-part->multipart automatically.
    void addContent( Content *content, bool prepend = false );

    void replaceContent(Content *oldContent, Content *newContent);
    // KDE5: Do not convert multipart->single-part automatically.
    void removeContent( Content *content, bool del = false );

    void changeEncoding( Headers::contentEncoding e );

    void toStream( QTextStream &ts, bool scrambleFromLines = false );

    // NOTE: The charset methods below are accessed by the headers which
    // have this Content as a parent.

    // TODO: Split this up into a charset for encoding and one for decoding, and make the one for
    //       encoding UTF-8 by default.
    QByteArray defaultCharset() const;

    void setDefaultCharset( const QByteArray &cs );

    bool forceDefaultCharset() const;

    virtual void setForceDefaultCharset( bool b );

    Content *content( const ContentIndex &index ) const;

    ContentIndex indexForContent( Content *content ) const;

    virtual bool isTopLevel() const;

    void setParent( Content *parent );

    Content* parent() const;

    Content* topLevel() const;

    ContentIndex index() const;

    //AK_REVIEW: move to MessageViewer/ObjectTreeParser
    bool bodyIsMessage() const;

    //AK_REVIEW: move to MessageViewer/ObjectTreeParser
    boost::shared_ptr<Message> bodyAsMessage() const;

  protected:
    virtual QByteArray assembleHeaders();

    KMIME_DEPRECATED QByteArray rawHeader( const char *name ) const;

    KMIME_DEPRECATED QList<QByteArray> rawHeaders( const char *name ) const;

    // KDE5: Not needed outside. Move to Private class.
    bool decodeText();

    template <class T> KMIME_DEPRECATED T *headerInstance( T *ptr, bool create );

    // KDE5: Not needed outside. Move to Private class.
    Headers::Base::List h_eaders;

    //@cond PRIVATE
    ContentPrivate *d_ptr;
    explicit Content( ContentPrivate *d );
    //@endcond

  private:
    Q_DECLARE_PRIVATE( Content )
    Q_DISABLE_COPY( Content )
};

// some compilers (for instance Compaq C++) need template inline functions
// here rather than in the *.cpp file

template <class T> T *Content::headerInstance( T */*ptr*/, bool create )
{
  return header<T>( create );
}

template <typename T> T *Content::header( bool create )
{
  Headers::Base *h = headerByType( T::staticType() );
  if ( h ) {
    // Make sure the header is actually of the right type.
    Q_ASSERT( dynamic_cast<T*>( h ) );
  } else if ( create ) {
    h = new T( this );
    setHeader( h );
  }
  return static_cast<T*>( h );
}

} // namespace KMime

#endif // __KMIME_CONTENT_H__