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