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 ? mStorage->find( msg ) : 0;
00430 }
00431
00432 int KMFolder::find( const KMMessage* msg ) const
00433 {
00434 return mStorage ? mStorage->find( msg ) : 0;
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 this == kmkernel->templatesFolder() )
00636 mWhoField = "To";
00637 } else if ( identity.drafts() == idString() ||
00638 identity.templates() == idString() ||
00639 identity.fcc() == idString() )
00640
00641 mWhoField = "To";
00642 else
00643 mWhoField = "From";
00644 } else if ( whoField == "From" || whoField == "To" )
00645
00646 mWhoField = whoField;
00647 else {
00648
00649 kdDebug(5006) << "Illegal setting " << whoField << " for userWhoField!"
00650 << endl;
00651 return;
00652 }
00653 mUserWhoField = whoField;
00654
00655 if (writeConfig)
00656 mStorage->writeConfig();
00657 emit viewConfigChanged();
00658 }
00659
00660 void KMFolder::correctUnreadMsgsCount()
00661 {
00662 mStorage->correctUnreadMsgsCount();
00663 }
00664
00665 QString KMFolder::idString() const
00666 {
00667 KMFolderNode* folderNode = parent();
00668 if (!folderNode)
00669 return "";
00670 while ( folderNode->parent() )
00671 folderNode = folderNode->parent();
00672 QString myPath = path();
00673 int pathLen = myPath.length() - folderNode->path().length();
00674 QString relativePath = myPath.right( pathLen );
00675 if (!relativePath.isEmpty())
00676 relativePath = relativePath.right( relativePath.length() - 1 ) + "/";
00677 QString escapedName = name();
00678
00679
00680 escapedName.replace( "[", "%(" );
00681 escapedName.replace( "]", "%)" );
00682 return relativePath + escapedName;
00683 }
00684
00685 void KMFolder::setAutoExpire( bool enabled )
00686 {
00687 if( enabled != mExpireMessages ) {
00688 mExpireMessages = enabled;
00689 mStorage->writeConfig();
00690 }
00691 }
00692
00693 void KMFolder::setUnreadExpireAge( int age )
00694 {
00695 if( age >= 0 && age != mUnreadExpireAge ) {
00696 mUnreadExpireAge = age;
00697 mStorage->writeConfig();
00698 }
00699 }
00700
00701 void KMFolder::setUnreadExpireUnits( ExpireUnits units )
00702 {
00703 if (units >= expireNever && units < expireMaxUnits)
00704 mUnreadExpireUnits = units;
00705 mStorage->writeConfig();
00706 }
00707
00708 void KMFolder::setReadExpireAge( int age )
00709 {
00710 if( age >= 0 && age != mReadExpireAge ) {
00711 mReadExpireAge = age;
00712 mStorage->writeConfig();
00713 }
00714 }
00715
00716 void KMFolder::setReadExpireUnits( ExpireUnits units )
00717 {
00718 if (units >= expireNever && units <= expireMaxUnits)
00719 mReadExpireUnits = units;
00720 mStorage->writeConfig();
00721 }
00722
00723
00724 void KMFolder::setExpireAction( ExpireAction a )
00725 {
00726 if ( a != mExpireAction ) {
00727 mExpireAction = a;
00728 mStorage->writeConfig();
00729 }
00730 }
00731
00732 void KMFolder::setExpireToFolderId( const QString& id )
00733 {
00734 if ( id != mExpireToFolderId ) {
00735 mExpireToFolderId = id;
00736 mStorage->writeConfig();
00737 }
00738 }
00739
00740
00741 static int daysToExpire( int number, ExpireUnits units )
00742 {
00743 switch (units) {
00744 case expireDays:
00745 return number;
00746 case expireWeeks:
00747 return number * 7;
00748 case expireMonths:
00749 return number * 31;
00750 default:
00751 ;
00752 }
00753 return -1;
00754 }
00755
00756 void KMFolder::daysToExpire(int& unreadDays, int& readDays) {
00757 unreadDays = ::daysToExpire( getUnreadExpireAge(), getUnreadExpireUnits() );
00758 readDays = ::daysToExpire( getReadExpireAge(), getReadExpireUnits() );
00759 }
00760
00761 void KMFolder::expireOldMessages( bool immediate )
00762 {
00763 KMail::ScheduledExpireTask* task = new KMail::ScheduledExpireTask(this, immediate);
00764 kmkernel->jobScheduler()->registerTask( task );
00765 if ( immediate ) {
00766
00767 compact( CompactLater );
00768 }
00769 }
00770
00771 void KMFolder::compact( CompactOptions options )
00772 {
00773 if ( options == CompactLater ) {
00774 KMail::ScheduledCompactionTask* task = new KMail::ScheduledCompactionTask(this, false);
00775 kmkernel->jobScheduler()->registerTask( task );
00776 } else {
00777 mStorage->compact( options == CompactSilentlyNow );
00778 }
00779 }
00780
00781 KMFolder* KMFolder::trashFolder() const
00782 {
00783 return mStorage ? mStorage->trashFolder() : 0;
00784 }
00785
00786 int KMFolder::writeIndex( bool createEmptyIndex )
00787 {
00788 return mStorage->writeIndex( createEmptyIndex );
00789 }
00790
00791 void KMFolder::setStatus( int idx, KMMsgStatus status, bool toggle )
00792 {
00793 mStorage->setStatus( idx, status, toggle );
00794 }
00795
00796 void KMFolder::setStatus( QValueList<int>& ids, KMMsgStatus status,
00797 bool toggle )
00798 {
00799 mStorage->setStatus( ids, status, toggle);
00800 }
00801
00802 void KMFolder::setIconPaths( const QString &normalPath,
00803 const QString &unreadPath )
00804 {
00805 mNormalIconPath = normalPath;
00806 mUnreadIconPath = unreadPath;
00807 mStorage->writeConfig();
00808 emit iconsChanged();
00809 }
00810
00811 void KMFolder::removeJobs()
00812 {
00813 mStorage->removeJobs();
00814 }
00815
00816 int KMFolder::updateIndex()
00817 {
00818 return mStorage->updateIndex();
00819 }
00820
00821 void KMFolder::reallyAddMsg( KMMessage* aMsg )
00822 {
00823 mStorage->reallyAddMsg( aMsg );
00824 }
00825
00826 void KMFolder::reallyAddCopyOfMsg( KMMessage* aMsg )
00827 {
00828 mStorage->reallyAddCopyOfMsg( aMsg );
00829 }
00830
00831 void KMFolder::setShortcut( const KShortcut &sc )
00832 {
00833 if ( mShortcut != sc ) {
00834 mShortcut = sc;
00835 emit shortcutChanged( this );
00836 }
00837 }
00838
00839 bool KMFolder::isMoveable() const
00840 {
00841 return mStorage->isMoveable();
00842 }
00843
00844 void KMFolder::slotContentsTypeChanged( KMail::FolderContentsType type )
00845 {
00846 kmkernel->iCalIface().folderContentsTypeChanged( this, type );
00847 emit iconsChanged();
00848 }
00849
00850 #include "kmfolder.moc"