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