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 }
00704
00705 void KMFolder::setReadExpireAge( int age )
00706 {
00707 if( age >= 0 && age != mReadExpireAge ) {
00708 mReadExpireAge = age;
00709 mStorage->writeConfig();
00710 }
00711 }
00712
00713 void KMFolder::setReadExpireUnits( ExpireUnits units )
00714 {
00715 if (units >= expireNever && units <= expireMaxUnits)
00716 mReadExpireUnits = units;
00717 }
00718
00719
00720 void KMFolder::setExpireAction( ExpireAction a )
00721 {
00722 if ( a != mExpireAction ) {
00723 mExpireAction = a;
00724 mStorage->writeConfig();
00725 }
00726 }
00727
00728 void KMFolder::setExpireToFolderId( const QString& id )
00729 {
00730 if ( id != mExpireToFolderId ) {
00731 mExpireToFolderId = id;
00732 mStorage->writeConfig();
00733 }
00734 }
00735
00736
00737 static int daysToExpire( int number, ExpireUnits units )
00738 {
00739 switch (units) {
00740 case expireDays:
00741 return number;
00742 case expireWeeks:
00743 return number * 7;
00744 case expireMonths:
00745 return number * 31;
00746 default:
00747 ;
00748 }
00749 return -1;
00750 }
00751
00752 void KMFolder::daysToExpire(int& unreadDays, int& readDays) {
00753 unreadDays = ::daysToExpire( getUnreadExpireAge(), getUnreadExpireUnits() );
00754 readDays = ::daysToExpire( getReadExpireAge(), getReadExpireUnits() );
00755 }
00756
00757 void KMFolder::expireOldMessages( bool immediate )
00758 {
00759 KMail::ScheduledExpireTask* task = new KMail::ScheduledExpireTask(this, immediate);
00760 kmkernel->jobScheduler()->registerTask( task );
00761 if ( immediate ) {
00762
00763 compact( CompactLater );
00764 }
00765 }
00766
00767 void KMFolder::compact( CompactOptions options )
00768 {
00769 if ( options == CompactLater ) {
00770 KMail::ScheduledCompactionTask* task = new KMail::ScheduledCompactionTask(this, false);
00771 kmkernel->jobScheduler()->registerTask( task );
00772 } else {
00773 mStorage->compact( options == CompactSilentlyNow );
00774 }
00775 }
00776
00777 KMFolder* KMFolder::trashFolder() const
00778 {
00779 return mStorage ? mStorage->trashFolder() : 0;
00780 }
00781
00782 int KMFolder::writeIndex( bool createEmptyIndex )
00783 {
00784 return mStorage->writeIndex( createEmptyIndex );
00785 }
00786
00787 void KMFolder::setStatus( int idx, KMMsgStatus status, bool toggle )
00788 {
00789 mStorage->setStatus( idx, status, toggle );
00790 }
00791
00792 void KMFolder::setStatus( QValueList<int>& ids, KMMsgStatus status,
00793 bool toggle )
00794 {
00795 mStorage->setStatus( ids, status, toggle);
00796 }
00797
00798 void KMFolder::setIconPaths( const QString &normalPath,
00799 const QString &unreadPath )
00800 {
00801 mNormalIconPath = normalPath;
00802 mUnreadIconPath = unreadPath;
00803 mStorage->writeConfig();
00804 emit iconsChanged();
00805 }
00806
00807 void KMFolder::removeJobs()
00808 {
00809 mStorage->removeJobs();
00810 }
00811
00812 int KMFolder::updateIndex()
00813 {
00814 return mStorage->updateIndex();
00815 }
00816
00817 void KMFolder::reallyAddMsg( KMMessage* aMsg )
00818 {
00819 mStorage->reallyAddMsg( aMsg );
00820 }
00821
00822 void KMFolder::reallyAddCopyOfMsg( KMMessage* aMsg )
00823 {
00824 mStorage->reallyAddCopyOfMsg( aMsg );
00825 }
00826
00827 void KMFolder::setShortcut( const KShortcut &sc )
00828 {
00829 if ( mShortcut != sc ) {
00830 mShortcut = sc;
00831 emit shortcutChanged( this );
00832 }
00833 }
00834
00835 bool KMFolder::isMoveable() const
00836 {
00837 return mStorage->isMoveable();
00838 }
00839
00840 void KMFolder::slotContentsTypeChanged( KMail::FolderContentsType type )
00841 {
00842 kmkernel->iCalIface().folderContentsTypeChanged( this, type );
00843 emit iconsChanged();
00844 }
00845
00846 #include "kmfolder.moc"