00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include <config.h>
00021
00022 #include "kmfolder.h"
00023 #include "kmfolderdir.h"
00024 #include "kmfoldermbox.h"
00025 #include "folderstorage.h"
00026 #include "kmfoldercachedimap.h"
00027 #include "kmfoldersearch.h"
00028 #include "kmfolderimap.h"
00029 #include "kmfoldermgr.h"
00030 #include <libkpimidentities/identitymanager.h>
00031 #include <libkpimidentities/identity.h>
00032 #include "expirejob.h"
00033 #include "compactionjob.h"
00034 #include "kmfoldertree.h"
00035 #include "kmailicalifaceimpl.h"
00036 #include "kmaccount.h"
00037
00038 #include <errno.h>
00039
00040 #include <kdebug.h>
00041 #include <klocale.h>
00042 #include <kshortcut.h>
00043 #include <kmessagebox.h>
00044 #include <qfile.h>
00045 #include <qfileinfo.h>
00046
00047
00048 KMFolder::KMFolder( KMFolderDir* aParent, const QString& aFolderName,
00049 KMFolderType aFolderType, bool withIndex, bool exportedSernums )
00050 : KMFolderNode( aParent, aFolderName ), mStorage(0),
00051 mChild( 0 ),
00052 mIsSystemFolder( false ),
00053 mHasIndex( withIndex ),
00054 mExportsSernums( exportedSernums ),
00055 mMoveInProgress( false ),
00056 mExpireMessages( false ), mUnreadExpireAge( 28 ),
00057 mReadExpireAge( 14 ), mUnreadExpireUnits( expireNever ),
00058 mReadExpireUnits( expireNever ),
00059 mExpireAction( ExpireDelete ),
00060 mUseCustomIcons( false ), mMailingListEnabled( false ),
00061 mAcctList( 0 ),
00062 mIdentity( 0 ),
00063 mPutRepliesInSameFolder( false ),
00064 mIgnoreNewMail( false )
00065 {
00066 if( aFolderType == KMFolderTypeCachedImap )
00067 mStorage = new KMFolderCachedImap( this, aFolderName.latin1() );
00068 else if( aFolderType == KMFolderTypeImap )
00069 mStorage = new KMFolderImap( this, aFolderName.latin1() );
00070 else if( aFolderType == KMFolderTypeMaildir )
00071 mStorage = new KMFolderMaildir( this, aFolderName.latin1() );
00072 else if( aFolderType == KMFolderTypeSearch )
00073 mStorage = new KMFolderSearch( this, aFolderName.latin1() );
00074 else
00075 mStorage = new KMFolderMbox( this, aFolderName.latin1() );
00076
00077 assert( mStorage );
00078
00079 QFileInfo dirinfo;
00080 dirinfo.setFile( mStorage->location() );
00081 if ( !dirinfo.exists() ) {
00082 int rc = mStorage->create();
00083 QString msg = i18n("<qt>Error while creating file <b>%1</b>:<br>%2</qt>").arg(aFolderName).arg(strerror(rc));
00084 if ( rc ) {
00085 KMessageBox::information(0, msg);
00086 }
00087 }
00088
00089 if ( aParent ) {
00090 connect( mStorage, SIGNAL( msgAdded( KMFolder*, Q_UINT32 ) ),
00091 aParent->manager(), SIGNAL( msgAdded( KMFolder*, Q_UINT32 ) ) );
00092 connect( mStorage, SIGNAL( msgRemoved( KMFolder*, Q_UINT32 ) ),
00093 parent()->manager(), SIGNAL( msgRemoved( KMFolder*, Q_UINT32 ) ) );
00094 connect( this, SIGNAL( msgChanged( KMFolder*, Q_UINT32, int ) ),
00095 parent()->manager(), SIGNAL( msgChanged( KMFolder*, Q_UINT32, int ) ) );
00096 connect( this, SIGNAL( msgHeaderChanged( KMFolder*, int ) ),
00097 parent()->manager(), SIGNAL( msgHeaderChanged( KMFolder*, int ) ) );
00098 connect( mStorage, SIGNAL( invalidated( KMFolder* ) ),
00099 parent()->manager(), SIGNAL( folderInvalidated( KMFolder* ) ) );
00100 }
00101
00102
00103 connect( mStorage, SIGNAL( changed() ), SIGNAL( changed() ) );
00104 connect( mStorage, SIGNAL( cleared() ), SIGNAL( cleared() ) );
00105 connect( mStorage, SIGNAL( expunged( KMFolder* ) ),
00106 SIGNAL( expunged( KMFolder* ) ) );
00107 connect( mStorage, SIGNAL( nameChanged() ), SIGNAL( nameChanged() ) );
00108 connect( mStorage, SIGNAL( msgRemoved( KMFolder*, Q_UINT32 ) ),
00109 SIGNAL( msgRemoved( KMFolder*, Q_UINT32 ) ) );
00110 connect( mStorage, SIGNAL( msgRemoved( int, QString ) ),
00111 SIGNAL( msgRemoved( int, QString ) ) );
00112 connect( mStorage, SIGNAL( msgRemoved( KMFolder* ) ),
00113 SIGNAL( msgRemoved( KMFolder* ) ) );
00114 connect( mStorage, SIGNAL( msgAdded( int ) ), SIGNAL( msgAdded( int ) ) );
00115 connect( mStorage, SIGNAL( msgAdded( KMFolder*, Q_UINT32 ) ),
00116 SIGNAL( msgAdded( KMFolder*, Q_UINT32 ) ) );
00117 connect( mStorage, SIGNAL( msgChanged( KMFolder*, Q_UINT32 , int ) ),
00118 SIGNAL( msgChanged( KMFolder*, Q_UINT32 , int ) ) );
00119 connect( mStorage, SIGNAL( msgHeaderChanged( KMFolder*, int ) ),
00120 SIGNAL( msgHeaderChanged( KMFolder*, int ) ) );
00121 connect( mStorage, SIGNAL( statusMsg( const QString& ) ),
00122 SIGNAL( statusMsg( const QString& ) ) );
00123 connect( mStorage, SIGNAL( numUnreadMsgsChanged( KMFolder* ) ),
00124 SIGNAL( numUnreadMsgsChanged( KMFolder* ) ) );
00125 connect( mStorage, SIGNAL( removed( KMFolder*, bool ) ),
00126 SIGNAL( removed( KMFolder*, bool ) ) );
00127 connect( mStorage, SIGNAL(noContentChanged()),
00128 SIGNAL(noContentChanged()) );
00129
00130 connect( mStorage, SIGNAL( contentsTypeChanged( KMail::FolderContentsType ) ),
00131 this, SLOT( slotContentsTypeChanged( KMail::FolderContentsType ) ) );
00132
00133 connect( mStorage, SIGNAL( folderSizeChanged() ),
00134 this, SLOT( slotFolderSizeChanged() ) );
00135
00136
00137
00138
00139 mStorage->readConfig();
00140
00141
00142 if ( mExportsSernums )
00143 mStorage->registerWithMessageDict();
00144 if ( !mHasIndex )
00145 mStorage->setAutoCreateIndex( false );
00146
00147 if ( mId == 0 && aParent )
00148 mId = aParent->manager()->createId();
00149 }
00150
00151 KMFolder::~KMFolder()
00152 {
00153 mStorage->close( "~KMFolder", true );
00154 delete mAcctList;
00155 if ( mHasIndex ) mStorage->deregisterFromMessageDict();
00156 delete mStorage;
00157 }
00158
00159 void KMFolder::readConfig( KConfig* config )
00160 {
00161 if ( !config->readEntry("SystemLabel").isEmpty() )
00162 mSystemLabel = config->readEntry("SystemLabel");
00163 mExpireMessages = config->readBoolEntry("ExpireMessages", false);
00164 mReadExpireAge = config->readNumEntry("ReadExpireAge", 3);
00165 mReadExpireUnits = (ExpireUnits)config->readNumEntry("ReadExpireUnits", expireMonths);
00166 mUnreadExpireAge = config->readNumEntry("UnreadExpireAge", 12);
00167 mUnreadExpireUnits = (ExpireUnits)config->readNumEntry("UnreadExpireUnits", expireNever);
00168 mExpireAction = config->readEntry("ExpireAction", "Delete") == "Move" ? ExpireMove : ExpireDelete;
00169 mExpireToFolderId = config->readEntry("ExpireToFolder");
00170
00171 mUseCustomIcons = config->readBoolEntry("UseCustomIcons", false );
00172 mNormalIconPath = config->readEntry("NormalIconPath" );
00173 mUnreadIconPath = config->readEntry("UnreadIconPath" );
00174
00175 mMailingListEnabled = config->readBoolEntry("MailingListEnabled");
00176 mMailingList.readConfig( config );
00177
00178 mIdentity = config->readUnsignedNumEntry("Identity",0);
00179
00180 setUserWhoField( config->readEntry("WhoField"), false );
00181 uint savedId = config->readUnsignedNumEntry("Id", 0);
00182
00183 if ( savedId != 0 && mId == 0 )
00184 mId = savedId;
00185 mPutRepliesInSameFolder = config->readBoolEntry( "PutRepliesInSameFolder", false );
00186 mIgnoreNewMail = config->readBoolEntry( "IgnoreNewMail", false );
00187
00188 if ( mUseCustomIcons )
00189 emit iconsChanged();
00190
00191 QString shortcut( config->readEntry( "Shortcut" ) );
00192 if ( !shortcut.isEmpty() ) {
00193 KShortcut sc( shortcut );
00194 setShortcut( sc );
00195 }
00196 }
00197
00198 void KMFolder::writeConfig( KConfig* config ) const
00199 {
00200 config->writeEntry("SystemLabel", mSystemLabel);
00201 config->writeEntry("ExpireMessages", mExpireMessages);
00202 config->writeEntry("ReadExpireAge", mReadExpireAge);
00203 config->writeEntry("ReadExpireUnits", mReadExpireUnits);
00204 config->writeEntry("UnreadExpireAge", mUnreadExpireAge);
00205 config->writeEntry("UnreadExpireUnits", mUnreadExpireUnits);
00206 config->writeEntry("ExpireAction", mExpireAction == ExpireDelete ? "Delete" : "Move");
00207 config->writeEntry("ExpireToFolder", mExpireToFolderId);
00208
00209 config->writeEntry("UseCustomIcons", mUseCustomIcons);
00210 config->writeEntry("NormalIconPath", mNormalIconPath);
00211 config->writeEntry("UnreadIconPath", mUnreadIconPath);
00212
00213 config->writeEntry("MailingListEnabled", mMailingListEnabled);
00214 mMailingList.writeConfig( config );
00215
00216 if ( mIdentity != 0 && ( !mStorage || !mStorage->account() || mIdentity != mStorage->account()->identityId() ) )
00217 config->writeEntry("Identity", mIdentity);
00218 else
00219 config->deleteEntry("Identity");
00220
00221 config->writeEntry("WhoField", mUserWhoField);
00222 config->writeEntry("Id", mId);
00223 config->writeEntry( "PutRepliesInSameFolder", mPutRepliesInSameFolder );
00224 config->writeEntry( "IgnoreNewMail", mIgnoreNewMail );
00225 if ( !mShortcut.isNull() )
00226 config->writeEntry( "Shortcut", mShortcut.toString() );
00227 else
00228 config->deleteEntry( "Shortcut" );
00229 }
00230
00231 KMFolderType KMFolder::folderType() const
00232 {
00233 return mStorage ? mStorage->folderType() : KMFolderTypeUnknown;
00234 }
00235
00236 QString KMFolder::fileName() const
00237 {
00238 return mStorage ? mStorage->fileName() : QString::null;
00239 }
00240
00241 QString KMFolder::location() const
00242 {
00243 return mStorage ? mStorage->location() : QString::null;
00244 }
00245
00246 QString KMFolder::indexLocation() const
00247 {
00248 return mStorage ? mStorage->indexLocation() : QString::null;
00249 }
00250
00251 QString KMFolder::subdirLocation() const
00252 {
00253 QString sLocation( path() );
00254
00255 if( !sLocation.isEmpty() )
00256 sLocation += '/';
00257 sLocation += '.' + FolderStorage::dotEscape( fileName() ) + ".directory";
00258
00259 return sLocation;
00260 }
00261
00262 KMFolderDir* KMFolder::createChildFolder()
00263 {
00264 if( mChild )
00265 return mChild;
00266
00267 QString childName = "." + fileName() + ".directory";
00268 QString childDir = path() + "/" + childName;
00269 if (access(QFile::encodeName(childDir), W_OK) != 0)
00270 {
00271 if (mkdir(QFile::encodeName(childDir), S_IRWXU) != 0
00272 && chmod(QFile::encodeName(childDir), S_IRWXU) != 0) {
00273 QString wmsg = QString(" '%1': %2").arg(childDir).arg(strerror(errno));
00274 KMessageBox::information(0,i18n("Failed to create folder") + wmsg);
00275 return 0;
00276 }
00277 }
00278
00279 KMFolderDirType newType = KMStandardDir;
00280 if( folderType() == KMFolderTypeCachedImap )
00281 newType = KMDImapDir;
00282 else if( folderType() == KMFolderTypeImap )
00283 newType = KMImapDir;
00284
00285 mChild = new KMFolderDir( this, parent(), childName, newType );
00286 if( !mChild )
00287 return 0;
00288 mChild->reload();
00289 parent()->append( mChild );
00290 return mChild;
00291 }
00292
00293 void KMFolder::setChild( KMFolderDir* aChild )
00294 {
00295 mChild = aChild;
00296 mStorage->updateChildrenState();
00297 }
00298
00299 bool KMFolder::noContent() const
00300 {
00301 return mStorage ? mStorage->noContent() : true;
00302 }
00303
00304 void KMFolder::setNoContent( bool aNoContent )
00305 {
00306 mStorage->setNoContent( aNoContent );
00307 }
00308
00309 bool KMFolder::noChildren() const
00310 {
00311 return mStorage->noChildren();
00312 }
00313
00314 void KMFolder::setNoChildren( bool aNoChildren )
00315 {
00316 mStorage->setNoChildren( aNoChildren );
00317 }
00318
00319 KMMessage* KMFolder::getMsg( int idx )
00320 {
00321 return mStorage->getMsg( idx );
00322 }
00323
00324 KMMsgInfo* KMFolder::unGetMsg( int idx )
00325 {
00326 return mStorage->unGetMsg( idx );
00327 }
00328
00329 bool KMFolder::isMessage( int idx )
00330 {
00331 return mStorage->isMessage( idx );
00332 }
00333
00334 DwString KMFolder::getDwString( int idx )
00335 {
00336 return mStorage->getDwString( idx );
00337 }
00338
00339 void KMFolder::ignoreJobsForMessage( KMMessage* m )
00340 {
00341 mStorage->ignoreJobsForMessage( m );
00342 }
00343
00344 FolderJob* KMFolder::createJob( KMMessage *msg, FolderJob::JobType jt,
00345 KMFolder *folder, QString partSpecifier,
00346 const AttachmentStrategy *as ) const
00347 {
00348 return mStorage->createJob( msg, jt, folder, partSpecifier, as );
00349 }
00350
00351 FolderJob* KMFolder::createJob( QPtrList<KMMessage>& msgList,
00352 const QString& sets,
00353 FolderJob::JobType jt, KMFolder *folder ) const
00354 {
00355 return mStorage->createJob( msgList, sets, jt, folder );
00356 }
00357
00358 const KMMsgBase* KMFolder::getMsgBase( int idx ) const
00359 {
00360 return mStorage->getMsgBase( idx );
00361 }
00362
00363 KMMsgBase* KMFolder::getMsgBase( int idx )
00364 {
00365 return mStorage->getMsgBase( idx );
00366 }
00367
00368 const KMMsgBase* KMFolder::operator[]( int idx ) const
00369 {
00370 return mStorage->operator[]( idx );
00371 }
00372
00373 KMMsgBase* KMFolder::operator[]( int idx )
00374 {
00375 return mStorage->operator[]( idx );
00376 }
00377
00378 KMMessage* KMFolder::take( int idx )
00379 {
00380 return mStorage->take( idx );
00381 }
00382
00383 void KMFolder::take( QPtrList<KMMessage> msgList )
00384 {
00385 mStorage->take( msgList );
00386 }
00387
00388 int KMFolder::addMsg( KMMessage* msg, int* index_return )
00389 {
00390 return mStorage->addMsg( msg, index_return );
00391 }
00392
00393 int KMFolder::addMsgKeepUID( KMMessage* msg, int* index_return )
00394 {
00395 return mStorage->addMsgKeepUID( msg, index_return );
00396 }
00397
00398 int KMFolder::addMsg( QPtrList<KMMessage>& list, QValueList<int>& index_return )
00399 {
00400 return mStorage->addMsg( list, index_return );
00401 }
00402
00403 void KMFolder::emitMsgAddedSignals( int idx )
00404 {
00405 mStorage->emitMsgAddedSignals( idx );
00406 }
00407
00408 void KMFolder::removeMsg( int i, bool imapQuiet )
00409 {
00410 mStorage->removeMsg( i, imapQuiet );
00411 }
00412
00413 void KMFolder::removeMsg( QPtrList<KMMessage> msgList, bool imapQuiet )
00414 {
00415 mStorage->removeMsg( msgList, imapQuiet );
00416 }
00417
00418 int KMFolder::expungeOldMsg( int days )
00419 {
00420 return mStorage->expungeOldMsg( days );
00421 }
00422
00423 int KMFolder::moveMsg( KMMessage* msg, int* index_return )
00424 {
00425 return mStorage->moveMsg( msg, index_return );
00426 }
00427
00428 int KMFolder::moveMsg(QPtrList<KMMessage> q, int* index_return )
00429 {
00430 return mStorage->moveMsg( q, index_return );
00431 }
00432
00433 int KMFolder::find( const KMMsgBase* msg ) const
00434 {
00435 return mStorage ? mStorage->find( msg ) : -1;
00436 }
00437
00438 int KMFolder::find( const KMMessage* msg ) const
00439 {
00440 return mStorage ? mStorage->find( msg ) : -1;
00441 }
00442
00443 int KMFolder::count( bool cache ) const
00444 {
00445 return mStorage->count( cache );
00446 }
00447
00448 int KMFolder::countUnread()
00449 {
00450 return mStorage->countUnread();
00451 }
00452
00453 int KMFolder::countUnreadRecursive()
00454 {
00455 KMFolder *folder;
00456 int count = countUnread();
00457 KMFolderDir *dir = child();
00458 if (!dir)
00459 return count;
00460
00461 QPtrListIterator<KMFolderNode> it(*dir);
00462 for ( ; it.current(); ++it )
00463 if (!it.current()->isDir()) {
00464 folder = static_cast<KMFolder*>(it.current());
00465 count += folder->countUnreadRecursive();
00466 }
00467
00468 return count;
00469 }
00470
00471 void KMFolder::msgStatusChanged( const KMMsgStatus oldStatus,
00472 const KMMsgStatus newStatus, int idx )
00473 {
00474 mStorage->msgStatusChanged( oldStatus, newStatus, idx );
00475 }
00476
00477 int KMFolder::open(const char *owner)
00478 {
00479 return mStorage->open(owner);
00480 }
00481
00482 int KMFolder::canAccess()
00483 {
00484 return mStorage->canAccess();
00485 }
00486
00487 void KMFolder::close( const char *owner, bool force )
00488 {
00489
00490 mStorage->close( owner, force );
00491 }
00492
00493 void KMFolder::sync()
00494 {
00495 mStorage->sync();
00496 }
00497
00498 bool KMFolder::isOpened() const
00499 {
00500 return mStorage->isOpened();
00501 }
00502
00503 void KMFolder::markNewAsUnread()
00504 {
00505 mStorage->markNewAsUnread();
00506 }
00507
00508 void KMFolder::markUnreadAsRead()
00509 {
00510 mStorage->markUnreadAsRead();
00511 }
00512
00513 void KMFolder::remove()
00514 {
00515
00516
00517
00518
00519
00520 mStorage->open("kmfolder_remove");
00521 mStorage->remove();
00522 }
00523
00524 int KMFolder::expunge()
00525 {
00526 return mStorage->expunge();
00527 }
00528
00529 int KMFolder::rename( const QString& newName, KMFolderDir *aParent )
00530 {
00531 return mStorage->rename( newName, aParent );
00532 }
00533
00534 bool KMFolder::dirty() const
00535 {
00536 return mStorage->dirty();
00537 }
00538
00539 void KMFolder::setDirty( bool f )
00540 {
00541 mStorage->setDirty( f );
00542 }
00543
00544 bool KMFolder::needsCompacting() const
00545 {
00546 return mStorage->needsCompacting();
00547 }
00548
00549 void KMFolder::setNeedsCompacting( bool f )
00550 {
00551 mStorage->setNeedsCompacting( f );
00552 }
00553
00554 void KMFolder::quiet( bool beQuiet )
00555 {
00556 mStorage->quiet( beQuiet );
00557 }
00558
00559 bool KMFolder::isReadOnly() const
00560 {
00561 return mStorage->isReadOnly();
00562 }
00563
00564 bool KMFolder::mailCheckInProgress() const
00565 {
00566 return mStorage->mailCheckInProgress();
00567 }
00568
00569 bool KMFolder::isWritable() const
00570 {
00571 return !mStorage->isReadOnly() && mStorage->canDeleteMessages();
00572 }
00573
00574 bool KMFolder::canDeleteMessages() const
00575 {
00576 return mStorage->canDeleteMessages();
00577 }
00578
00579 QString KMFolder::label() const
00580 {
00581 if ( !mSystemLabel.isEmpty() )
00582 return mSystemLabel;
00583 if ( !mLabel.isEmpty() )
00584 return mLabel;
00585 if ( isSystemFolder() )
00586 return i18n( name().utf8() );
00587 return name();
00588 }
00589
00590
00591 QString KMFolder::prettyURL() const
00592 {
00593 QString parentUrl;
00594 if ( parent() )
00595 parentUrl = parent()->prettyURL();
00596 if ( !parentUrl.isEmpty() )
00597 return parentUrl + '/' + label();
00598 else
00599 return label();
00600 }
00601
00602
00603 QString KMFolder::mailingListPostAddress() const
00604 {
00605 if ( mMailingList.features() & MailingList::Post ) {
00606 KURL::List::const_iterator it;
00607 KURL::List post = mMailingList.postURLS();
00608 for( it = post.begin(); it != post.end(); ++it ) {
00609
00610
00611 if ( (*it).protocol() == "mailto" || (*it).protocol().isEmpty() )
00612 return (*it).path();
00613 }
00614 }
00615 return QString::null;
00616 }
00617
00618 void KMFolder::setMailingListEnabled( bool enabled )
00619 {
00620 mMailingListEnabled = enabled;
00621 mStorage->writeConfig();
00622 }
00623
00624 void KMFolder::setMailingList( const MailingList& mlist )
00625 {
00626 mMailingList = mlist;
00627 mStorage->writeConfig();
00628 }
00629
00630 void KMFolder::setIdentity( uint identity )
00631 {
00632 mIdentity = identity;
00633 kmkernel->slotRequestConfigSync();
00634 }
00635
00636 uint KMFolder::identity() const
00637 {
00638
00639 kdDebug() << "FOO: " << mIdentity << " :: " << mStorage << endl;
00640 if ( !mIdentity && mStorage )
00641 if ( KMAccount *act = mStorage->account() )
00642 return act->identityId();
00643 return mIdentity;
00644 }
00645
00646 void KMFolder::setWhoField(const QString& aWhoField )
00647 {
00648 mWhoField = aWhoField;
00649 #if 0
00650
00651 mStorage->writeConfig();
00652 #endif
00653 }
00654
00655 void KMFolder::setUserWhoField( const QString& whoField, bool writeConfig )
00656 {
00657 if ( mUserWhoField == whoField )
00658 return;
00659 if ( whoField.isEmpty() )
00660 {
00661
00662 const KPIM::Identity & identity =
00663 kmkernel->identityManager()->identityForUoidOrDefault( mIdentity );
00664
00665 if ( isSystemFolder() && folderType() != KMFolderTypeImap ) {
00666
00667 if ( this == kmkernel->inboxFolder() ||
00668 this == kmkernel->trashFolder() )
00669 mWhoField = "From";
00670 if ( this == kmkernel->outboxFolder() ||
00671 this == kmkernel->sentFolder() ||
00672 this == kmkernel->draftsFolder() ||
00673 this == kmkernel->templatesFolder() )
00674 mWhoField = "To";
00675 } else if ( identity.drafts() == idString() ||
00676 identity.templates() == idString() ||
00677 identity.fcc() == idString() )
00678
00679 mWhoField = "To";
00680 else
00681 mWhoField = "From";
00682 } else if ( whoField == "From" || whoField == "To" )
00683
00684 mWhoField = whoField;
00685 else {
00686
00687 kdDebug(5006) << "Illegal setting " << whoField << " for userWhoField!"
00688 << endl;
00689 return;
00690 }
00691 mUserWhoField = whoField;
00692
00693 if (writeConfig)
00694 mStorage->writeConfig();
00695 emit viewConfigChanged();
00696 }
00697
00698 void KMFolder::correctUnreadMsgsCount()
00699 {
00700 mStorage->correctUnreadMsgsCount();
00701 }
00702
00703 QString KMFolder::idString() const
00704 {
00705 KMFolderNode* folderNode = parent();
00706 if (!folderNode)
00707 return "";
00708 while ( folderNode->parent() )
00709 folderNode = folderNode->parent();
00710 QString myPath = path();
00711 int pathLen = myPath.length() - folderNode->path().length();
00712 QString relativePath = myPath.right( pathLen );
00713 if (!relativePath.isEmpty())
00714 relativePath = relativePath.right( relativePath.length() - 1 ) + "/";
00715 QString escapedName = name();
00716
00717
00718 escapedName.replace( "[", "%(" );
00719 escapedName.replace( "]", "%)" );
00720 return relativePath + escapedName;
00721 }
00722
00723 void KMFolder::setAutoExpire( bool enabled )
00724 {
00725 if( enabled != mExpireMessages ) {
00726 mExpireMessages = enabled;
00727 mStorage->writeConfig();
00728 }
00729 }
00730
00731 void KMFolder::setUnreadExpireAge( int age )
00732 {
00733 if( age >= 0 && age != mUnreadExpireAge ) {
00734 mUnreadExpireAge = age;
00735 mStorage->writeConfig();
00736 }
00737 }
00738
00739 void KMFolder::setUnreadExpireUnits( ExpireUnits units )
00740 {
00741 if (units >= expireNever && units < expireMaxUnits)
00742 mUnreadExpireUnits = units;
00743 mStorage->writeConfig();
00744 }
00745
00746 void KMFolder::setReadExpireAge( int age )
00747 {
00748 if( age >= 0 && age != mReadExpireAge ) {
00749 mReadExpireAge = age;
00750 mStorage->writeConfig();
00751 }
00752 }
00753
00754 void KMFolder::setReadExpireUnits( ExpireUnits units )
00755 {
00756 if (units >= expireNever && units <= expireMaxUnits)
00757 mReadExpireUnits = units;
00758 mStorage->writeConfig();
00759 }
00760
00761
00762 void KMFolder::setExpireAction( ExpireAction a )
00763 {
00764 if ( a != mExpireAction ) {
00765 mExpireAction = a;
00766 mStorage->writeConfig();
00767 }
00768 }
00769
00770 void KMFolder::setExpireToFolderId( const QString& id )
00771 {
00772 if ( id != mExpireToFolderId ) {
00773 mExpireToFolderId = id;
00774 mStorage->writeConfig();
00775 }
00776 }
00777
00778
00779 static int daysToExpire( int number, ExpireUnits units )
00780 {
00781 switch (units) {
00782 case expireDays:
00783 return number;
00784 case expireWeeks:
00785 return number * 7;
00786 case expireMonths:
00787 return number * 31;
00788 default:
00789 ;
00790 }
00791 return -1;
00792 }
00793
00794 void KMFolder::daysToExpire(int& unreadDays, int& readDays) {
00795 unreadDays = ::daysToExpire( getUnreadExpireAge(), getUnreadExpireUnits() );
00796 readDays = ::daysToExpire( getReadExpireAge(), getReadExpireUnits() );
00797 }
00798
00799 void KMFolder::expireOldMessages( bool immediate )
00800 {
00801 KMail::ScheduledExpireTask* task = new KMail::ScheduledExpireTask(this, immediate);
00802 kmkernel->jobScheduler()->registerTask( task );
00803 if ( immediate ) {
00804
00805 compact( CompactLater );
00806 }
00807 }
00808
00809 void KMFolder::compact( CompactOptions options )
00810 {
00811 if ( options == CompactLater ) {
00812 KMail::ScheduledCompactionTask* task = new KMail::ScheduledCompactionTask(this, false);
00813 kmkernel->jobScheduler()->registerTask( task );
00814 } else {
00815 mStorage->compact( options == CompactSilentlyNow );
00816 }
00817 }
00818
00819 KMFolder* KMFolder::trashFolder() const
00820 {
00821 return mStorage ? mStorage->trashFolder() : 0;
00822 }
00823
00824 int KMFolder::writeIndex( bool createEmptyIndex )
00825 {
00826 return mStorage->writeIndex( createEmptyIndex );
00827 }
00828
00829 void KMFolder::setStatus( int idx, KMMsgStatus status, bool toggle )
00830 {
00831 mStorage->setStatus( idx, status, toggle );
00832 }
00833
00834 void KMFolder::setStatus( QValueList<int>& ids, KMMsgStatus status,
00835 bool toggle )
00836 {
00837 mStorage->setStatus( ids, status, toggle);
00838 }
00839
00840 void KMFolder::setIconPaths( const QString &normalPath,
00841 const QString &unreadPath )
00842 {
00843 mNormalIconPath = normalPath;
00844 mUnreadIconPath = unreadPath;
00845 mStorage->writeConfig();
00846 emit iconsChanged();
00847 }
00848
00849 void KMFolder::removeJobs()
00850 {
00851 mStorage->removeJobs();
00852 }
00853
00854 int KMFolder::updateIndex()
00855 {
00856 return mStorage->updateIndex();
00857 }
00858
00859 void KMFolder::reallyAddMsg( KMMessage* aMsg )
00860 {
00861 mStorage->reallyAddMsg( aMsg );
00862 }
00863
00864 void KMFolder::reallyAddCopyOfMsg( KMMessage* aMsg )
00865 {
00866 mStorage->reallyAddCopyOfMsg( aMsg );
00867 }
00868
00869 void KMFolder::setShortcut( const KShortcut &sc )
00870 {
00871 if ( mShortcut != sc ) {
00872 mShortcut = sc;
00873 emit shortcutChanged( this );
00874 }
00875 }
00876
00877 bool KMFolder::isMoveable() const
00878 {
00879 return !isSystemFolder();
00880 }
00881
00882 void KMFolder::slotContentsTypeChanged( KMail::FolderContentsType type )
00883 {
00884 kmkernel->iCalIface().folderContentsTypeChanged( this, type );
00885 emit iconsChanged();
00886 }
00887
00888 void KMFolder::slotFolderSizeChanged()
00889 {
00890 emit folderSizeChanged( this );
00891 KMFolder* papa = parent()->manager()->parentFolder( this );
00892 if ( papa && papa != this ) {
00893 papa->slotFolderSizeChanged();
00894 }
00895 }
00896
00897
00898 #include "kmfolder.moc"