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