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   /* The storage needs to be open before remove is called, otherwise
00448      it will not unregister the corresponding serial numbers from
00449      the message dict, since its message list is empty, and the .ids
00450      file contents are not loaded. That can lead to lookups in the
00451      dict returning stale pointers to the folder later. */
00452   mStorage->open();
00453   mStorage->remove();
00454 }
00455 
00456 int KMFolder::expunge()
00457 {
00458   return mStorage->expunge();
00459 }
00460 
00461 int KMFolder::rename( const QString& newName, KMFolderDir *aParent )
00462 {
00463   return mStorage->rename( newName, aParent );
00464 }
00465 
00466 bool KMFolder::autoCreateIndex() const
00467 {
00468   return mStorage->autoCreateIndex();
00469 }
00470 
00471 void KMFolder::setAutoCreateIndex( bool b )
00472 {
00473   mStorage->setAutoCreateIndex( b );
00474 }
00475 
00476 bool KMFolder::dirty() const
00477 {
00478   return mStorage->dirty();
00479 }
00480 
00481 void KMFolder::setDirty( bool f )
00482 {
00483   mStorage->setDirty( f );
00484 }
00485 
00486 bool KMFolder::needsCompacting() const
00487 {
00488   return mStorage->needsCompacting();
00489 }
00490 
00491 void KMFolder::setNeedsCompacting( bool f )
00492 {
00493   mStorage->setNeedsCompacting( f );
00494 }
00495 
00496 void KMFolder::quiet( bool beQuiet )
00497 {
00498   mStorage->quiet( beQuiet );
00499 }
00500 
00501 bool KMFolder::isReadOnly() const
00502 {
00503   return mStorage->isReadOnly();
00504 }
00505 
00506 QString KMFolder::label() const
00507 {
00508   if ( !mSystemLabel.isEmpty() )
00509      return mSystemLabel;
00510   if ( !mLabel.isEmpty() )
00511      return mLabel;
00512   if ( isSystemFolder() )
00513      return i18n( name().latin1() );
00514   return name();
00515 }
00516 
00517 //-----------------------------------------------------------------------------
00518 QString KMFolder::prettyURL() const
00519 {
00520   if ( parent() )
00521     return parent()->prettyURL() + "/" + label();
00522   else
00523     return "/" + label();
00524 }
00525 
00526 //--------------------------------------------------------------------------
00527 QString KMFolder::mailingListPostAddress() const
00528 {
00529   if ( mMailingList.features() & MailingList::Post ) {
00530     KURL::List::const_iterator it;
00531     KURL::List post = mMailingList.postURLS();
00532     for( it = post.begin(); it != post.end(); ++it ) {
00533       // We check for isEmpty because before 3.3 postAddress was just an
00534       // email@kde.org and that leaves protocol() field in the kurl class
00535       if ( (*it).protocol() == "mailto" || (*it).protocol().isEmpty() )
00536         return (*it).path();
00537     }
00538   }
00539   return QString::null;
00540 }
00541 
00542 const char* KMFolder::type() const
00543 {
00544   return mStorage->type();
00545 }
00546 
00547 bool KMFolder::hasAccounts() const
00548 {
00549   return mStorage->hasAccounts();
00550 }
00551 
00552 void KMFolder::setMailingListEnabled( bool enabled )
00553 {
00554   mMailingListEnabled = enabled;
00555   mStorage->writeConfig();
00556 }
00557 
00558 void KMFolder::setMailingList( const MailingList& mlist )
00559 {
00560   mMailingList = mlist;
00561   mStorage->writeConfig();
00562 }
00563 
00564 void KMFolder::setIdentity( uint identity )
00565 {
00566   mIdentity = identity;
00567   GlobalSettings::self()->requestSync();
00568 }
00569 
00570 void KMFolder::setWhoField(const QString& aWhoField )
00571 {
00572   mWhoField = aWhoField;
00573 #if 0
00574   // This isn't saved in the config anyway
00575   mStorage->writeConfig();
00576 #endif
00577 }
00578 
00579 void KMFolder::setUserWhoField( const QString& whoField, bool writeConfig )
00580 {
00581   mUserWhoField = whoField;
00582   if ( whoField.isEmpty() )
00583   {
00584     // default setting
00585     const KPIM::Identity & identity =
00586       kmkernel->identityManager()->identityForUoidOrDefault( mIdentity );
00587 
00588     if ( isSystemFolder() && folderType() != KMFolderTypeImap ) {
00589       // local system folders
00590       if ( this == kmkernel->inboxFolder() ||
00591            this == kmkernel->trashFolder() )
00592         mWhoField = "From";
00593       if ( this == kmkernel->outboxFolder() ||
00594            this == kmkernel->sentFolder() ||
00595            this == kmkernel->draftsFolder() )
00596         mWhoField = "To";
00597     } else if ( identity.drafts() == idString()
00598                 || identity.fcc() == idString() )
00599       // drafts or sent of the identity
00600       mWhoField = "To";
00601     else
00602       mWhoField = "From";
00603   } else if ( whoField == "From" || whoField == "To" )
00604     // set the whoField according to the user-setting
00605     mWhoField = whoField;
00606   else
00607     // this should not happen...
00608     kdDebug(5006) << "Illegal setting " << whoField << " for userWhoField!"
00609                   << endl;
00610 
00611   if (writeConfig)
00612     mStorage->writeConfig();
00613 }
00614 
00615 void KMFolder::correctUnreadMsgsCount()
00616 {
00617   mStorage->correctUnreadMsgsCount();
00618 }
00619 
00620 QString KMFolder::idString() const
00621 {
00622   KMFolderNode* folderNode = parent();
00623   if (!folderNode)
00624     return "";
00625   while ( folderNode->parent() )
00626     folderNode = folderNode->parent();
00627   QString myPath = path();
00628   int pathLen = myPath.length() - folderNode->path().length();
00629   QString relativePath = myPath.right( pathLen );
00630   if (!relativePath.isEmpty())
00631     relativePath = relativePath.right( relativePath.length() - 1 ) + "/";
00632   QString escapedName = name();
00633   /* Escape [ and ] as they are disallowed for kconfig sections and that is
00634      what the idString is primarily used for. */
00635   escapedName.replace( "[", "%(" );
00636   escapedName.replace( "]", "%)" );
00637   return relativePath + escapedName;
00638 }
00639 
00640 void KMFolder::setAutoExpire( bool enabled )
00641 {
00642   if( enabled != mExpireMessages ) {
00643     mExpireMessages = enabled;
00644     mStorage->writeConfig();
00645   }
00646 }
00647 
00648 void KMFolder::setUnreadExpireAge( int age )
00649 {
00650   if( age >= 0 && age != mUnreadExpireAge ) {
00651     mUnreadExpireAge = age;
00652     mStorage->writeConfig();
00653   }
00654 }
00655 
00656 void KMFolder::setUnreadExpireUnits( ExpireUnits units )
00657 {
00658   if (units >= expireNever && units < expireMaxUnits)
00659     mUnreadExpireUnits = units;
00660 }
00661 
00662 void KMFolder::setReadExpireAge( int age )
00663 {
00664   if( age >= 0 && age != mReadExpireAge ) {
00665     mReadExpireAge = age;
00666     mStorage->writeConfig();
00667   }
00668 }
00669 
00670 void KMFolder::setReadExpireUnits( ExpireUnits units )
00671 {
00672   if (units >= expireNever && units <= expireMaxUnits)
00673     mReadExpireUnits = units;
00674 }
00675 
00676 
00677 void KMFolder::setExpireAction( ExpireAction a )
00678 {
00679   if ( a != mExpireAction ) {
00680     mExpireAction = a;
00681     mStorage->writeConfig();
00682   }
00683 }
00684 
00685 void KMFolder::setExpireToFolderId( const QString& id )
00686 {
00687   if ( id != mExpireToFolderId ) {
00688     mExpireToFolderId = id;
00689     mStorage->writeConfig();
00690   }
00691 }
00692 
00693 
00694 static int daysToExpire( int number, ExpireUnits units )
00695 {
00696   switch (units) {
00697   case expireDays: // Days
00698     return number;
00699   case expireWeeks: // Weeks
00700     return number * 7;
00701   case expireMonths: // Months - this could be better rather than assuming 31day months.
00702     return number * 31;
00703   default: // this avoids a compiler warning (not handled enumeration values)
00704     ;
00705   }
00706   return -1;
00707 }
00708 
00709 void KMFolder::daysToExpire(int& unreadDays, int& readDays) {
00710   unreadDays = ::daysToExpire( getUnreadExpireAge(), getUnreadExpireUnits() );
00711   readDays = ::daysToExpire( getReadExpireAge(), getReadExpireUnits() );
00712 }
00713 
00714 void KMFolder::expireOldMessages( bool immediate )
00715 {
00716   KMail::ScheduledExpireTask* task = new KMail::ScheduledExpireTask(this, immediate);
00717   kmkernel->jobScheduler()->registerTask( task );
00718   if ( immediate ) {
00719     // #82259: compact after expiring.
00720     compact( CompactLater );
00721   }
00722 }
00723 
00724 void KMFolder::compact( CompactOptions options )
00725 {
00726   if ( options == CompactLater ) {
00727     KMail::ScheduledCompactionTask* task = new KMail::ScheduledCompactionTask(this, false);
00728     kmkernel->jobScheduler()->registerTask( task );
00729   } else {
00730     mStorage->compact( options == CompactSilentlyNow );
00731   }
00732 }
00733 
00734 KMFolder* KMFolder::trashFolder() const
00735 {
00736   return mStorage ? mStorage->trashFolder() : 0;
00737 }
00738 
00739 int KMFolder::writeIndex( bool createEmptyIndex )
00740 {
00741   return mStorage->writeIndex( createEmptyIndex );
00742 }
00743 
00744 void KMFolder::fillMsgDict( KMMsgDict* dict )
00745 {
00746   mStorage->fillMsgDict( dict );
00747 }
00748 
00749 int KMFolder::writeMsgDict( KMMsgDict* dict)
00750 {
00751   return mStorage->writeMsgDict( dict );
00752 }
00753 
00754 int KMFolder::touchMsgDict()
00755 {
00756   return mStorage->touchMsgDict();
00757 }
00758 
00759 int KMFolder::appendtoMsgDict( int idx )
00760 {
00761   return mStorage->appendtoMsgDict( idx );
00762 }
00763 
00764 void KMFolder::setRDict( KMMsgDictREntry* rentry )
00765 {
00766   mStorage->setRDict( rentry );
00767 }
00768 
00769 KMMsgDictREntry* KMFolder::rDict() const
00770 {
00771   return mStorage->rDict();
00772 }
00773 
00774 void KMFolder::setStatus( int idx, KMMsgStatus status, bool toggle )
00775 {
00776   mStorage->setStatus( idx, status, toggle );
00777 }
00778 
00779 void KMFolder::setStatus( QValueList<int>& ids, KMMsgStatus status,
00780                           bool toggle )
00781 {
00782   mStorage->setStatus( ids, status, toggle);
00783 }
00784 
00785 void KMFolder::setIconPaths( const QString &normalPath,
00786                              const QString &unreadPath )
00787 {
00788   mNormalIconPath = normalPath;
00789   mUnreadIconPath = unreadPath;
00790   mStorage->writeConfig();
00791   emit iconsChanged();
00792 }
00793 
00794 void KMFolder::removeJobs()
00795 {
00796   mStorage->removeJobs();
00797 }
00798 
00799 size_t KMFolder::crlf2lf( char* str, const size_t strLen )
00800 {
00801   return FolderStorage::crlf2lf( str, strLen );
00802 }
00803 
00804 int KMFolder::updateIndex()
00805 {
00806   return mStorage->updateIndex();
00807 }
00808 
00809 void KMFolder::reallyAddMsg( KMMessage* aMsg )
00810 {
00811   mStorage->reallyAddMsg( aMsg );
00812 }
00813 
00814 void KMFolder::reallyAddCopyOfMsg( KMMessage* aMsg )
00815 {
00816   mStorage->reallyAddCopyOfMsg( aMsg );
00817 }
00818 
00819 bool KMFolder::isMoveable() const
00820 {
00821   return !isSystemFolder();
00822 }
00823 
00824 void KMFolder::slotContentsTypeChanged( KMail::FolderContentsType type )
00825 {
00826   kmkernel->iCalIface().folderContentsTypeChanged( this, type );
00827   emit iconsChanged();
00828 }
00829 
00830 
00831 #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 Oct 4 14:42:20 2007 by doxygen 1.4.2 written by Dimitri van Heesch, © 1997-2003