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