libkmime

kmime_headers_obs.h

00001 /*
00002     kmime_headers.h
00003 
00004     KMime, the KDE internet mail/usenet news message library.
00005     Copyright (c) 2001 the KMime authors.
00006     See file AUTHORS for details
00007 
00008     This program is free software; you can redistribute it and/or modify
00009     it under the terms of the GNU General Public License as published by
00010     the Free Software Foundation; either version 2 of the License, or
00011     (at your option) any later version.
00012     You should have received a copy of the GNU General Public License
00013     along with this program; if not, write to the Free Software Foundation,
00014     Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, US
00015 */
00016 #ifndef __KMIME_HEADERS_OBS_H__
00017 #define __KMIME_HEADERS_OBS_H__
00018 
00019 #if defined(KMIME_NEW_STYPE_CLASSTREE)
00020 #error You cannot use this file with the new header classes!
00021 #endif
00022 
00023 #include <kdepimmacros.h>
00024 
00026 class KDE_EXPORT MessageID : public Base {
00027 
00028   public:
00029     MessageID() : Base()  {}
00030     MessageID(Content *p) : Base(p) {}
00031     MessageID(Content *p, const QCString &s) : Base(p) { from7BitString(s); }
00032     MessageID(Content *p, const QString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
00033     ~MessageID()  {}
00034 
00035     virtual void from7BitString(const QCString &s);
00036     virtual QCString as7BitString(bool incType=true);
00037     virtual void fromUnicodeString(const QString &s, const QCString&);
00038     virtual QString asUnicodeString();
00039     virtual void clear()            { m_id.resize(0); }
00040     virtual bool isEmpty()          { return (m_id.isEmpty()); }
00041     virtual const char* type()      { return "Message-Id"; }
00042 
00043     void generate(const QCString &fqdn);
00044 
00045   protected:
00046     QCString m_id;
00047 
00048 };
00049 
00051 class KDE_EXPORT Supersedes : public MessageID {
00052 
00053   public:
00054     Supersedes() : MessageID()  {}
00055     Supersedes(Content *p) : MessageID(p)  {}
00056     Supersedes(Content *p, const QCString &s) : MessageID(p,s)  {}
00057     Supersedes(Content *p, const QString &s)  : MessageID(p,s)  {}
00058     ~Supersedes()                   {}
00059 
00060     virtual const char* type()      { return "Supersedes"; }
00061 
00062 };
00063 
00066 class KDE_EXPORT AddressField : public Base {
00067 
00068   public:
00069     AddressField() : Base()  {}
00070     AddressField(Content *p) : Base(p)  {}
00071     AddressField(Content *p, const QCString &s) : Base(p)  { from7BitString(s); }
00072     AddressField(Content *p, const QString &s, const QCString &cs) : Base(p)  { fromUnicodeString(s, cs); }
00073     AddressField(const AddressField &a):  Base(a.p_arent)  { n_ame=a.n_ame; e_mail=a.e_mail.copy(); e_ncCS=a.e_ncCS; }
00074     ~AddressField()  {}
00075 
00076     AddressField& operator=(const AddressField &a)  { n_ame=a.n_ame; e_mail=a.e_mail.copy(); e_ncCS=a.e_ncCS; return (*this); }
00077 
00078     virtual void from7BitString(const QCString &s);
00079     virtual QCString as7BitString(bool incType=true);
00080     virtual void fromUnicodeString(const QString &s, const QCString &cs);
00081     virtual QString asUnicodeString();
00082     virtual void clear()              { n_ame.truncate(0); e_mail.resize(0); }
00083     virtual bool isEmpty()            { return (e_mail.isEmpty() && n_ame.isEmpty()); }
00084 
00085     bool hasName()                    { return ( !n_ame.isEmpty() ); }
00086     bool hasEmail()                   { return ( !e_mail.isEmpty() ); }
00087     QString name()                    { return n_ame; }
00088     QCString nameAs7Bit();
00089     QCString email()                  { return e_mail; }
00090     void setName(const QString &s)    { n_ame=s; }
00091     void setNameFrom7Bit(const QCString &s);
00092     void setEmail(const QCString &s)  { e_mail=s; }
00093 
00094   protected:
00095     QString n_ame;
00096     QCString e_mail;
00097 };
00098 typedef QPtrList<AddressField> ObsAddressList;
00099 
00101 class KDE_EXPORT From : public AddressField {
00102 
00103   public:
00104     From() : AddressField()  {}
00105     From(Content *p) : AddressField(p)  {}
00106     From(Content *p, const QCString &s) : AddressField(p,s)  {}
00107     From(Content *p, const QString &s, const QCString &cs) : AddressField(p,s,cs)  {}
00108     ~From()  {}
00109 
00110     virtual const char* type()      { return "From"; }
00111 };
00112 
00113 
00115 class KDE_EXPORT ReplyTo : public AddressField {
00116 
00117   public:
00118     ReplyTo() : AddressField()  {}
00119     ReplyTo(Content *p) : AddressField(p)  {}
00120     ReplyTo(Content *p, const QCString &s) : AddressField(p,s)  {}
00121     ReplyTo(Content *p, const QString &s, const QCString &cs) : AddressField(p,s,cs)  {}
00122     ~ReplyTo()  {}
00123 
00124     virtual const char* type()      { return "Reply-To"; }
00125 
00126 };
00127 
00128 
00131 class KDE_EXPORT MailCopiesTo : public AddressField {
00132 
00133   public:
00134     MailCopiesTo() : AddressField()  {}
00135     MailCopiesTo(Content *p) : AddressField(p)  {}
00136     MailCopiesTo(Content *p, const QCString &s) : AddressField(p,s)  {}
00137     MailCopiesTo(Content *p, const QString &s, const QCString &cs) : AddressField(p,s,cs)  {}
00138     ~MailCopiesTo()  {}
00139 
00140     bool isValid();
00141     bool alwaysCopy();
00142     bool neverCopy();
00143 
00144     virtual const char* type()      { return "Mail-Copies-To"; }
00145 
00146 };
00147 
00149 class KDE_EXPORT To : public Base {
00150 
00151   public:
00152     To() : Base(),a_ddrList(0)  {}
00153     To(Content *p) : Base(p),a_ddrList(0)  {}
00154     To(Content *p, const QCString &s) : Base(p),a_ddrList(0)  { from7BitString(s); }
00155     To(Content *p, const QString &s, const QCString &cs) : Base(p),a_ddrList(0)  { fromUnicodeString(s,cs); }
00156     ~To()  { delete a_ddrList; }
00157 
00158     virtual void from7BitString(const QCString &s);
00159     virtual QCString as7BitString(bool incType=true);
00160     virtual void fromUnicodeString(const QString &s, const QCString &cs);
00161     virtual QString asUnicodeString();
00162     virtual void clear()            { delete a_ddrList; a_ddrList=0; }
00163     virtual bool isEmpty()          { return (!a_ddrList || a_ddrList->isEmpty()
00164                                               || a_ddrList->first()->isEmpty()); }
00165     virtual const char* type()      { return "To"; }
00166 
00167     void addAddress(const AddressField &a);
00168     void emails(QStrList *l);
00169 
00170   protected:
00171     ObsAddressList *a_ddrList;
00172 
00173 };
00174 
00175 
00177 class KDE_EXPORT CC : public To {
00178 
00179   public:
00180     CC() : To()  {}
00181     CC(Content *p) : To(p)  {}
00182     CC(Content *p, const QCString &s) : To(p,s)  {}
00183     CC(Content *p, const QString &s, const QCString &cs) : To(p,s,cs)  {}
00184     ~CC()  {}
00185 
00186     virtual const char* type()      { return "CC"; }
00187 
00188 };
00189 
00190 
00192 class KDE_EXPORT BCC : public To {
00193 
00194   public:
00195     BCC() : To()  {}
00196     BCC(Content *p) : To(p)  {}
00197     BCC(Content *p, const QCString &s) : To(p,s)  {}
00198     BCC(Content *p, const QString &s, const QCString &cs) : To(p,s,cs)  {}
00199     ~BCC()  {}
00200 
00201     virtual const char* type()      { return "BCC"; }
00202 
00203 };
00204 
00206 class KDE_EXPORT References : public Base {
00207 
00208   public:
00209     References() : Base(),p_os(-1)  {}
00210     References(Content *p) : Base(p),p_os(-1)  {}
00211     References(Content *p, const QCString &s) : Base(p),p_os(-1)  { from7BitString(s); }
00212     References(Content *p, const QString &s) : Base(p),p_os(-1)  { fromUnicodeString(s, Latin1); }
00213     ~References()                 {}
00214 
00215     virtual void from7BitString(const QCString &s);
00216     virtual QCString as7BitString(bool incType=true);
00217     virtual void fromUnicodeString(const QString &s, const QCString&);
00218     virtual QString asUnicodeString();
00219     virtual void clear()            { r_ef.resize(0); p_os=0; }
00220     virtual bool isEmpty()          { return (r_ef.isEmpty()); }
00221     virtual const char* type()      { return "References"; }
00222 
00223     int count();
00224     QCString first();
00225     QCString next();
00226     QCString at(unsigned int i);
00227     void append(const QCString &s);
00228 
00229   protected:
00230     QCString r_ef;
00231     int p_os;
00232 
00233 };
00234 
00236 class KDE_EXPORT ContentType : public Base {
00237 
00238   public:
00239     ContentType() : Base(),m_imeType("invalid/invalid"),c_ategory(CCsingle)  {}
00240     ContentType(Content *p) : Base(p),m_imeType("invalid/invalid"),c_ategory(CCsingle)  {}
00241     ContentType(Content *p, const QCString &s) : Base(p)  { from7BitString(s); }
00242     ContentType(Content *p, const QString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
00243     ~ContentType()  {}
00244 
00245     virtual void from7BitString(const QCString &s);
00246     virtual QCString as7BitString(bool incType=true);
00247     virtual void fromUnicodeString(const QString &s, const QCString&);
00248     virtual QString asUnicodeString();
00249     virtual void clear()            { m_imeType.resize(0); p_arams.resize(0); }
00250     virtual bool isEmpty()          { return (m_imeType.isEmpty()); }
00251     virtual const char* type()      { return "Content-Type"; }
00252 
00253 
00254     //mime-type handling
00255     QCString mimeType()                     { return m_imeType; }
00256     QCString mediaType();
00257     QCString subType();
00258     void setMimeType(const QCString &s);
00259     bool isMediatype(const char *s);
00260     bool isSubtype(const char *s);
00261     bool isText();
00262     bool isPlainText();
00263     bool isHTMLText();
00264     bool isImage();
00265     bool isMultipart();
00266     bool isPartial();
00267 
00268     //parameter handling
00269     QCString charset();
00270     void setCharset(const QCString &s);
00271     QCString boundary();
00272     void setBoundary(const QCString &s);
00273     QString name();
00274     void setName(const QString &s, const QCString &cs);
00275     QCString id();
00276     void setId(const QCString &s);
00277     int partialNumber();
00278     int partialCount();
00279     void setPartialParams(int total, int number);
00280 
00281     //category
00282     contentCategory category()            { return c_ategory; }
00283     void setCategory(contentCategory c)   { c_ategory=c; }
00284 
00285   protected:
00286     QCString getParameter(const char *name);
00287     void setParameter(const QCString &name, const QCString &value, bool doubleQuotes=false);
00288     QCString m_imeType, p_arams;
00289     contentCategory c_ategory;
00290 
00291 };
00292 
00293 
00295 class KDE_EXPORT CTEncoding : public Base {
00296 
00297   public:
00298     CTEncoding() : Base(),c_te(CE7Bit),d_ecoded(true)  {}
00299     CTEncoding(Content *p) : Base(p),c_te(CE7Bit),d_ecoded(true)  {}
00300     CTEncoding(Content *p, const QCString &s) : Base(p)  { from7BitString(s); }
00301     CTEncoding(Content *p, const QString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
00302     ~CTEncoding()  {}
00303 
00304     virtual void from7BitString(const QCString &s);
00305     virtual QCString as7BitString(bool incType=true);
00306     virtual void fromUnicodeString(const QString &s, const QCString&);
00307     virtual QString asUnicodeString();
00308     virtual void clear()            { d_ecoded=true; c_te=CE7Bit; }
00309     virtual const char* type()      { return "Content-Transfer-Encoding"; }
00310 
00311     contentEncoding cte()                   { return c_te; }
00312     void setCte(contentEncoding e)          { c_te=e; }
00313     bool decoded()                          { return d_ecoded; }
00314     void setDecoded(bool d=true)            { d_ecoded=d; }
00315     bool needToEncode()                     { return (d_ecoded && (c_te==CEquPr || c_te==CEbase64)); }
00316 
00317   protected:
00318     contentEncoding c_te;
00319     bool d_ecoded;
00320 
00321 };
00322 
00323 
00325 class KDE_EXPORT CDisposition : public Base {
00326 
00327   public:
00328     CDisposition() : Base(),d_isp(CDinline)  {}
00329     CDisposition(Content *p) : Base(p),d_isp(CDinline)  {}
00330     CDisposition(Content *p, const QCString &s) : Base(p)  { from7BitString(s); }
00331     CDisposition(Content *p, const QString &s, const QCString &cs) : Base(p)  { fromUnicodeString(s, cs); }
00332     ~CDisposition()  {}
00333 
00334     virtual void from7BitString(const QCString &s);
00335     virtual QCString as7BitString(bool incType=true);
00336     virtual void fromUnicodeString(const QString &s, const QCString &cs);
00337     virtual QString asUnicodeString();
00338     virtual void clear()            { f_ilename.truncate(0); d_isp=CDinline; }
00339     virtual const char* type()      { return "Content-Disposition"; }
00340 
00341     contentDisposition disposition()          { return d_isp; }
00342     void setDisposition(contentDisposition d) { d_isp=d; }
00343     bool isAttachment()                       { return (d_isp==CDattachment); }
00344 
00345     QString filename()                        { return f_ilename; }
00346     void setFilename(const QString &s)        { f_ilename=s; }
00347 
00348   protected:
00349     contentDisposition d_isp;
00350     QString f_ilename;
00351 
00352 };
00353 
00354 
00356 class KDE_EXPORT CDescription : public Generics::GUnstructured {
00357 
00358   public:
00359     CDescription() : Generics::GUnstructured()  {}
00360     CDescription( Content * p ) : Generics::GUnstructured( p )  {}
00361     CDescription( Content * p, const QCString & s )
00362       : Generics::GUnstructured( p, s ) {};
00363     CDescription( Content * p, const QString & s, const QCString & cs )
00364       : Generics::GUnstructured( p, s, cs ) {}
00365     ~CDescription()  {}
00366 
00367     virtual const char* type()      { return "Content-Description"; }
00368 };
00369 
00370 #endif  // __KMIME_HEADERS_OBS_H__
KDE Home | KDE Accessibility Home | Description of Access Keys