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
00448
00449
00450
00451
00452 mStorage->open();
00453 mStorage->remove();
00454 }
00455
00456 int KMFolder::expunge()
00457 {
00458 return mStorage->expunge();
00459 }
00460
00461 int KMFolder::rename( const QString& newName, KMFolderDir *aParent )
00462 {
00463 return mStorage->rename( newName, aParent );
00464 }
00465
00466 bool KMFolder::autoCreateIndex() const
00467 {
00468 return mStorage->autoCreateIndex();
00469 }
00470
00471 void KMFolder::setAutoCreateIndex( bool b )
00472 {
00473 mStorage->setAutoCreateIndex( b );
00474 }
00475
00476 bool KMFolder::dirty() const
00477 {
00478 return mStorage->dirty();
00479 }
00480
00481 void KMFolder::setDirty( bool f )
00482 {
00483 mStorage->setDirty( f );
00484 }
00485
00486 bool KMFolder::needsCompacting() const
00487 {
00488 return mStorage->needsCompacting();
00489 }
00490
00491 void KMFolder::setNeedsCompacting( bool f )
00492 {
00493 mStorage->setNeedsCompacting( f );
00494 }
00495
00496 void KMFolder::quiet( bool beQuiet )
00497 {
00498 mStorage->quiet( beQuiet );
00499 }
00500
00501 bool KMFolder::isReadOnly() const
00502 {
00503 return mStorage->isReadOnly();
00504 }
00505
00506 QString KMFolder::label() const
00507 {
00508 if ( !mSystemLabel.isEmpty() )
00509 return mSystemLabel;
00510 if ( !mLabel.isEmpty() )
00511 return mLabel;
00512 if ( isSystemFolder() )
00513 return i18n( name().latin1() );
00514 return name();
00515 }
00516
00517
00518 QString KMFolder::prettyURL() const
00519 {
00520 if ( parent() )
00521 return parent()->prettyURL() + "/" + label();
00522 else
00523 return "/" + label();
00524 }
00525
00526
00527 QString KMFolder::mailingListPostAddress() const
00528 {
00529 if ( mMailingList.features() & MailingList::Post ) {
00530 KURL::List::const_iterator it;
00531 KURL::List post = mMailingList.postURLS();
00532 for( it = post.begin(); it != post.end(); ++it ) {
00533
00534
00535 if ( (*it).protocol() == "mailto" || (*it).protocol().isEmpty() )
00536 return (*it).path();
00537 }
00538 }
00539 return QString::null;
00540 }
00541
00542 const char* KMFolder::type() const
00543 {
00544 return mStorage->type();
00545 }
00546
00547 bool KMFolder::hasAccounts() const
00548 {
00549 return mStorage->hasAccounts();
00550 }
00551
00552 void KMFolder::setMailingListEnabled( bool enabled )
00553 {
00554 mMailingListEnabled = enabled;
00555 mStorage->writeConfig();
00556 }
00557
00558 void KMFolder::setMailingList( const MailingList& mlist )
00559 {
00560 mMailingList = mlist;
00561 mStorage->writeConfig();
00562 }
00563
00564 void KMFolder::setIdentity( uint identity )
00565 {
00566 mIdentity = identity;
00567 GlobalSettings::self()->requestSync();
00568 }
00569
00570 void KMFolder::setWhoField(const QString& aWhoField )
00571 {
00572 mWhoField = aWhoField;
00573 #if 0
00574
00575 mStorage->writeConfig();
00576 #endif
00577 }
00578
00579 void KMFolder::setUserWhoField( const QString& whoField, bool writeConfig )
00580 {
00581 mUserWhoField = whoField;
00582 if ( whoField.isEmpty() )
00583 {
00584
00585 const KPIM::Identity & identity =
00586 kmkernel->identityManager()->identityForUoidOrDefault( mIdentity );
00587
00588 if ( isSystemFolder() && folderType() != KMFolderTypeImap ) {
00589
00590 if ( this == kmkernel->inboxFolder() ||
00591 this == kmkernel->trashFolder() )
00592 mWhoField = "From";
00593 if ( this == kmkernel->outboxFolder() ||
00594 this == kmkernel->sentFolder() ||
00595 this == kmkernel->draftsFolder() )
00596 mWhoField = "To";
00597 } else if ( identity.drafts() == idString()
00598 || identity.fcc() == idString() )
00599
00600 mWhoField = "To";
00601 else
00602 mWhoField = "From";
00603 } else if ( whoField == "From" || whoField == "To" )
00604
00605 mWhoField = whoField;
00606 else
00607
00608 kdDebug(5006) << "Illegal setting " << whoField << " for userWhoField!"
00609 << endl;
00610
00611 if (writeConfig)
00612 mStorage->writeConfig();
00613 }
00614
00615 void KMFolder::correctUnreadMsgsCount()
00616 {
00617 mStorage->correctUnreadMsgsCount();
00618 }
00619
00620 QString KMFolder::idString() const
00621 {
00622 KMFolderNode* folderNode = parent();
00623 if (!folderNode)
00624 return "";
00625 while ( folderNode->parent() )
00626 folderNode = folderNode->parent();
00627 QString myPath = path();
00628 int pathLen = myPath.length() - folderNode->path().length();
00629 QString relativePath = myPath.right( pathLen );
00630 if (!relativePath.isEmpty())
00631 relativePath = relativePath.right( relativePath.length() - 1 ) + "/";
00632 QString escapedName = name();
00633
00634
00635 escapedName.replace( "[", "%(" );
00636 escapedName.replace( "]", "%)" );
00637 return relativePath + escapedName;
00638 }
00639
00640 void KMFolder::setAutoExpire( bool enabled )
00641 {
00642 if( enabled != mExpireMessages ) {
00643 mExpireMessages = enabled;
00644 mStorage->writeConfig();
00645 }
00646 }
00647
00648 void KMFolder::setUnreadExpireAge( int age )
00649 {
00650 if( age >= 0 && age != mUnreadExpireAge ) {
00651 mUnreadExpireAge = age;
00652 mStorage->writeConfig();
00653 }
00654 }
00655
00656 void KMFolder::setUnreadExpireUnits( ExpireUnits units )
00657 {
00658 if (units >= expireNever && units < expireMaxUnits)
00659 mUnreadExpireUnits = units;
00660 }
00661
00662 void KMFolder::setReadExpireAge( int age )
00663 {
00664 if( age >= 0 && age != mReadExpireAge ) {
00665 mReadExpireAge = age;
00666 mStorage->writeConfig();
00667 }
00668 }
00669
00670 void KMFolder::setReadExpireUnits( ExpireUnits units )
00671 {
00672 if (units >= expireNever && units <= expireMaxUnits)
00673 mReadExpireUnits = units;
00674 }
00675
00676
00677 void KMFolder::setExpireAction( ExpireAction a )
00678 {
00679 if ( a != mExpireAction ) {
00680 mExpireAction = a;
00681 mStorage->writeConfig();
00682 }
00683 }
00684
00685 void KMFolder::setExpireToFolderId( const QString& id )
00686 {
00687 if ( id != mExpireToFolderId ) {
00688 mExpireToFolderId = id;
00689 mStorage->writeConfig();
00690 }
00691 }
00692
00693
00694 static int daysToExpire( int number, ExpireUnits units )
00695 {
00696 switch (units) {
00697 case expireDays:
00698 return number;
00699 case expireWeeks:
00700 return number * 7;
00701 case expireMonths:
00702 return number * 31;
00703 default:
00704 ;
00705 }
00706 return -1;
00707 }
00708
00709 void KMFolder::daysToExpire(int& unreadDays, int& readDays) {
00710 unreadDays = ::daysToExpire( getUnreadExpireAge(), getUnreadExpireUnits() );
00711 readDays = ::daysToExpire( getReadExpireAge(), getReadExpireUnits() );
00712 }
00713
00714 void KMFolder::expireOldMessages( bool immediate )
00715 {
00716 KMail::ScheduledExpireTask* task = new KMail::ScheduledExpireTask(this, immediate);
00717 kmkernel->jobScheduler()->registerTask( task );
00718 if ( immediate ) {
00719
00720 compact( CompactLater );
00721 }
00722 }
00723
00724 void KMFolder::compact( CompactOptions options )
00725 {
00726 if ( options == CompactLater ) {
00727 KMail::ScheduledCompactionTask* task = new KMail::ScheduledCompactionTask(this, false);
00728 kmkernel->jobScheduler()->registerTask( task );
00729 } else {
00730 mStorage->compact( options == CompactSilentlyNow );
00731 }
00732 }
00733
00734 KMFolder* KMFolder::trashFolder() const
00735 {
00736 return mStorage ? mStorage->trashFolder() : 0;
00737 }
00738
00739 int KMFolder::writeIndex( bool createEmptyIndex )
00740 {
00741 return mStorage->writeIndex( createEmptyIndex );
00742 }
00743
00744 void KMFolder::fillMsgDict( KMMsgDict* dict )
00745 {
00746 mStorage->fillMsgDict( dict );
00747 }
00748
00749 int KMFolder::writeMsgDict( KMMsgDict* dict)
00750 {
00751 return mStorage->writeMsgDict( dict );
00752 }
00753
00754 int KMFolder::touchMsgDict()
00755 {
00756 return mStorage->touchMsgDict();
00757 }
00758
00759 int KMFolder::appendtoMsgDict( int idx )
00760 {
00761 return mStorage->appendtoMsgDict( idx );
00762 }
00763
00764 void KMFolder::setRDict( KMMsgDictREntry* rentry )
00765 {
00766 mStorage->setRDict( rentry );
00767 }
00768
00769 KMMsgDictREntry* KMFolder::rDict() const
00770 {
00771 return mStorage->rDict();
00772 }
00773
00774 void KMFolder::setStatus( int idx, KMMsgStatus status, bool toggle )
00775 {
00776 mStorage->setStatus( idx, status, toggle );
00777 }
00778
00779 void KMFolder::setStatus( QValueList<int>& ids, KMMsgStatus status,
00780 bool toggle )
00781 {
00782 mStorage->setStatus( ids, status, toggle);
00783 }
00784
00785 void KMFolder::setIconPaths( const QString &normalPath,
00786 const QString &unreadPath )
00787 {
00788 mNormalIconPath = normalPath;
00789 mUnreadIconPath = unreadPath;
00790 mStorage->writeConfig();
00791 emit iconsChanged();
00792 }
00793
00794 void KMFolder::removeJobs()
00795 {
00796 mStorage->removeJobs();
00797 }
00798
00799 size_t KMFolder::crlf2lf( char* str, const size_t strLen )
00800 {
00801 return FolderStorage::crlf2lf( str, strLen );
00802 }
00803
00804 int KMFolder::updateIndex()
00805 {
00806 return mStorage->updateIndex();
00807 }
00808
00809 void KMFolder::reallyAddMsg( KMMessage* aMsg )
00810 {
00811 mStorage->reallyAddMsg( aMsg );
00812 }
00813
00814 void KMFolder::reallyAddCopyOfMsg( KMMessage* aMsg )
00815 {
00816 mStorage->reallyAddCopyOfMsg( aMsg );
00817 }
00818
00819 bool KMFolder::isMoveable() const
00820 {
00821 return !isSystemFolder();
00822 }
00823
00824 void KMFolder::slotContentsTypeChanged( KMail::FolderContentsType type )
00825 {
00826 kmkernel->iCalIface().folderContentsTypeChanged( this, type );
00827 emit iconsChanged();
00828 }
00829
00830
00831 #include "kmfolder.moc"