00001
00002
00003
00004
00005 #ifdef HAVE_CONFIG_H
00006 #include <config.h>
00007 #endif
00008
00009 #include "identity.h"
00010
00011 #include <libtdepim/tdefileio.h>
00012 #include <libtdepim/collectingprocess.h>
00013
00014 #include <kdebug.h>
00015 #include <tdelocale.h>
00016 #include <tdemessagebox.h>
00017 #include <tdeconfig.h>
00018 #include <kurl.h>
00019
00020 #include <tqfileinfo.h>
00021
00022 #include <sys/types.h>
00023 #include <stdlib.h>
00024 #include <stdio.h>
00025 #include <errno.h>
00026 #include <assert.h>
00027
00028 using namespace KPIM;
00029
00030
00031 Signature::Signature()
00032 : mType( Disabled )
00033 {
00034
00035 }
00036
00037 Signature::Signature( const TQString & text )
00038 : mText( text ),
00039 mType( Inlined )
00040 {
00041
00042 }
00043
00044 Signature::Signature( const TQString & url, bool isExecutable )
00045 : mUrl( url ),
00046 mType( isExecutable ? FromCommand : FromFile )
00047 {
00048 }
00049
00050 bool Signature::operator==( const Signature & other ) const {
00051 if ( mType != other.mType ) return false;
00052 switch ( mType ) {
00053 case Inlined: return mText == other.mText;
00054 case FromFile:
00055 case FromCommand: return mUrl == other.mUrl;
00056 default:
00057 case Disabled: return true;
00058 }
00059 }
00060
00061 TQString Signature::rawText( bool * ok ) const
00062 {
00063 switch ( mType ) {
00064 case Disabled:
00065 if ( ok ) *ok = true;
00066 return TQString();
00067 case Inlined:
00068 if ( ok ) *ok = true;
00069 return mText;
00070 case FromFile:
00071 return textFromFile( ok );
00072 case FromCommand:
00073 return textFromCommand( ok );
00074 };
00075 kdFatal( 5006 ) << "Signature::type() returned unknown value!" << endl;
00076 return TQString();
00077 }
00078
00079 TQString Signature::textFromCommand( bool * ok ) const
00080 {
00081 assert( mType == FromCommand );
00082
00083
00084 if ( mUrl.isEmpty() ) {
00085 if ( ok ) *ok = true;
00086 return TQString();
00087 }
00088
00089
00090 CollectingProcess proc;
00091 proc.setUseShell(true);
00092 proc << mUrl;
00093
00094
00095 int rc = 0;
00096 if ( !proc.start( TDEProcess::Block, TDEProcess::Stdout ) )
00097 rc = -1;
00098 else
00099 rc = ( proc.normalExit() ) ? proc.exitStatus() : -1 ;
00100
00101
00102 if ( rc != 0 ) {
00103 if ( ok ) *ok = false;
00104 TQString wmsg = i18n("<qt>Failed to execute signature script<br><b>%1</b>:<br>%2</qt>")
00105 .arg( mUrl ).arg( strerror(rc) );
00106 KMessageBox::error(0, wmsg);
00107 return TQString();
00108 }
00109
00110
00111 if ( ok ) *ok = true;
00112
00113
00114 TQByteArray output = proc.collectedStdout();
00115
00116
00117 return TQString::fromLocal8Bit( output.data(), output.size() );
00118 }
00119
00120 TQString Signature::textFromFile( bool * ok ) const
00121 {
00122 assert( mType == FromFile );
00123
00124
00125 if ( !KURL(mUrl).isLocalFile() && !(TQFileInfo(mUrl).isRelative()
00126 && TQFileInfo(mUrl).exists()) ) {
00127 kdDebug( 5006 ) << "Signature::textFromFile: non-local URLs are unsupported" << endl;
00128 if ( ok ) *ok = false;
00129 return TQString();
00130 }
00131 if ( ok ) *ok = true;
00132
00133 return TQString::fromLocal8Bit( kFileToString( mUrl, false ) );
00134 }
00135
00136 TQString Signature::withSeparator( bool * ok ) const
00137 {
00138 bool internalOK = false;
00139 TQString signature = rawText( &internalOK );
00140 if ( !internalOK ) {
00141 if ( ok ) *ok = false;
00142 return TQString();
00143 }
00144 if ( ok ) *ok = true;
00145 if ( signature.isEmpty() ) return signature;
00146 if ( signature.startsWith( TQString::fromLatin1("-- \n") ) )
00147
00148 return TQString::fromLatin1("\n") += signature;
00149 else if ( signature.find( TQString::fromLatin1("\n-- \n") ) != -1 )
00150
00151
00152 return signature;
00153 else
00154
00155 return TQString::fromLatin1("\n-- \n") + signature;
00156 }
00157
00158
00159 void Signature::setUrl( const TQString & url, bool isExecutable )
00160 {
00161 mUrl = url;
00162 mType = isExecutable ? FromCommand : FromFile ;
00163 }
00164
00165
00166 static const char sigTypeKey[] = "Signature Type";
00167 static const char sigTypeInlineValue[] = "inline";
00168 static const char sigTypeFileValue[] = "file";
00169 static const char sigTypeCommandValue[] = "command";
00170 static const char sigTypeDisabledValue[] = "disabled";
00171 static const char sigTextKey[] = "Inline Signature";
00172 static const char sigFileKey[] = "Signature File";
00173 static const char sigCommandKey[] = "Signature Command";
00174
00175 void Signature::readConfig( const TDEConfigBase * config )
00176 {
00177 TQString sigType = config->readEntry( sigTypeKey );
00178 if ( sigType == sigTypeInlineValue ) {
00179 mType = Inlined;
00180 } else if ( sigType == sigTypeFileValue ) {
00181 mType = FromFile;
00182 mUrl = config->readPathEntry( sigFileKey );
00183 } else if ( sigType == sigTypeCommandValue ) {
00184 mType = FromCommand;
00185 mUrl = config->readPathEntry( sigCommandKey );
00186 } else {
00187 mType = Disabled;
00188 }
00189 mText = config->readEntry( sigTextKey );
00190 }
00191
00192 void Signature::writeConfig( TDEConfigBase * config ) const
00193 {
00194 switch ( mType ) {
00195 case Inlined:
00196 config->writeEntry( sigTypeKey, sigTypeInlineValue );
00197 break;
00198 case FromFile:
00199 config->writeEntry( sigTypeKey, sigTypeFileValue );
00200 config->writePathEntry( sigFileKey, mUrl );
00201 break;
00202 case FromCommand:
00203 config->writeEntry( sigTypeKey, sigTypeCommandValue );
00204 config->writePathEntry( sigCommandKey, mUrl );
00205 break;
00206 case Disabled:
00207 config->writeEntry( sigTypeKey, sigTypeDisabledValue );
00208 default: ;
00209 }
00210 config->writeEntry( sigTextKey, mText );
00211 }
00212
00213 TQDataStream & KPIM::operator<<( TQDataStream & stream, const KPIM::Signature & sig ) {
00214 return stream << static_cast<TQ_UINT8>(sig.mType)
00215 << sig.mUrl
00216 << sig.mText;
00217 }
00218
00219 TQDataStream & KPIM::operator>>( TQDataStream & stream, KPIM::Signature & sig ) {
00220 TQ_UINT8 s;
00221 stream >> s
00222 >> sig.mUrl
00223 >> sig.mText;
00224 sig.mType = static_cast<Signature::Type>(s);
00225 return stream;
00226 }
00227
00228
00229 static Identity* identityNull = 0;
00230 const Identity& Identity::null()
00231 {
00232 if ( !identityNull )
00233 identityNull = new Identity;
00234 return *identityNull;
00235 }
00236
00237 bool Identity::isNull() const {
00238 return mIdentity.isEmpty() && mFullName.isEmpty() && mEmailAddr.isEmpty() &&
00239 mEmailAliases.empty() &&
00240 mOrganization.isEmpty() && mReplyToAddr.isEmpty() && mBcc.isEmpty() &&
00241 mVCardFile.isEmpty() &&
00242 mFcc.isEmpty() && mDrafts.isEmpty() && mTemplates.isEmpty() &&
00243 mPGPEncryptionKey.isEmpty() && mPGPSigningKey.isEmpty() &&
00244 mSMIMEEncryptionKey.isEmpty() && mSMIMESigningKey.isEmpty() &&
00245 mTransport.isEmpty() && mDictionary.isEmpty() &&
00246 mPreferredCryptoMessageFormat == Kleo::AutoFormat &&
00247 mSignature.type() == Signature::Disabled &&
00248 mXFace.isEmpty();
00249 }
00250
00251 bool Identity::operator==( const Identity & other ) const {
00252 bool same = mUoid == other.mUoid &&
00253 mIdentity == other.mIdentity && mFullName == other.mFullName &&
00254 mEmailAddr == other.mEmailAddr && mOrganization == other.mOrganization &&
00255 mEmailAliases == other.mEmailAliases &&
00256 mReplyToAddr == other.mReplyToAddr && mBcc == other.mBcc &&
00257 mVCardFile == other.mVCardFile &&
00258 mFcc == other.mFcc &&
00259 mPGPEncryptionKey == other.mPGPEncryptionKey &&
00260 mPGPSigningKey == other.mPGPSigningKey &&
00261 mSMIMEEncryptionKey == other.mSMIMEEncryptionKey &&
00262 mSMIMESigningKey == other.mSMIMESigningKey &&
00263 mPreferredCryptoMessageFormat == other.mPreferredCryptoMessageFormat &&
00264 mDrafts == other.mDrafts && mTemplates == other.mTemplates &&
00265 mTransport == other.mTransport &&
00266 mDictionary == other.mDictionary && mSignature == other.mSignature &&
00267 mXFace == other.mXFace && mXFaceEnabled == other.mXFaceEnabled;
00268
00269 #if 0
00270 if ( same )
00271 return true;
00272 if ( mUoid != other.mUoid ) kdDebug() << "mUoid differs : " << mUoid << " != " << other.mUoid << endl;
00273 if ( mIdentity != other.mIdentity ) kdDebug() << "mIdentity differs : " << mIdentity << " != " << other.mIdentity << endl;
00274 if ( mFullName != other.mFullName ) kdDebug() << "mFullName differs : " << mFullName << " != " << other.mFullName << endl;
00275 if ( mEmailAddr != other.mEmailAddr ) kdDebug() << "mEmailAddr differs : " << mEmailAddr << " != " << other.mEmailAddr << endl;
00276 if ( mEmailAliases != other.mEmailAliases ) kdDebug() << "mEmailAliases differs : " << mEmailAliases.join(";") << " != " << other.mEmailAliases.join(";") << endl;
00277 if ( mOrganization != other.mOrganization ) kdDebug() << "mOrganization differs : " << mOrganization << " != " << other.mOrganization << endl;
00278 if ( mReplyToAddr != other.mReplyToAddr ) kdDebug() << "mReplyToAddr differs : " << mReplyToAddr << " != " << other.mReplyToAddr << endl;
00279 if ( mBcc != other.mBcc ) kdDebug() << "mBcc differs : " << mBcc << " != " << other.mBcc << endl;
00280 if ( mVCardFile != other.mVCardFile ) kdDebug() << "mVCardFile differs : " << mVCardFile << " != " << other.mVCardFile << endl;
00281 if ( mFcc != other.mFcc ) kdDebug() << "mFcc differs : " << mFcc << " != " << other.mFcc << endl;
00282 if ( mPGPEncryptionKey != other.mPGPEncryptionKey ) kdDebug() << "mPGPEncryptionKey differs : " << mPGPEncryptionKey << " != " << other.mPGPEncryptionKey << endl;
00283 if ( mPGPSigningKey != other.mPGPSigningKey ) kdDebug() << "mPGPSigningKey differs : " << mPGPSigningKey << " != " << other.mPGPSigningKey << endl;
00284 if ( mSMIMEEncryptionKey != other.mSMIMEEncryptionKey ) kdDebug() << "mSMIMEEncryptionKey differs : '" << mSMIMEEncryptionKey << "' != '" << other.mSMIMEEncryptionKey << "'" << endl;
00285 if ( mSMIMESigningKey != other.mSMIMESigningKey ) kdDebug() << "mSMIMESigningKey differs : " << mSMIMESigningKey << " != " << other.mSMIMESigningKey << endl;
00286 if ( mPreferredCryptoMessageFormat != other.mPreferredCryptoMessageFormat ) kdDebug() << "mPreferredCryptoMessageFormat differs : " << mPreferredCryptoMessageFormat << " != " << other.mPreferredCryptoMessageFormat << endl;
00287 if ( mDrafts != other.mDrafts ) kdDebug() << "mDrafts differs : " << mDrafts << " != " << other.mDrafts << endl;
00288 if ( mTemplates != other.mTemplates ) kdDebug() << "mTemplates differs : " << mTemplates << " != " << other.mTemplates << endl;
00289 if ( mTransport != other.mTransport ) kdDebug() << "mTransport differs : " << mTransport << " != " << other.mTransport << endl;
00290 if ( mDictionary != other.mDictionary ) kdDebug() << "mDictionary differs : " << mDictionary << " != " << other.mDictionary << endl;
00291 if ( ! ( mSignature == other.mSignature ) ) kdDebug() << "mSignature differs" << endl;
00292 #endif
00293 return same;
00294 }
00295
00296 Identity::Identity( const TQString & id, const TQString & fullName,
00297 const TQString & emailAddr, const TQString & organization,
00298 const TQString & replyToAddr )
00299 : mUoid( 0 ), mIdentity( id ), mFullName( fullName ),
00300 mEmailAddr( emailAddr ), mOrganization( organization ),
00301 mReplyToAddr( replyToAddr ),
00302
00303
00304 mBcc( "" ), mVCardFile( "" ), mPGPEncryptionKey( "" ), mPGPSigningKey( "" ),
00305 mSMIMEEncryptionKey( "" ), mSMIMESigningKey( "" ), mFcc( "" ),
00306 mDrafts( "" ), mTemplates( "" ), mTransport( "" ),
00307 mDictionary( "" ),
00308 mXFace( "" ), mXFaceEnabled( false ),
00309 mIsDefault( false ),
00310 mPreferredCryptoMessageFormat( Kleo::AutoFormat )
00311 {
00312 }
00313
00314 Identity::~Identity()
00315 {
00316 }
00317
00318
00319 void Identity::readConfig( const TDEConfigBase * config )
00320 {
00321 mUoid = config->readUnsignedNumEntry("uoid",0);
00322
00323 mIdentity = config->readEntry("Identity");
00324 mFullName = config->readEntry("Name");
00325 mEmailAddr = config->readEntry("Email Address");
00326 mEmailAliases = config->readListEntry("Email Aliases");
00327 mVCardFile = config->readPathEntry("VCardFile");
00328 mOrganization = config->readEntry("Organization");
00329 mPGPSigningKey = config->readEntry("PGP Signing Key").latin1();
00330 mPGPEncryptionKey = config->readEntry("PGP Encryption Key").latin1();
00331 mSMIMESigningKey = config->readEntry("SMIME Signing Key").latin1();
00332 mSMIMEEncryptionKey = config->readEntry("SMIME Encryption Key").latin1();
00333 mPreferredCryptoMessageFormat = Kleo::stringToCryptoMessageFormat( config->readEntry("Preferred Crypto Message Format", "none" ) );
00334 mReplyToAddr = config->readEntry( "Reply-To Address" );
00335 mBcc = config->readEntry( "Bcc" );
00336 mFcc = config->readEntry( "Fcc", "sent-mail" );
00337 if( mFcc.isEmpty() )
00338 mFcc = "sent-mail";
00339 mDrafts = config->readEntry( "Drafts", "drafts" );
00340 if( mDrafts.isEmpty() )
00341 mDrafts = "drafts";
00342 mTemplates = config->readEntry( "Templates", "templates" );
00343 if( mTemplates.isEmpty() )
00344 mTemplates = "templates";
00345 mTransport = config->readEntry( "Transport" );
00346 mDictionary = config->readEntry( "Dictionary" );
00347 mXFace = config->readEntry( "X-Face" );
00348 mXFaceEnabled = config->readBoolEntry( "X-FaceEnabled", false );
00349
00350 mSignature.readConfig( config );
00351 kdDebug(5006) << "Identity::readConfig(): UOID = " << mUoid
00352 << " for identity named \"" << mIdentity << "\"" << endl;
00353 }
00354
00355
00356 void Identity::writeConfig( TDEConfigBase * config ) const
00357 {
00358 config->writeEntry("uoid", mUoid);
00359
00360 config->writeEntry("Identity", mIdentity);
00361 config->writeEntry("Name", mFullName);
00362 config->writeEntry("Organization", mOrganization);
00363 config->writeEntry("PGP Signing Key", mPGPSigningKey.data());
00364 config->writeEntry("PGP Encryption Key", mPGPEncryptionKey.data());
00365 config->writeEntry("SMIME Signing Key", mSMIMESigningKey.data());
00366 config->writeEntry("SMIME Encryption Key", mSMIMEEncryptionKey.data());
00367 config->writeEntry("Preferred Crypto Message Format", Kleo::cryptoMessageFormatToString( mPreferredCryptoMessageFormat ) );
00368 config->writeEntry("Email Address", mEmailAddr);
00369 config->writeEntry("Email Aliases", mEmailAliases);
00370 config->writeEntry("Reply-To Address", mReplyToAddr);
00371 config->writeEntry("Bcc", mBcc);
00372 config->writePathEntry("VCardFile", mVCardFile);
00373 config->writeEntry("Transport", mTransport);
00374 config->writeEntry("Fcc", mFcc);
00375 config->writeEntry("Drafts", mDrafts);
00376 config->writeEntry("Templates", mTemplates);
00377 config->writeEntry( "Dictionary", mDictionary );
00378 config->writeEntry( "X-Face", mXFace );
00379 config->writeEntry( "X-FaceEnabled", mXFaceEnabled );
00380
00381 mSignature.writeConfig( config );
00382 }
00383
00384 TQDataStream & KPIM::operator<<( TQDataStream & stream, const KPIM::Identity & i ) {
00385 return stream << static_cast<TQ_UINT32>(i.uoid())
00386 << i.identityName()
00387 << i.fullName()
00388 << i.organization()
00389 << i.pgpSigningKey()
00390 << i.pgpEncryptionKey()
00391 << i.smimeSigningKey()
00392 << i.smimeEncryptionKey()
00393 << i.primaryEmailAddress()
00394 << i.emailAliases()
00395 << i.replyToAddr()
00396 << i.bcc()
00397 << i.vCardFile()
00398 << i.transport()
00399 << i.fcc()
00400 << i.drafts()
00401 << i.templates()
00402 << i.mSignature
00403 << i.dictionary()
00404 << i.xface()
00405 << TQString( Kleo::cryptoMessageFormatToString( i.mPreferredCryptoMessageFormat ) );
00406 }
00407
00408 TQDataStream & KPIM::operator>>( TQDataStream & stream, KPIM::Identity & i ) {
00409 TQ_UINT32 uoid;
00410 TQString format;
00411 stream >> uoid
00412 >> i.mIdentity
00413 >> i.mFullName
00414 >> i.mOrganization
00415 >> i.mPGPSigningKey
00416 >> i.mPGPEncryptionKey
00417 >> i.mSMIMESigningKey
00418 >> i.mSMIMEEncryptionKey
00419 >> i.mEmailAddr
00420 >> i.mEmailAliases
00421 >> i.mReplyToAddr
00422 >> i.mBcc
00423 >> i.mVCardFile
00424 >> i.mTransport
00425 >> i.mFcc
00426 >> i.mDrafts
00427 >> i.mTemplates
00428 >> i.mSignature
00429 >> i.mDictionary
00430 >> i.mXFace
00431 >> format;
00432 i.mUoid = uoid;
00433 i.mPreferredCryptoMessageFormat = Kleo::stringToCryptoMessageFormat( format.latin1() );
00434
00435 return stream;
00436 }
00437
00438
00439 bool Identity::mailingAllowed() const
00440 {
00441 return !mEmailAddr.isEmpty();
00442 }
00443
00444
00445 void Identity::setIsDefault( bool flag ) {
00446 mIsDefault = flag;
00447 }
00448
00449 void Identity::setIdentityName( const TQString & name ) {
00450 mIdentity = name;
00451 }
00452
00453 void Identity::setFullName(const TQString &str)
00454 {
00455 mFullName = str;
00456 }
00457
00458
00459
00460 void Identity::setOrganization(const TQString &str)
00461 {
00462 mOrganization = str;
00463 }
00464
00465 void Identity::setPGPSigningKey(const TQCString &str)
00466 {
00467 mPGPSigningKey = str;
00468 if ( mPGPSigningKey.isNull() )
00469 mPGPSigningKey = "";
00470 }
00471
00472 void Identity::setPGPEncryptionKey(const TQCString &str)
00473 {
00474 mPGPEncryptionKey = str;
00475 if ( mPGPEncryptionKey.isNull() )
00476 mPGPEncryptionKey = "";
00477 }
00478
00479 void Identity::setSMIMESigningKey(const TQCString &str)
00480 {
00481 mSMIMESigningKey = str;
00482 if ( mSMIMESigningKey.isNull() )
00483 mSMIMESigningKey = "";
00484 }
00485
00486 void Identity::setSMIMEEncryptionKey(const TQCString &str)
00487 {
00488 mSMIMEEncryptionKey = str;
00489 if ( mSMIMEEncryptionKey.isNull() )
00490 mSMIMEEncryptionKey = "";
00491 }
00492
00493
00494 void Identity::setPrimaryEmailAddress( const TQString & str )
00495 {
00496 mEmailAddr = str;
00497 }
00498
00499 void Identity::setEmailAliases( const TQStringList & list )
00500 {
00501 mEmailAliases = list;
00502 }
00503
00504 bool Identity::matchesEmailAddress( const TQString & addr ) const
00505 {
00506 const TQString lower = addr.lower();
00507 if ( lower == mEmailAddr.lower() )
00508 return true;
00509 for ( TQStringList::const_iterator it = mEmailAliases.begin(), end = mEmailAliases.end() ; it != end ; ++it )
00510 if ( (*it).lower() == lower )
00511 return true;
00512 return false;
00513 }
00514
00515
00516 void Identity::setVCardFile(const TQString &str)
00517 {
00518 mVCardFile = str;
00519 }
00520
00521
00522
00523 TQString Identity::fullEmailAddr(void) const
00524 {
00525 if (mFullName.isEmpty()) return mEmailAddr;
00526
00527 const TQString specials("()<>@,.;:[]");
00528
00529 TQString result;
00530
00531
00532 bool needsQuotes=false;
00533 for (unsigned int i=0; i < mFullName.length(); i++) {
00534 if ( specials.contains( mFullName[i] ) )
00535 needsQuotes = true;
00536 else if ( mFullName[i] == '\\' || mFullName[i] == '"' ) {
00537 needsQuotes = true;
00538 result += '\\';
00539 }
00540 result += mFullName[i];
00541 }
00542
00543 if (needsQuotes) {
00544 result.insert(0,'"');
00545 result += '"';
00546 }
00547
00548 result += " <" + mEmailAddr + '>';
00549
00550 return result;
00551 }
00552
00553
00554 void Identity::setReplyToAddr(const TQString& str)
00555 {
00556 mReplyToAddr = str;
00557 }
00558
00559
00560
00561 void Identity::setSignatureFile(const TQString &str)
00562 {
00563 mSignature.setUrl( str, signatureIsCommand() );
00564 }
00565
00566
00567
00568 void Identity::setSignatureInlineText(const TQString &str )
00569 {
00570 mSignature.setText( str );
00571 }
00572
00573
00574
00575 void Identity::setTransport( const TQString &str )
00576 {
00577 mTransport = str;
00578 if ( mTransport.isNull() )
00579 mTransport = "";
00580 }
00581
00582
00583 void Identity::setFcc( const TQString &str )
00584 {
00585 mFcc = str;
00586 if ( mFcc.isNull() )
00587 mFcc = "";
00588 }
00589
00590
00591 void Identity::setDrafts( const TQString &str )
00592 {
00593 mDrafts = str;
00594 if ( mDrafts.isNull() )
00595 mDrafts = "";
00596 }
00597
00598
00599 void Identity::setTemplates( const TQString &str )
00600 {
00601 mTemplates = str;
00602 if ( mTemplates.isNull() )
00603 mTemplates = "";
00604 }
00605
00606
00607 void Identity::setDictionary( const TQString &str )
00608 {
00609 mDictionary = str;
00610 if ( mDictionary.isNull() )
00611 mDictionary = "";
00612 }
00613
00614
00615
00616 void Identity::setXFace( const TQString &str )
00617 {
00618 mXFace = str;
00619 mXFace.remove( " " );
00620 mXFace.remove( "\n" );
00621 mXFace.remove( "\r" );
00622 }
00623
00624
00625
00626 void Identity::setXFaceEnabled( const bool on )
00627 {
00628 mXFaceEnabled = on;
00629 }
00630
00631
00632
00633 TQString Identity::signatureText( bool * ok ) const
00634 {
00635 bool internalOK = false;
00636 TQString signatureText = mSignature.withSeparator( &internalOK );
00637 if ( internalOK ) {
00638 if ( ok ) *ok=true;
00639 return signatureText;
00640 }
00641
00642
00643
00644
00645 if ( ok ) *ok = false;
00646 return TQString();
00647
00648 #if 0 // ### FIXME: error handling
00649 if (mSignatureFile.endsWith("|"))
00650 {
00651 }
00652 else
00653 {
00654 }
00655 #endif
00656
00657 return TQString();
00658 }