identity.h

/*
 * User identity information
 *
 * Author: Stefan Taferner <taferner@kde.org>
 * This code is under GPL
 */
#ifndef kpim_identity_h
#define kpim_identity_h
 
#include <kleo/enum.h>
 
#include <tdemacros.h>
 
#include <tqstring.h>
#include <tqcstring.h>
#include <tqstringlist.h>
 
class TDEProcess;
namespace KPIM {
  class Identity;
  class Signature;
}
class TDEConfigBase;
class IdentityList;
class TQDataStream;
 
namespace KPIM {
 
TDE_EXPORT TQDataStream & operator<<( TQDataStream & stream, const KPIM::Signature & sig );
TDE_EXPORT TQDataStream & operator>>( TQDataStream & stream, KPIM::Signature & sig );
 
TDE_EXPORT TQDataStream & operator<<( TQDataStream & stream, const KPIM::Identity & ident );
TDE_EXPORT TQDataStream & operator>>( TQDataStream & stream, KPIM::Identity & ident );
 
class TDE_EXPORT Signature {
  friend class Identity;
 
  friend TQDataStream & KPIM::operator<<( TQDataStream & stream, const Signature & sig );
  friend TQDataStream & KPIM::operator>>( TQDataStream & stream, Signature & sig );
 
public:
  enum Type { Disabled = 0, Inlined = 1, FromFile = 2, FromCommand = 3 };
 
  bool operator==( const Signature & other ) const;
 
  Signature();
  Signature( const TQString & text );
  Signature( const TQString & url, bool isExecutable );
 
  TQString rawText( bool * ok=0 ) const;
 
  TQString withSeparator( bool * ok=0 ) const;
 
  void setText( const TQString & text ) { mText = text; }
  TQString text() const { return mText; }
 
  void setUrl( const TQString & url, bool isExecutable=false );
  TQString url() const { return mUrl; }
 
  Type type() const { return mType; }
  void setType( Type type ) { mType = type; }
 
protected:
  void writeConfig( TDEConfigBase * config ) const;
  void readConfig( const TDEConfigBase * config );
 
private:
  TQString textFromFile( bool * ok ) const;
  TQString textFromCommand( bool * ok ) const;
 
private:
  TQString mUrl;
  TQString mText;
  Type    mType;
};
 
class TDE_EXPORT Identity
{
  // only the identity manager should be able to construct and
  // destruct us, but then we get into problems with using
  // TQValueList<Identity> and especially qHeapSort().
  friend class IdentityManager;
 
  friend TQDataStream & operator<<( TQDataStream & stream, const KPIM::Identity & ident );
  friend TQDataStream & operator>>( TQDataStream & stream, KPIM::Identity & ident );
 
public:
  typedef TQValueList<Identity> List;
 
  bool operator==( const Identity & other ) const;
 
  bool operator!=( const Identity & other ) const {
    return !operator==( other );
  }
 
  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 );
  }
 
  explicit Identity( const TQString & id=TQString(),
             const TQString & realName=TQString(),
             const TQString & emailAddr=TQString(),
             const TQString & organization=TQString(),
             const TQString & replyToAddress=TQString() );
 
  ~Identity();
 
protected:
  void readConfig( const TDEConfigBase * );
 
  void writeConfig( TDEConfigBase * ) const;
 
public:
  bool mailingAllowed() const;
 
  TQString identityName() const { return mIdentity; }
  void setIdentityName( const TQString & name );
 
  bool isDefault() const { return mIsDefault; }
 
  uint uoid() const { return mUoid; }
 
protected:
  void setIsDefault( bool flag );
 
  void setUoid( uint aUoid ) { mUoid = aUoid; }
 
public:
  TQString fullName() const { return mFullName; }
  void setFullName(const TQString&);
 
  TQString organization() const { return mOrganization; }
  void setOrganization(const TQString&);
 
  TDE_DEPRECATED TQCString pgpIdentity() const { return pgpEncryptionKey(); }
  TDE_DEPRECATED void setPgpIdentity( const TQCString & key ) {
    setPGPEncryptionKey( key );
    setPGPSigningKey( key );
  }
 
  TQCString pgpEncryptionKey() const { return mPGPEncryptionKey; }
  void setPGPEncryptionKey( const TQCString & key );
 
  TQCString pgpSigningKey() const { return mPGPSigningKey; }
  void setPGPSigningKey( const TQCString & key );
 
  TQCString smimeEncryptionKey() const { return mSMIMEEncryptionKey; }
  void setSMIMEEncryptionKey( const TQCString & key );
 
  TQCString smimeSigningKey() const { return mSMIMESigningKey; }
  void setSMIMESigningKey( const TQCString & key );
 
  Kleo::CryptoMessageFormat preferredCryptoMessageFormat() const { return mPreferredCryptoMessageFormat; }
  void setPreferredCryptoMessageFormat( Kleo::CryptoMessageFormat format ) { mPreferredCryptoMessageFormat = format; }
 
  TDE_DEPRECATED TQString emailAddr() const { return primaryEmailAddress(); }
  TDE_DEPRECATED void setEmailAddr( const TQString & email ) { setPrimaryEmailAddress( email ); }
 
  TQString primaryEmailAddress() const { return mEmailAddr; }
  void setPrimaryEmailAddress( const TQString & email );
 
  const TQStringList & emailAliases() const { return mEmailAliases; }
  void setEmailAliases( const TQStringList & );
 
  bool matchesEmailAddress( const TQString & addr ) const;
 
  TQString vCardFile() const { return mVCardFile; }
  void setVCardFile(const TQString&);
 
  TQString fullEmailAddr() const;
 
  TQString replyToAddr() const { return mReplyToAddr; }
  void setReplyToAddr(const TQString&);
 
  TQString bcc() const { return mBcc; }
  void setBcc(const TQString& aBcc) { mBcc = aBcc; }
 
  void setSignature( const Signature & sig ) { mSignature = sig; }
  Signature & signature() /* _not_ const! */ { return mSignature; }
  const Signature & signature() const { return mSignature; }
 
protected:
  bool signatureIsCommand() const { return mSignature.type() == Signature::FromCommand; }
  bool signatureIsPlainFile() const { return mSignature.type() == Signature::FromFile; }
  bool signatureIsInline() const { return mSignature.type() == Signature::Inlined; }
 
  TQString signatureFile() const { return mSignature.url(); }
  void setSignatureFile(const TQString&);
 
  TQString signatureInlineText() const { return mSignature.text();}
  void setSignatureInlineText(const TQString&);
 
  bool useSignatureFile() const { return signatureIsPlainFile() || signatureIsCommand(); }
 
public:
  TQString signatureText( bool * ok=0) const;
 
  TQString transport() const { return mTransport; }
  void setTransport(const TQString&);
 
  TQString fcc() const { return mFcc; }
  void setFcc(const TQString&);
 
  TQString drafts() const { return mDrafts; }
  void setDrafts(const TQString&);
 
  TQString templates() const { return mTemplates; }
  void setTemplates( const TQString& );
 
  TQString dictionary() const { return mDictionary; }
  void setDictionary( const TQString& );
 
  TQString xface() const { return mXFace; }
  void setXFace( const TQString& );
  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;
  TQString mIdentity, mFullName, mEmailAddr, mOrganization;
  TQStringList mEmailAliases;
  TQString mReplyToAddr;
  TQString mBcc;
  TQString mVCardFile;
  TQCString mPGPEncryptionKey, mPGPSigningKey, mSMIMEEncryptionKey, mSMIMESigningKey;
  TQString mFcc, mDrafts, mTemplates, mTransport;
  TQString mDictionary;
  TQString mXFace;
  bool mXFaceEnabled;
  Signature mSignature;
  bool      mIsDefault;
  Kleo::CryptoMessageFormat mPreferredCryptoMessageFormat;
};
 
} // namespace KPIM
 
#endif /*kpim_identity_h*/