diff --git a/kpimidentities/identity.cpp b/kpimidentities/identity.cpp index 6e47ce028..30d96f7c3 100644 --- a/kpimidentities/identity.cpp +++ b/kpimidentities/identity.cpp @@ -1,614 +1,614 @@ // -*- mode: C++; c-file-style: "gnu" -*- // kmidentity.cpp // License: GPL #ifdef HAVE_CONFIG_H #include #endif #include "identity.h" #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace KPIM; Signature::Signature() : mType( Disabled ) { } Signature::Signature( const QString & text ) : mText( text ), mType( Inlined ) { } Signature::Signature( const QString & url, bool isExecutable ) : mUrl( url ), mType( isExecutable ? FromCommand : FromFile ) { } bool Signature::operator==( const Signature & other ) const { if ( mType != other.mType ) return false; switch ( mType ) { case Inlined: return mText == other.mText; case FromFile: case FromCommand: return mUrl == other.mUrl; default: case Disabled: return true; } } QString Signature::rawText( bool * ok ) const { switch ( mType ) { case Disabled: if ( ok ) *ok = true; return QString::null; case Inlined: if ( ok ) *ok = true; return mText; case FromFile: return textFromFile( ok ); case FromCommand: return textFromCommand( ok ); }; kdFatal( 5006 ) << "Signature::type() returned unknown value!" << endl; return QString::null; // make compiler happy } QString Signature::textFromCommand( bool * ok ) const { assert( mType == FromCommand ); // handle pathological cases: if ( mUrl.isEmpty() ) { if ( ok ) *ok = true; return QString::null; } // create a shell process: CollectingProcess proc; proc.setUseShell(true); proc << mUrl; // run the process: int rc = 0; if ( !proc.start( KProcess::Block, KProcess::Stdout ) ) rc = -1; else rc = ( proc.normalExit() ) ? proc.exitStatus() : -1 ; // handle errors, if any: if ( rc != 0 ) { if ( ok ) *ok = false; QString wmsg = i18n("Failed to execute signature script
%1:
%2") .arg( mUrl ).arg( strerror(rc) ); KMessageBox::error(0, wmsg); return QString::null; } // no errors: if ( ok ) *ok = true; // get output: QByteArray output = proc.collectedStdout(); // ### hmm, should we allow other encodings, too? return QString::fromLocal8Bit( output.data(), output.size() ); } QString Signature::textFromFile( bool * ok ) const { assert( mType == FromFile ); // ### FIXME: Use KIO::NetAccess to download non-local files! if ( !KURL(mUrl).isLocalFile() && !(QFileInfo(mUrl).isRelative() && QFileInfo(mUrl).exists()) ) { kdDebug( 5006 ) << "Signature::textFromFile: non-local URLs are unsupported" << endl; if ( ok ) *ok = false; return QString::null; } if ( ok ) *ok = true; // ### hmm, should we allow other encodings, too? return QString::fromLocal8Bit( kFileToString( mUrl, false ) ); } QString Signature::withSeparator( bool * ok ) const { bool internalOK = false; QString signature = rawText( &internalOK ); if ( !internalOK ) { if ( ok ) *ok = false; return QString::null; } if ( ok ) *ok = true; if ( signature.isEmpty() ) return signature; // don't add a separator in this case if ( signature.startsWith( QString::fromLatin1("-- \n") ) ) // already have signature separator at start of sig: return QString::fromLatin1("\n") += signature; else if ( signature.find( QString::fromLatin1("\n-- \n") ) != -1 ) // already have signature separator inside sig; don't prepend '\n' // to improve abusing signatures as templates: return signature; else // need to prepend one: return QString::fromLatin1("\n-- \n") + signature; } void Signature::setUrl( const QString & url, bool isExecutable ) { mUrl = url; mType = isExecutable ? FromCommand : FromFile ; } // config keys and values: static const char sigTypeKey[] = "Signature Type"; static const char sigTypeInlineValue[] = "inline"; static const char sigTypeFileValue[] = "file"; static const char sigTypeCommandValue[] = "command"; static const char sigTypeDisabledValue[] = "disabled"; static const char sigTextKey[] = "Inline Signature"; static const char sigFileKey[] = "Signature File"; static const char sigCommandKey[] = "Signature Command"; void Signature::readConfig( const KConfigBase * config ) { QString sigType = config->readEntry( sigTypeKey ); if ( sigType == sigTypeInlineValue ) { mType = Inlined; mText = config->readEntry( sigTextKey ); } else if ( sigType == sigTypeFileValue ) { mType = FromFile; mUrl = config->readPathEntry( sigFileKey ); } else if ( sigType == sigTypeCommandValue ) { mType = FromCommand; mUrl = config->readPathEntry( sigCommandKey ); } else { mType = Disabled; } } void Signature::writeConfig( KConfigBase * config ) const { switch ( mType ) { case Inlined: config->writeEntry( sigTypeKey, sigTypeInlineValue ); config->writeEntry( sigTextKey, mText ); break; case FromFile: config->writeEntry( sigTypeKey, sigTypeFileValue ); config->writePathEntry( sigFileKey, mUrl ); break; case FromCommand: config->writeEntry( sigTypeKey, sigTypeCommandValue ); config->writePathEntry( sigCommandKey, mUrl ); break; case Disabled: config->writeEntry( sigTypeKey, sigTypeDisabledValue ); default: ; } } QDataStream & KPIM::operator<<( QDataStream & stream, const KPIM::Signature & sig ) { return stream << static_cast(sig.mType) << sig.mUrl << sig.mText; } QDataStream & KPIM::operator>>( QDataStream & stream, KPIM::Signature & sig ) { Q_UINT8 s; stream >> s >> sig.mUrl >> sig.mText; sig.mType = static_cast(s); return stream; } // ### should use a kstaticdeleter? -Identity Identity::null; +const Identity Identity::null; bool Identity::isNull() const { return mIdentity.isEmpty() && mFullName.isEmpty() && mEmailAddr.isEmpty() && mOrganization.isEmpty() && mReplyToAddr.isEmpty() && mBcc.isEmpty() && mVCardFile.isEmpty() && mFcc.isEmpty() && mDrafts.isEmpty() && mPGPEncryptionKey.isEmpty() && mPGPSigningKey.isEmpty() && mSMIMEEncryptionKey.isEmpty() && mSMIMESigningKey.isEmpty() && mTransport.isEmpty() && mDictionary.isEmpty() && mPreferredCryptoMessageFormat == Kleo::AutoFormat && mSignature.type() == Signature::Disabled && mXFace.isEmpty(); } bool Identity::operator==( const Identity & other ) const { bool same = mUoid == other.mUoid && mIdentity == other.mIdentity && mFullName == other.mFullName && mEmailAddr == other.mEmailAddr && mOrganization == other.mOrganization && mReplyToAddr == other.mReplyToAddr && mBcc == other.mBcc && mVCardFile == other.mVCardFile && mFcc == other.mFcc && mPGPEncryptionKey == other.mPGPEncryptionKey && mPGPSigningKey == other.mPGPSigningKey && mSMIMEEncryptionKey == other.mSMIMEEncryptionKey && mSMIMESigningKey == other.mSMIMESigningKey && mPreferredCryptoMessageFormat == other.mPreferredCryptoMessageFormat && mDrafts == other.mDrafts && mTransport == other.mTransport && mDictionary == other.mDictionary && mSignature == other.mSignature && mXFace == other.mXFace && mXFaceEnabled == other.mXFaceEnabled; #if 0 if ( same ) return true; if ( mUoid != other.mUoid ) kdDebug() << "mUoid differs : " << mUoid << " != " << other.mUoid << endl; if ( mIdentity != other.mIdentity ) kdDebug() << "mIdentity differs : " << mIdentity << " != " << other.mIdentity << endl; if ( mFullName != other.mFullName ) kdDebug() << "mFullName differs : " << mFullName << " != " << other.mFullName << endl; if ( mEmailAddr != other.mEmailAddr ) kdDebug() << "mEmailAddr differs : " << mEmailAddr << " != " << other.mEmailAddr << endl; if ( mOrganization != other.mOrganization ) kdDebug() << "mOrganization differs : " << mOrganization << " != " << other.mOrganization << endl; if ( mReplyToAddr != other.mReplyToAddr ) kdDebug() << "mReplyToAddr differs : " << mReplyToAddr << " != " << other.mReplyToAddr << endl; if ( mBcc != other.mBcc ) kdDebug() << "mBcc differs : " << mBcc << " != " << other.mBcc << endl; if ( mVCardFile != other.mVCardFile ) kdDebug() << "mVCardFile differs : " << mVCardFile << " != " << other.mVCardFile << endl; if ( mFcc != other.mFcc ) kdDebug() << "mFcc differs : " << mFcc << " != " << other.mFcc << endl; if ( mPGPEncryptionKey != other.mPGPEncryptionKey ) kdDebug() << "mPGPEncryptionKey differs : " << mPGPEncryptionKey << " != " << other.mPGPEncryptionKey << endl; if ( mPGPSigningKey != other.mPGPSigningKey ) kdDebug() << "mPGPSigningKey differs : " << mPGPSigningKey << " != " << other.mPGPSigningKey << endl; if ( mSMIMEEncryptionKey != other.mSMIMEEncryptionKey ) kdDebug() << "mSMIMEEncryptionKey differs : '" << mSMIMEEncryptionKey << "' != '" << other.mSMIMEEncryptionKey << "'" << endl; if ( mSMIMESigningKey != other.mSMIMESigningKey ) kdDebug() << "mSMIMESigningKey differs : " << mSMIMESigningKey << " != " << other.mSMIMESigningKey << endl; if ( mPreferredCryptoMessageFormat != other.mPreferredCryptoMessageFormat ) kdDebug() << "mPreferredCryptoMessageFormat differs : " << mPreferredCryptoMessageFormat << " != " << other.mPreferredCryptoMessageFormat << endl; if ( mDrafts != other.mDrafts ) kdDebug() << "mDrafts differs : " << mDrafts << " != " << other.mDrafts << endl; if ( mTransport != other.mTransport ) kdDebug() << "mTransport differs : " << mTransport << " != " << other.mTransport << endl; if ( mDictionary != other.mDictionary ) kdDebug() << "mDictionary differs : " << mDictionary << " != " << other.mDictionary << endl; if ( ! ( mSignature == other.mSignature ) ) kdDebug() << "mSignature differs" << endl; #endif return same; } Identity::Identity( const QString & id, const QString & fullName, const QString & emailAddr, const QString & organization, const QString & replyToAddr ) : mUoid( 0 ), mIdentity( id ), mFullName( fullName ), mEmailAddr( emailAddr ), mOrganization( organization ), mReplyToAddr( replyToAddr ), // Using "" instead of null to make operator==() not fail // (readConfig returns "") mBcc( "" ), mVCardFile( "" ), mPGPEncryptionKey( "" ), mPGPSigningKey( "" ), mSMIMEEncryptionKey( "" ), mSMIMESigningKey( "" ), mFcc( "" ), mDrafts( "" ), mTransport( "" ), mDictionary( "" ), mXFace( "" ), mXFaceEnabled( false ), mIsDefault( false ), mPreferredCryptoMessageFormat( Kleo::AutoFormat ) { } Identity::~Identity() { } void Identity::readConfig( const KConfigBase * config ) { mUoid = config->readUnsignedNumEntry("uoid",0); mIdentity = config->readEntry("Identity"); mFullName = config->readEntry("Name"); mEmailAddr = config->readEntry("Email Address"); mVCardFile = config->readPathEntry("VCardFile"); mOrganization = config->readEntry("Organization"); mPGPSigningKey = config->readEntry("PGP Signing Key").latin1(); mPGPEncryptionKey = config->readEntry("PGP Encryption Key").latin1(); mSMIMESigningKey = config->readEntry("SMIME Signing Key").latin1(); mSMIMEEncryptionKey = config->readEntry("SMIME Encryption Key").latin1(); mPreferredCryptoMessageFormat = Kleo::stringToCryptoMessageFormat( config->readEntry("Preferred Crypto Message Format", "none" ) ); mReplyToAddr = config->readEntry("Reply-To Address"); mBcc = config->readEntry("Bcc"); mFcc = config->readEntry("Fcc", "sent-mail"); if( mFcc.isEmpty() ) mFcc = "sent-mail"; mDrafts = config->readEntry("Drafts", "drafts"); if( mDrafts.isEmpty() ) mDrafts = "drafts"; mTransport = config->readEntry("Transport"); mDictionary = config->readEntry( "Dictionary" ); mXFace = config->readEntry( "X-Face" ); mXFaceEnabled = config->readBoolEntry( "X-FaceEnabled", false ); mSignature.readConfig( config ); kdDebug(5006) << "Identity::readConfig(): UOID = " << mUoid << " for identity named \"" << mIdentity << "\"" << endl; } void Identity::writeConfig( KConfigBase * config ) const { config->writeEntry("uoid", mUoid); config->writeEntry("Identity", mIdentity); config->writeEntry("Name", mFullName); config->writeEntry("Organization", mOrganization); config->writeEntry("PGP Signing Key", mPGPSigningKey.data()); config->writeEntry("PGP Encryption Key", mPGPEncryptionKey.data()); config->writeEntry("SMIME Signing Key", mSMIMESigningKey.data()); config->writeEntry("SMIME Encryption Key", mSMIMEEncryptionKey.data()); config->writeEntry("Preferred Crypto Message Format", Kleo::cryptoMessageFormatToString( mPreferredCryptoMessageFormat ) ); config->writeEntry("Email Address", mEmailAddr); config->writeEntry("Reply-To Address", mReplyToAddr); config->writeEntry("Bcc", mBcc); config->writePathEntry("VCardFile", mVCardFile); config->writeEntry("Transport", mTransport); config->writeEntry("Fcc", mFcc); config->writeEntry("Drafts", mDrafts); config->writeEntry( "Dictionary", mDictionary ); config->writeEntry( "X-Face", mXFace ); config->writeEntry( "X-FaceEnabled", mXFaceEnabled ); mSignature.writeConfig( config ); } QDataStream & KPIM::operator<<( QDataStream & stream, const KPIM::Identity & i ) { return stream << static_cast(i.uoid()) << i.identityName() << i.fullName() << i.organization() << i.pgpSigningKey() << i.pgpEncryptionKey() << i.smimeSigningKey() << i.smimeEncryptionKey() << i.emailAddr() << i.replyToAddr() << i.bcc() << i.vCardFile() << i.transport() << i.fcc() << i.drafts() << i.mSignature << i.dictionary() << i.xface() << QString( Kleo::cryptoMessageFormatToString( i.mPreferredCryptoMessageFormat ) ); } QDataStream & KPIM::operator>>( QDataStream & stream, KPIM::Identity & i ) { Q_UINT32 uoid; QString format; stream >> uoid >> i.mIdentity >> i.mFullName >> i.mOrganization >> i.mPGPSigningKey >> i.mPGPEncryptionKey >> i.mSMIMESigningKey >> i.mSMIMEEncryptionKey >> i.mEmailAddr >> i.mReplyToAddr >> i.mBcc >> i.mVCardFile >> i.mTransport >> i.mFcc >> i.mDrafts >> i.mSignature >> i.mDictionary >> i.mXFace >> format; i.mUoid = uoid; i.mPreferredCryptoMessageFormat = Kleo::stringToCryptoMessageFormat( format.latin1() ); return stream; } //----------------------------------------------------------------------------- bool Identity::mailingAllowed() const { return !mEmailAddr.isEmpty(); } void Identity::setIsDefault( bool flag ) { mIsDefault = flag; } void Identity::setIdentityName( const QString & name ) { mIdentity = name; } void Identity::setFullName(const QString &str) { mFullName = str; } //----------------------------------------------------------------------------- void Identity::setOrganization(const QString &str) { mOrganization = str; } void Identity::setPGPSigningKey(const QCString &str) { mPGPSigningKey = str; if ( mPGPSigningKey.isNull() ) mPGPSigningKey = ""; } void Identity::setPGPEncryptionKey(const QCString &str) { mPGPEncryptionKey = str; if ( mPGPEncryptionKey.isNull() ) mPGPEncryptionKey = ""; } void Identity::setSMIMESigningKey(const QCString &str) { mSMIMESigningKey = str; if ( mSMIMESigningKey.isNull() ) mSMIMESigningKey = ""; } void Identity::setSMIMEEncryptionKey(const QCString &str) { mSMIMEEncryptionKey = str; if ( mSMIMEEncryptionKey.isNull() ) mSMIMEEncryptionKey = ""; } //----------------------------------------------------------------------------- void Identity::setEmailAddr(const QString &str) { mEmailAddr = str; } //----------------------------------------------------------------------------- void Identity::setVCardFile(const QString &str) { mVCardFile = str; } //----------------------------------------------------------------------------- QString Identity::fullEmailAddr(void) const { if (mFullName.isEmpty()) return mEmailAddr; const QString specials("()<>@,.;:[]"); QString result; // add DQUOTE's if necessary: bool needsQuotes=false; for (unsigned int i=0; i < mFullName.length(); i++) { if ( specials.contains( mFullName[i] ) ) needsQuotes = true; else if ( mFullName[i] == '\\' || mFullName[i] == '"' ) { needsQuotes = true; result += '\\'; } result += mFullName[i]; } if (needsQuotes) { result.insert(0,'"'); result += '"'; } result += " <" + mEmailAddr + '>'; return result; } //----------------------------------------------------------------------------- void Identity::setReplyToAddr(const QString& str) { mReplyToAddr = str; } //----------------------------------------------------------------------------- void Identity::setSignatureFile(const QString &str) { mSignature.setUrl( str, signatureIsCommand() ); } //----------------------------------------------------------------------------- void Identity::setSignatureInlineText(const QString &str ) { mSignature.setText( str ); } //----------------------------------------------------------------------------- void Identity::setTransport(const QString &str) { mTransport = str; if ( mTransport.isNull() ) mTransport = ""; } //----------------------------------------------------------------------------- void Identity::setFcc(const QString &str) { mFcc = str; if ( mFcc.isNull() ) mFcc = ""; } //----------------------------------------------------------------------------- void Identity::setDrafts(const QString &str) { mDrafts = str; if ( mDrafts.isNull() ) mDrafts = ""; } //----------------------------------------------------------------------------- void Identity::setDictionary( const QString &str ) { mDictionary = str; if ( mDictionary.isNull() ) mDictionary = ""; } //----------------------------------------------------------------------------- void Identity::setXFace( const QString &str ) { mXFace = str; mXFace.remove( " " ); mXFace.remove( "\n" ); mXFace.remove( "\r" ); } //----------------------------------------------------------------------------- void Identity::setXFaceEnabled( const bool on ) { mXFaceEnabled = on; } //----------------------------------------------------------------------------- QString Identity::signatureText( bool * ok ) const { bool internalOK = false; QString signatureText = mSignature.withSeparator( &internalOK ); if ( internalOK ) { if ( ok ) *ok=true; return signatureText; } // OK, here comes the funny part. The call to // Signature::withSeparator() failed, so we should probably fix the // cause: if ( ok ) *ok = false; return QString::null; #if 0 // ### FIXME: error handling if (mSignatureFile.endsWith("|")) { } else { } #endif return QString::null; } diff --git a/kpimidentities/identity.h b/kpimidentities/identity.h index 45a3a056f..6469e0cae 100644 --- a/kpimidentities/identity.h +++ b/kpimidentities/identity.h @@ -1,312 +1,312 @@ /* -*- 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 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; mType = Inlined; } 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; } 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 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 & KPIM::operator<<( QDataStream & stream, const Identity & ident ); friend QDataStream & KPIM::operator>>( QDataStream & stream, 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 @ref KConfigGroup). Called from @ref IdentityManager. */ void readConfig( const KConfigBase * ); /** Write configuration to config. Group must be preset (or use @ref KConfigGroup). Called from @ref 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 @ref 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; } 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&); /** 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 Identity null; + 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, mTransport; QString mDictionary; QString mXFace; bool mXFaceEnabled; Signature mSignature; bool mIsDefault; Kleo::CryptoMessageFormat mPreferredCryptoMessageFormat; }; QDataStream & operator<<( QDataStream & stream, const KPIM::Signature & sig ); QDataStream & operator>>( QDataStream & stream, KPIM::Signature & sig ); QDataStream & operator<<( QDataStream & stream, const KPIM::Identity & ident ); QDataStream & operator>>( QDataStream & stream, KPIM::Identity & ident ); } // namespace KPIM #endif /*kpim_identity_h*/