Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 861 insertions, 0 deletions

diff --git a/libkmime/kmime_headers.h b/libkmime/kmime_headers.h
new file mode 100644
index 000000000..779cd341a
--- /dev/null
+++ b/libkmime/kmime_headers.h
@@ -0,0 +1,861 @@
+/*  -*- c++ -*
+    kmime_headers.h
+
+    KMime, the KDE internet mail/usenet news message library.
+    Copyright (c) 2001-2002 the KMime authors.
+    See file AUTHORS for details
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License version 2.0 as
+    published by the Free Software Foundation.
+    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, US
+*/
+#ifndef __KMIME_HEADERS_H__
+#define __KMIME_HEADERS_H__
+
+// Content:
+//
+// - header's base class defining the common interface
+// - generic base classes for different types of fields
+// - incompatible, GStructured-based field classes
+// - compatible, GUnstructured-based field classes
+
+#include "kmime_header_parsing.h"
+
+#include <qstring.h>
+#include <qstrlist.h>
+#include <qstringlist.h>
+#include <qregexp.h>
+#include <qdatetime.h>
+#include <qasciidict.h>
+#include <qmap.h>
+#include <qptrlist.h>
+
+#include <time.h>
+
+#include <kdepimmacros.h>
+
+namespace KMime {
+
+//forward declaration
+class Content;
+
+namespace Headers {
+
+
+enum contentCategory    { CCsingle,
+                          CCcontainer,
+                          CCmixedPart,
+                          CCalternativePart };
+
+enum contentEncoding    { CE7Bit,
+                          CE8Bit,
+                          CEquPr,
+                          CEbase64,
+                          CEuuenc,
+                          CEbinary };
+
+enum contentDisposition { CDinline,
+                          CDattachment,
+                          CDparallel };
+
+//often used charset
+static const QCString Latin1("ISO-8859-1");
+
+#define mk_trivial_subclass_with_name( subclass, subclassName, baseclass ) \
+class subclass : public Generics::baseclass { \
+public: \
+  subclass() : Generics::baseclass() {} \
+  subclass( Content * p ) : Generics::baseclass( p ) {} \
+  subclass( Content * p, const QCString & s ) \
+    : Generics::baseclass( p ) { from7BitString( s ); } \
+  subclass( Content * p, const QString & s, const QCString & cs ) \
+    : Generics::baseclass( p ) { fromUnicodeString( s, cs ); } \
+  ~subclass() {} \
+  \
+  const char * type() const { return #subclassName; } \
+}
+ 
+#define mk_trivial_subclass( subclass, baseclass ) \
+mk_trivial_subclass_with_name( subclass, subclass, baseclass )
+
+#define mk_parsing_subclass_with_name( subclass, subclassName, baseclass ) \
+class subclass : public Generics::baseclass { \
+public: \
+  subclass() : Generics::baseclass() {} \
+  subclass( Content * p ) : Generics::baseclass( p ) {} \
+  subclass( Content * p, const QCString & s ) \
+    : Generics::baseclass( p ) { from7BitString( s ); } \
+  subclass( Content * p, const QString & s, const QCString & cs ) \
+    : Generics::baseclass( p ) { fromUnicodeString( s, cs ); } \
+  ~subclass() {} \
+  \
+  const char * type() const { return #subclassName; } \
+protected: \
+  bool parse( const char* & scursor, const char * const send, bool isCRLF=false ); \
+}
+
+#define mk_parsing_subclass( subclass, baseclass ) \
+mk_parsing_subclass_with_name( subclass, subclass, baseclass )
+
+//
+//
+// HEADER'S BASE CLASS. DEFINES THE COMMON INTERFACE
+//
+//
+
+/** Baseclass of all header-classes. It represents a
+    header-field as described in RFC-822.  */
+class KDE_EXPORT Base {
+
+  public:
+    typedef QPtrList<Base> List;
+
+    /** Create an empty header. */
+    Base() : e_ncCS(0), p_arent(0) {}
+
+    /** Create an empty header with a parent-content. */
+    Base(KMime::Content *parent) : e_ncCS(0), p_arent(parent) {}
+
+    /** Destructor */
+    virtual ~Base()  {}
+
+    /** Return the parent of this header. */
+    KMime::Content* parent()  { return p_arent; }
+
+    /** Set the parent for this header. */
+    void setParent(KMime::Content *p)  { p_arent=p; }
+
+    /** Parse the given string. Take care of RFC2047-encoded
+	strings. A default charset is given. If the last parameter
+	is true the default charset is used in any case */
+    virtual void from7BitString(const QCString&)  {}
+
+    /** Return the encoded header. The parameter specifies
+	whether the header-type should be included. */
+    virtual QCString as7BitString(bool=true)  { return QCString(); }
+
+    /** Return the charset that is used for RFC2047-encoding */
+    QCString rfc2047Charset();
+
+    /** Set the charset for RFC2047-encoding */
+    void setRFC2047Charset(const QCString &cs);
+
+    /** Return the default charset */
+    QCString defaultCS();
+
+    /** Return if the default charset is mandatory */
+    bool forceCS();
+
+    /** Parse the given string and set the charset. */
+    virtual void fromUnicodeString(const QString&, const QCString&)  {}
+
+    /** Return the decoded content of the header without
+       the header-type. */
+    virtual QString asUnicodeString()  { return QString(); }
+
+    /** Delete */
+    virtual void clear()  {}
+
+    /** Do we have data? */
+    virtual bool isEmpty()  { return false; }
+
+    /** Return the type of this header (e.g. "From") */
+    virtual const char* type()  { return ""; }
+
+    /** Check if this header is of type t. */
+    bool is(const char* t)  { return (strcasecmp(t, type())==0); }
+
+    /** Check if this header is a MIME header */
+    bool isMimeHeader()  { return (strncasecmp(type(), "Content-", 8)==0); }
+
+    /** Check if this header is a X-Header */
+    bool isXHeader()  { return (strncmp(type(), "X-", 2)==0); }
+
+  protected:
+    QCString typeIntro()  { return (QCString(type())+": "); }
+
+    const char *e_ncCS;
+    Content *p_arent;
+
+};
+
+
+//
+//
+// GENERIC BASE CLASSES FOR DIFFERENT TYPES OF FIELDS
+//
+//
+
+namespace Generics {
+
+/** Abstract base class for unstructured header fields
+    (e.g. "Subject", "Comment", "Content-description").
+    
+    Features: Decodes the header according to RFC2047, incl. RFC2231
+    extensions to encoded-words.
+
+    Subclasses need only re-implement @p const @p char* @p type().
+
+    A macro to automate this is named
+\code
+    MK_TRIVIAL_GUnstructured_SUBCLASS(classname,headername);
+\endcode
+
+    The ContentDescription class then reads:
+\code
+    MK_TRIVIAL_GUnstructured_SUBCLASS(ContentDescription,Content-Description);
+\endcode
+*/
+
+  // known issues:
+  // - uses old decodeRFC2047String function, instead of our own...
+
+class KDE_EXPORT GUnstructured : public Base {
+
+public:
+  GUnstructured() : Base()  {}
+  GUnstructured( Content * p ) : Base( p ) {}
+  GUnstructured( Content * p, const QCString & s )
+    : Base( p ) { from7BitString(s); }
+  GUnstructured( Content * p, const QString & s, const QCString & cs )
+    : Base( p )  { fromUnicodeString( s, cs ); }
+  ~GUnstructured()  {}
+
+  virtual void from7BitString( const QCString& str );
+  virtual QCString as7BitString( bool withHeaderType=true );
+
+  virtual void fromUnicodeString( const QString & str,
+				  const QCString & suggestedCharset);
+  virtual QString asUnicodeString();
+
+  virtual void clear()            { d_ecoded.truncate(0); }
+  virtual bool isEmpty()          { return (d_ecoded.isEmpty()); }
+
+private:
+  QString d_ecoded;
+};
+
+/** This is the base class for all structured header fields. It
+    contains parsing methods for all basic token types found in
+    rfc2822.
+
+    @section Parsing
+
+    At the basic level, there are tokens & tspecials (rfc2045),
+    atoms & specials, quoted-strings, domain-literals (all rfc822) and
+    encoded-words (rfc2047).
+
+    As a special token, we have the comment. It is one of the basic
+    tokens defined in rfc822, but it's parsing relies in part on the
+    basic token parsers (e.g. comments may contain encoded-words).
+    Also, most upper-level parsers (notably those for phrase and
+    dot-atom) choose to ignore any comment when parsing.
+
+    Then there are the real composite tokens, which are made up of one
+    or more of the basic tokens (and semantically invisible comments):
+    phrases (rfc822 with rfc2047) and dot-atoms (rfc2822).
+    
+    This finishes the list of supported token types. Subclasses will
+    provide support for more higher-level tokens, where necessary,
+    using these parsers.
+
+    @short Base class for structured header fields.
+    @author Marc Mutz <mutz@kde.org>
+*/
+
+class KDE_EXPORT GStructured : public Base {
+public:
+  GStructured() : Base()  {}
+  GStructured( Content * p ) : Base( p ) {}
+  GStructured( Content * p, const QCString & s )
+    : Base( p ) { from7BitString(s); }
+  GStructured( Content * p, const QString & s, const QCString & cs )
+    : Base( p )  { fromUnicodeString( s, cs ); }
+  ~GStructured()  {}
+
+  
+protected:
+#if 0
+  // the assembly squad:
+
+  bool writeAtom( char* & dcursor, const char * const dend, const QString & input );
+  bool writeAtom( char* & dcursor, const char * const dend,
+		  const QPair<const char*,int> & input );
+  bool writeToken( char* & dcursor, const char * const dend, const QString & input );
+  bool writeToken( char* & dcursor, const char * const dend,
+		   const QPair<const char*int> & input );
+
+  bool writeGenericQuotedString( char* & dcursor, const char * const dend,
+				 const QString & input, bool withCRLF=false );
+  bool writeComment( char* & dcursor, const char * const dend,
+		     const QString & input, bool withCRLF=false );
+  bool writePhrase( char* & dcursor, const char * const dend,
+		    const QString & input, bool withCRLF=false );
+  bool writeDotAtom( char* & dcursor, const char * const dend,
+		     const QString & input, bool withCRLF=false );
+#endif
+};
+
+
+class KDE_EXPORT GAddress : public GStructured {
+public:
+  GAddress() : GStructured()  {}
+  GAddress( Content * p ) : GStructured( p ) {}
+  GAddress( Content * p, const QCString & s )
+    : GStructured( p ) { from7BitString(s); }
+  GAddress( Content * p, const QString & s, const QCString & cs )
+    : GStructured( p )  { fromUnicodeString( s, cs ); }
+  ~GAddress()  {}
+
+protected:
+};
+
+
+/** Base class for headers that deal with (possibly multiple)
+    addresses, but don't allow groups: */
+class KDE_EXPORT MailboxList : public GAddress {
+public:
+  MailboxList() : GAddress()  {}
+  MailboxList( Content * p ) : GAddress( p ) {}
+  MailboxList( Content * p, const QCString & s )
+    : GAddress( p ) { from7BitString(s); }
+  MailboxList( Content * p, const QString & s, const QCString & cs )
+    : GAddress( p )  { fromUnicodeString( s, cs ); }
+  ~MailboxList()  {}
+
+protected:
+  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+
+  /** The list of mailboxes */
+  QValueList<Types::Mailbox> mMailboxList;
+};
+
+
+/** Base class for headers that deal with exactly one mailbox
+    (e.g. Sender) */
+mk_parsing_subclass(SingleMailbox,MailboxList);
+
+/** Base class for headers that deal with (possibly multiple)
+    addresses, allowing groups. */
+class KDE_EXPORT AddressList : public GAddress {
+public:
+  AddressList() : GAddress()  {}
+  AddressList( Content * p ) : GAddress( p ) {}
+  AddressList( Content * p, const QCString & s )
+    : GAddress( p ) { from7BitString(s); }
+  AddressList( Content * p, const QString & s, const QCString & cs )
+    : GAddress( p )  { fromUnicodeString( s, cs ); }
+  ~AddressList()  {}
+
+protected:
+  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+
+  /** The list of addresses */
+  QValueList<Types::Address> mAddressList;
+};
+
+/** Base class for headers which deal with a list of msg-id's */
+class KDE_EXPORT GIdent : public GAddress {
+public:
+  GIdent() : GAddress()  {}
+  GIdent( Content * p ) : GAddress( p ) {}
+  GIdent( Content * p, const QCString & s )
+    : GAddress( p ) { from7BitString(s); }
+  GIdent( Content * p, const QString & s, const QCString & cs )
+    : GAddress( p )  { fromUnicodeString( s, cs ); }
+  ~GIdent()  {}
+
+protected:
+  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+
+  /** The list of msg-id's */
+  QValueList<Types::AddrSpec> mMsgIdList;
+};
+
+/** Base class for headers which deal with a list of msg-id's */
+mk_parsing_subclass(GSingleIdent,GIdent);
+
+/** Base class for headers which deal with a single atom. */
+class KDE_EXPORT GToken : public GStructured {
+public:
+  GToken() : GStructured()  {}
+  GToken( Content * p ) : GStructured( p ) {}
+  GToken( Content * p, const QCString & s )
+    : GStructured( p ) { from7BitString(s); }
+  GToken( Content * p, const QString & s, const QCString & cs )
+    : GStructured( p )  { fromUnicodeString( s, cs ); }
+  ~GToken()  {}
+
+protected:
+  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+
+  QCString mToken;
+};
+
+
+class KDE_EXPORT GPhraseList : public GStructured {
+public:
+  GPhraseList() : GStructured()  {}
+  GPhraseList( Content * p ) : GStructured( p ) {}
+  GPhraseList( Content * p, const QCString & s )
+    : GStructured( p ) { from7BitString(s); }
+  GPhraseList( Content * p, const QString & s, const QCString & cs )
+    : GStructured( p )  { fromUnicodeString( s, cs ); }
+  ~GPhraseList()  {}
+
+protected:
+  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+
+  QStringList mPhraseList;
+};
+
+class KDE_EXPORT GDotAtom : public GStructured {
+public:
+  GDotAtom() : GStructured()  {}
+  GDotAtom( Content * p ) : GStructured( p ) {}
+  GDotAtom( Content * p, const QCString & s )
+    : GStructured( p ) { from7BitString(s); }
+  GDotAtom( Content * p, const QString & s, const QCString & cs )
+    : GStructured( p )  { fromUnicodeString( s, cs ); }
+  ~GDotAtom()  {}
+
+protected:
+  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+
+  QString mDotAtom;
+};
+
+class KDE_EXPORT GParametrized : public GStructured {
+public:
+  GParametrized() : GStructured()  {}
+  GParametrized( Content * p ) : GStructured( p ) {}
+  GParametrized( Content * p, const QCString & s )
+    : GStructured( p ) { from7BitString(s); }
+  GParametrized( Content * p, const QString & s, const QCString & cs )
+    : GStructured( p )  { fromUnicodeString( s, cs ); }
+  ~GParametrized()  {}
+
+protected:
+  QMap<QString,QString> mParameterHash;
+
+private:
+};
+
+class KDE_EXPORT GContentType : public GParametrized {
+public:
+  GContentType() : GParametrized()  {}
+  GContentType( Content * p ) : GParametrized( p ) {}
+  GContentType( Content * p, const QCString & s )
+    : GParametrized( p ) { from7BitString(s); }
+  GContentType( Content * p, const QString & s, const QCString & cs )
+    : GParametrized( p )  { fromUnicodeString( s, cs ); }
+  ~GContentType()  {}
+
+protected:
+  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+
+  QCString mMimeType;
+  QCString mMimeSubType;
+};
+
+
+class KDE_EXPORT GCISTokenWithParameterList : public GParametrized {
+public:
+  GCISTokenWithParameterList() : GParametrized()  {}
+  GCISTokenWithParameterList( Content * p ) : GParametrized( p ) {}
+  GCISTokenWithParameterList( Content * p, const QCString & s )
+    : GParametrized( p ) { from7BitString(s); }
+  GCISTokenWithParameterList( Content * p, const QString & s, const QCString & cs )
+    : GParametrized( p )  { fromUnicodeString( s, cs ); }
+  ~GCISTokenWithParameterList()  {}
+
+protected:
+  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+
+  QCString mToken;
+};
+
+
+} // namespace Generics
+
+//
+//
+// INCOMPATIBLE, GSTRUCTURED-BASED FIELDS:
+//
+//
+
+
+/** Represents the Return-Path header field. */
+class KDE_EXPORT ReturnPath : public Generics::GAddress {
+public:
+  ReturnPath() : Generics::GAddress()  {}
+  ReturnPath( Content * p ) : Generics::GAddress( p ) {}
+  ReturnPath( Content * p, const QCString & s )
+    : Generics::GAddress( p ) { from7BitString(s); }
+  ReturnPath( Content * p, const QString & s, const QCString & cs )
+    : Generics::GAddress( p )  { fromUnicodeString( s, cs ); }
+  ~ReturnPath()  {}
+
+  const char * type() const { return "Return-Path"; }
+
+protected:
+  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
+};
+
+#if defined(KMIME_NEW_STYLE_CLASSTREE)
+// classes whose names collide with earlier ones:
+
+// GAddress et al.:
+
+// rfc(2)822 headers:
+mk_trivial_subclass(From,MailboxList);
+mk_trivial_subclass(Sender,SingleMailbox);
+mk_trivial_subclass_with_name(ReplyTo,Reply-To,AddressList);
+mk_trivial_subclass(Cc,AddressList);
+mk_trivial_subclass(Bcc,AddressList);
+// usefor headers:
+mk_trivial_subclass_with_name(MailCopiesTo,Mail-Copies-To,AddressList);
+
+// GToken:
+
+mk_trivial_subclass_with_name(ContentTransferEncoding,
+			      Content-Transfer-Encoding,GToken);
+
+// GPhraseList:
+
+mk_trivial_subclass(Keywords,GPhraseList);
+
+// GDotAtom:
+
+mk_trivial_subclass_with_name(MIMEVersion,MIME-Version,GDotAtom);
+
+// GIdent:
+
+mk_trivial_subclass_with_name(MessageID,Message-ID,GSingleIdent);
+mk_trivial_subclass_with_name(ContentID,Content-ID,GSingleIdent);
+mk_trivial_subclass(Supersedes,GSingleIdent);
+mk_trivial_subclass_with_name(InReplyTo,In-Reply-To,GIdent);
+mk_trivial_subclass(References,GIdent);
+
+// GContentType:
+
+mk_trivial_subclass_with_name(ContentType,ContentType,GContentType);
+
+// GCISTokenWithParameterList:
+
+mk_trivial_subclass_with_name(ContentDisposition,Content-Disposition,
+			      GCISTokenWithParameterList);
+
+
+#endif
+
+
+//
+//
+// COMPATIBLE GUNSTRUCTURED-BASED FIELDS:
+//
+//
+
+
+/** Represents an arbitrary header, that can contain
+    any header-field.
+    Adds a type over GUnstructured.
+    @see GUnstructured
+*/
+class KDE_EXPORT Generic : public Generics::GUnstructured {
+
+  public:
+    Generic() : Generics::GUnstructured(), t_ype(0) {}
+    Generic(const char *t)
+      : Generics::GUnstructured(), t_ype(0) { setType(t); }
+    Generic(const char *t, Content *p)
+      : Generics::GUnstructured( p ), t_ype(0) { setType(t); }
+    Generic(const char *t, Content *p, const QCString &s)
+      : Generics::GUnstructured( p, s ), t_ype(0) { setType(t); }
+    Generic(const char *t, Content *p, const QString &s, const QCString &cs)
+      : Generics::GUnstructured( p, s, cs ), t_ype(0) { setType(t); }
+    ~Generic() { delete[] t_ype; }
+
+    virtual void clear()            { delete[] t_ype; GUnstructured::clear(); }
+    virtual bool isEmpty()          { return (t_ype==0 || GUnstructured::isEmpty()); }
+    virtual const char* type()      { return t_ype; }
+    void setType(const char *type);
+
+  protected:
+    char *t_ype;
+
+};
+
+
+/** Represents a "Subject" header */
+class KDE_EXPORT Subject : public Generics::GUnstructured {
+
+  public:
+    Subject() : Generics::GUnstructured()  {}
+    Subject( Content * p ) : Generics::GUnstructured( p )  {}
+    Subject( Content * p, const QCString & s )
+      : Generics::GUnstructured( p, s ) {}
+    Subject( Content * p, const QString & s, const QCString & cs )
+      : Generics::GUnstructured( p, s, cs ) {}
+    ~Subject()  {}
+
+    virtual const char* type() { return "Subject"; }
+
+    bool isReply() {
+      return ( asUnicodeString().find( QString("Re:"), 0, false ) == 0 );
+    }
+};
+
+/** Represents a "Organization" header */
+class KDE_EXPORT Organization : public Generics::GUnstructured {
+
+  public:
+    Organization() : Generics::GUnstructured() {}
+    Organization( Content * p ) : Generics::GUnstructured( p ) {}
+    Organization( Content * p, const QCString & s )
+      : Generics::GUnstructured( p, s ) {};
+    Organization( Content * p, const QString & s, const QCString & cs)
+      : Generics::GUnstructured( p, s, cs ) {}
+    ~Organization()  {}
+
+    virtual const char* type()      { return "Organization"; }
+
+};
+
+//
+//
+// NOT YET CONVERTED STUFF BELOW:
+//
+//
+
+
+
+/** Represents a "Control" header */
+class KDE_EXPORT Control : public Base {
+
+  public:
+    Control() : Base()  {}
+    Control(Content *p) : Base(p)  {}
+    Control(Content *p, const QCString &s) : Base(p) { from7BitString(s); }
+    Control(Content *p, const QString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
+    ~Control()  {}
+
+    virtual void from7BitString(const QCString &s);
+    virtual QCString as7BitString(bool incType=true);
+    virtual void fromUnicodeString(const QString &s, const QCString&);
+    virtual QString asUnicodeString();
+    virtual void clear()            { c_trlMsg.truncate(0); }
+    virtual bool isEmpty()          { return (c_trlMsg.isEmpty()); }
+    virtual const char* type()      { return "Control"; }
+
+    bool isCancel()                 { return (c_trlMsg.find("cancel", 0, false)!=-1); }
+
+  protected:
+    QCString c_trlMsg;
+
+};
+
+/** Represents a "Date" header */
+class KDE_EXPORT Date : public Base {
+
+  public:
+    Date() : Base(), t_ime(0)  {}
+    Date(Content *p) : Base(p), t_ime(0)  {}
+    Date(Content *p, time_t t) : Base(p), t_ime(t)  {}
+    Date(Content *p, const QCString &s) : Base(p)  { from7BitString(s); }
+    Date(Content *p, const QString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
+    ~Date()  {}
+
+    virtual void from7BitString(const QCString &s);
+    virtual QCString as7BitString(bool incType=true);
+    virtual void fromUnicodeString(const QString &s, const QCString&);
+    virtual QString asUnicodeString();
+    virtual void clear()            { t_ime=0; }
+    virtual bool isEmpty()          { return (t_ime==0); }
+    virtual const char* type()      { return "Date"; }
+
+    time_t unixTime()               { return t_ime; }
+    void setUnixTime(time_t t)      { t_ime=t; }
+    void setUnixTime()              { t_ime=time(0); }
+    QDateTime qdt();
+    int ageInDays();
+    
+  protected:
+    time_t t_ime;
+
+};
+
+
+/** Represents a "Newsgroups" header */
+class KDE_EXPORT Newsgroups : public Base {
+
+  public:
+    Newsgroups() : Base()  {}
+    Newsgroups(Content *p) : Base(p)  {}
+    Newsgroups(Content *p, const QCString &s) : Base(p)  { from7BitString(s); }
+    Newsgroups(Content *p, const QString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
+    ~Newsgroups()  {}
+
+    virtual void from7BitString(const QCString &s);
+    virtual QCString as7BitString(bool incType=true);
+    virtual void fromUnicodeString(const QString &s, const QCString&);
+    virtual QString asUnicodeString();
+    virtual void clear()            { g_roups.resize(0); }
+    virtual bool isEmpty()          { return g_roups.isEmpty(); }
+    virtual const char* type()      { return "Newsgroups"; }
+
+    QCString firstGroup();
+    bool isCrossposted()            { return ( g_roups.find(',')>-1 ); }
+    QStringList getGroups();
+
+  protected:
+    QCString g_roups;
+
+};
+
+
+/** Represents a "Followup-To" header */
+class KDE_EXPORT FollowUpTo : public Newsgroups {
+
+  public:
+    FollowUpTo() : Newsgroups()  {}
+    FollowUpTo(Content *p) : Newsgroups(p)  {}
+    FollowUpTo(Content *p, const QCString &s) : Newsgroups(p,s)  {}
+    FollowUpTo(Content *p, const QString &s) : Newsgroups(p,s)  {}
+    ~FollowUpTo()  {}
+
+    virtual const char* type()        { return "Followup-To"; }
+
+};
+
+
+/** Represents a "Lines" header */
+class KDE_EXPORT Lines : public Base {
+
+  public:
+    Lines() : Base(),l_ines(-1)  {}
+    Lines(Content *p) : Base(p),l_ines(-1)  {}
+    Lines(Content *p, unsigned int i) : Base(p),l_ines(i)  {}
+    Lines(Content *p, const QCString &s) : Base(p)  { from7BitString(s); }
+    Lines(Content *p, const QString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
+    ~Lines()                 {}
+
+    virtual void from7BitString(const QCString &s);
+    virtual QCString as7BitString(bool incType=true);
+    virtual void fromUnicodeString(const QString &s, const QCString&);
+    virtual QString asUnicodeString();
+    virtual void clear()            { l_ines=-1; }
+    virtual bool isEmpty()          { return (l_ines==-1); }
+    virtual const char* type()      { return "Lines"; }
+
+    int numberOfLines()             { return l_ines; }
+    void setNumberOfLines(int i)    { l_ines=i; }
+
+  protected:
+    int l_ines;
+
+};
+
+
+
+/** Represents a "User-Agent" header */
+class KDE_EXPORT UserAgent : public Base {
+
+  public:
+    UserAgent() : Base()  {}
+    UserAgent(Content *p) : Base(p)  {}
+    UserAgent(Content *p, const QCString &s) : Base(p)  { from7BitString(s); }
+    UserAgent(Content *p, const QString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
+    ~UserAgent()  {}
+
+    virtual void from7BitString(const QCString &s);
+    virtual QCString as7BitString(bool incType=true);
+    virtual void fromUnicodeString(const QString &s, const QCString&);
+    virtual QString asUnicodeString();
+    virtual void clear()            { u_agent.resize(0); }
+    virtual bool isEmpty()          { return (u_agent.isEmpty()); }
+    virtual const char* type()      { return "User-Agent"; }
+
+  protected:
+    QCString u_agent;
+
+};
+
+
+#if !defined(KMIME_NEW_STYLE_CLASSTREE)
+#include "kmime_headers_obs.h"
+#endif
+}  //namespace Headers
+
+#if 0
+typedef Headers::Base* (*headerCreator)(void);
+
+/** This is a factory for KMime::Headers. You can create new header
+    objects by type with @ref create and @ref upgrade an existing
+    @ref Headers::Generic to a specialized header object.
+
+    If you are a header class author, you can register your class
+    (let's call it Foo) so:
+    <pre>
+    
+    </pre>    
+
+    @short Factory for KMime::Headers
+    @author Marc Mutz <mutz@kde.org>
+    @see KMime::Headers::Base KMime::Headers::Generic
+*/
+
+class HeaderFactory : public QAsciiDict<headerCreator>
+{
+private:
+  HeaderFactory();
+  ~HeaderFactory() {}
+  static QAsciiDict
+
+public:
+  /** Create a new header object of type @p aType, or a fitting
+      generic substitute, if available and known
+  */
+  static Headers::Base* create( const char* aType )
+  {
+    if (!s_elf)
+      s_elf = new HeaderFactory;
+    headerCreator * hc = (*s_elf)[aType];
+    if ( !hc )
+      return 0;
+    else
+      return (*hc)();
+  }
+
+  /** This is a wrapper around the above function, provided for
+      convenience. It differs from the above only in what arguments it
+      takes.
+  */
+  static Headers::Base* create( const QCString& aType )
+  {
+    return create( aType.data() );
+  }
+
+  /** Consume @p aType and build a header object that corresponds to
+      the type that @p aType->type() returns.
+      @param  aType    generic header to upgrade. This will be deleted
+                       if necessary, so don't use references to it after
+                       calling this function.
+      @return A corresponding header object (if available), or a generic
+      object for this kind of header (if known), or @p aType (else).
+      @see Headers::Generic create
+  */
+  static Headers::Base* upgrade( Headers::Generic* aType ) { (void)aType; return new Headers::Base; }
+
+};
+
+#endif
+
+}  //namespace KMime
+
+
+#endif // __KMIME_HEADERS_H__
+