kmail Library API Documentation

kmfolder.cpp

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