From 460c52653ab0dcca6f19a4f492ed2c5e4e963ab0 Mon Sep 17 00:00:00 2001 From: toma Date: Wed, 25 Nov 2009 17:56:58 +0000 Subject: 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 --- libkpimidentities/identity.h | 319 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 319 insertions(+) create mode 100644 libkpimidentities/identity.h (limited to 'libkpimidentities/identity.h') diff --git a/libkpimidentities/identity.h b/libkpimidentities/identity.h new file mode 100644 index 000000000..6b06e9a9d --- /dev/null +++ b/libkpimidentities/identity.h @@ -0,0 +1,319 @@ +/* -*- mode: C++; c-file-style: "gnu" -*- + * User identity information + * + * Author: Stefan Taferner + * This code is under GPL + */ +#ifndef kpim_identity_h +#define kpim_identity_h + +#include + +#include + +#include +#include +#include + +class KProcess; +namespace KPIM { + class Identity; + class Signature; +} +class KConfigBase; +class IdentityList; +class QDataStream; + +namespace KPIM { + +/** + * @short abstraction of a signature (aka "footer"). + * @author Marc Mutz + */ +class KDE_EXPORT Signature { + friend class Identity; + + friend QDataStream & KPIM::operator<<( QDataStream & stream, const Signature & sig ); + friend QDataStream & KPIM::operator>>( QDataStream & stream, Signature & sig ); + +public: + /** Type of signature (ie. way to obtain the signature text) */ + enum Type { Disabled = 0, Inlined = 1, FromFile = 2, FromCommand = 3 }; + + /** Used for comparison */ + bool operator==( const Signature & other ) const; + + /** Constructor for disabled signature */ + Signature(); + /** Constructor for inline text */ + Signature( const QString & text ); + /** Constructor for text from a file or from output of a command */ + Signature( const QString & url, bool isExecutable ); + + /** @return the raw signature text as entered resp. read from file. */ + QString rawText( bool * ok=0 ) const; + + /** @return the signature text with a "-- " separator added, if + necessary. */ + QString withSeparator( bool * ok=0 ) const; + + /** Set the signature text and mark this signature as being of + "inline text" type. */ + void setText( const QString & text ) { mText = text; } + QString text() const { return mText; } + + /** Set the signature URL and mark this signature as being of + "from file" resp. "from output of command" type. */ + void setUrl( const QString & url, bool isExecutable=false ); + QString url() const { return mUrl; } + + /// @return the type of signature (ie. way to obtain the signature text) + Type type() const { return mType; } + void setType( Type type ) { mType = type; } + +protected: + void writeConfig( KConfigBase * config ) const; + void readConfig( const KConfigBase * config ); + +private: + QString textFromFile( bool * ok ) const; + QString textFromCommand( bool * ok ) const; + +private: + QString mUrl; + QString mText; + Type mType; +}; + +/** User identity information */ +class KDE_EXPORT Identity +{ + // only the identity manager should be able to construct and + // destruct us, but then we get into problems with using + // QValueList and especially qHeapSort(). + friend class IdentityManager; + + friend QDataStream & operator<<( QDataStream & stream, const KPIM::Identity & ident ); + friend QDataStream & operator>>( QDataStream & stream, KPIM::Identity & ident ); + +public: + typedef QValueList List; + + /** used for comparison */ + bool operator==( const Identity & other ) const; + + bool operator!=( const Identity & other ) const { + return !operator==( other ); + } + + /** used for sorting */ + bool operator<( const Identity & other ) const { + if ( isDefault() ) return true; + if ( other.isDefault() ) return false; + return identityName() < other.identityName(); + } + bool operator>( const Identity & other ) const { + if ( isDefault() ) return false; + if ( other.isDefault() ) return true; + return identityName() > other.identityName(); + } + bool operator<=( const Identity & other ) const { + return !operator>( other ); + } + bool operator>=( const Identity & other ) const { + return !operator<( other ); + } + + /** Constructor */ + explicit Identity( const QString & id=QString::null, + const QString & realName=QString::null, + const QString & emailAddr=QString::null, + const QString & organization=QString::null, + const QString & replyToAddress=QString::null ); + + /** Destructor */ + ~Identity(); + +protected: + /** Read configuration from config. Group must be preset (or use + KConfigGroup). Called from IdentityManager. */ + void readConfig( const KConfigBase * ); + + /** Write configuration to config. Group must be preset (or use + KConfigGroup). Called from IdentityManager. */ + void writeConfig( KConfigBase * ) const; + +public: + /** Tests if there are enough values set to allow mailing */ + bool mailingAllowed() const; + + /** Identity/nickname for this collection */ + QString identityName() const { return mIdentity; } + void setIdentityName( const QString & name ); + + /** @return whether this identity is the default identity */ + bool isDefault() const { return mIsDefault; } + + /// Unique Object Identifier for this identity + uint uoid() const { return mUoid; } + +protected: + /** Set whether this identity is the default identity. Since this + affects all other identites, too (most notably, the old default + identity), only the IdentityManager can change this. + You should use + 
+      kmkernel->identityManager()->setAsDefault( name_of_default )
+
+ instead. + **/ + void setIsDefault( bool flag ); + + void setUoid( uint aUoid ) { mUoid = aUoid; } + +public: + /** Full name of the user */ + QString fullName() const { return mFullName; } + void setFullName(const QString&); + + /** The user's organization (optional) */ + QString organization() const { return mOrganization; } + void setOrganization(const QString&); + + KDE_DEPRECATED QCString pgpIdentity() const { return pgpEncryptionKey(); } + KDE_DEPRECATED void setPgpIdentity( const QCString & key ) { + setPGPEncryptionKey( key ); + setPGPSigningKey( key ); + } + + /** The user's OpenPGP encryption key */ + QCString pgpEncryptionKey() const { return mPGPEncryptionKey; } + void setPGPEncryptionKey( const QCString & key ); + + /** The user's OpenPGP signing key */ + QCString pgpSigningKey() const { return mPGPSigningKey; } + void setPGPSigningKey( const QCString & key ); + + /** The user's S/MIME encryption key */ + QCString smimeEncryptionKey() const { return mSMIMEEncryptionKey; } + void setSMIMEEncryptionKey( const QCString & key ); + + /** The user's S/MIME signing key */ + QCString smimeSigningKey() const { return mSMIMESigningKey; } + void setSMIMESigningKey( const QCString & key ); + + Kleo::CryptoMessageFormat preferredCryptoMessageFormat() const { return mPreferredCryptoMessageFormat; } + void setPreferredCryptoMessageFormat( Kleo::CryptoMessageFormat format ) { mPreferredCryptoMessageFormat = format; } + + /** email address (without the user name - only name\@host) */ + QString emailAddr() const { return mEmailAddr; } + void setEmailAddr(const QString&); + + /** vCard to attach to outgoing emails */ + QString vCardFile() const { return mVCardFile; } + void setVCardFile(const QString&); + + /** email address in the format "username " suitable + for the "From:" field of email messages. */ + QString fullEmailAddr() const; + + /** email address for the ReplyTo: field */ + QString replyToAddr() const { return mReplyToAddr; } + void setReplyToAddr(const QString&); + + /** email addresses for the BCC: field */ + QString bcc() const { return mBcc; } + void setBcc(const QString& aBcc) { mBcc = aBcc; } + + void setSignature( const Signature & sig ) { mSignature = sig; } + Signature & signature() /* _not_ const! */ { return mSignature; } + const Signature & signature() const { return mSignature; } + +protected: + /** @return true if the signature is read from the output of a command */ + bool signatureIsCommand() const { return mSignature.type() == Signature::FromCommand; } + /** @return true if the signature is read from a text file */ + bool signatureIsPlainFile() const { return mSignature.type() == Signature::FromFile; } + /** @return true if the signature was specified directly */ + bool signatureIsInline() const { return mSignature.type() == Signature::Inlined; } + + /** name of the signature file (with path) */ + QString signatureFile() const { return mSignature.url(); } + void setSignatureFile(const QString&); + + /** inline signature */ + QString signatureInlineText() const { return mSignature.text();} + void setSignatureInlineText(const QString&); + + /** Inline or signature from a file */ + bool useSignatureFile() const { return signatureIsPlainFile() || signatureIsCommand(); } + +public: + /** Returns the signature. This method also takes care of special + signature files that are shell scripts and handles them + correct. So use this method to rectreive the contents of the + signature file. If @p prompt is false, no errors will be displayed + (useful for retries). */ + QString signatureText( bool * ok=0) const; + + /** The transport that is set for this identity. Used to link a + transport with an identity. */ + QString transport() const { return mTransport; } + void setTransport(const QString&); + + /** The folder where sent messages from this identity will be + stored by default. */ + QString fcc() const { return mFcc; } + void setFcc(const QString&); + + /** The folder where draft messages from this identity will be + stored by default. */ + QString drafts() const { return mDrafts; } + void setDrafts(const QString&); + + /** The folder where template messages from this identity will be + stored by default. */ + QString templates() const { return mTemplates; } + void setTemplates( const QString& ); + + /** dictionary which should be used for spell checking */ + QString dictionary() const { return mDictionary; } + void setDictionary( const QString& ); + + /** a X-Face header for this identity */ + QString xface() const { return mXFace; } + void setXFace( const QString& ); + bool isXFaceEnabled() const { return mXFaceEnabled; } + void setXFaceEnabled( const bool ); + + static const Identity& null(); + bool isNull() const; +protected: + // if you add new members, make sure they have an operator= (or the + // compiler can synthesize one) and amend Identity::operator==, + // isNull(), readConfig() and writeConfig() as well as operator<< + // and operator>> accordingly: + uint mUoid; + QString mIdentity, mFullName, mEmailAddr, mOrganization; + QString mReplyToAddr; + QString mBcc; + QString mVCardFile; + QCString mPGPEncryptionKey, mPGPSigningKey, mSMIMEEncryptionKey, mSMIMESigningKey; + QString mFcc, mDrafts, mTemplates, mTransport; + QString mDictionary; + QString mXFace; + bool mXFaceEnabled; + Signature mSignature; + bool mIsDefault; + Kleo::CryptoMessageFormat mPreferredCryptoMessageFormat; +}; + +KDE_EXPORT QDataStream & operator<<( QDataStream & stream, const KPIM::Signature & sig ); +KDE_EXPORT QDataStream & operator>>( QDataStream & stream, KPIM::Signature & sig ); + +KDE_EXPORT QDataStream & operator<<( QDataStream & stream, const KPIM::Identity & ident ); +KDE_EXPORT QDataStream & operator>>( QDataStream & stream, KPIM::Identity & ident ); + +} // namespace KPIM + +#endif /*kpim_identity_h*/ -- cgit v1.2.1