kmail

kmfolder.cpp

00001 /* -*- mode: C++; c-file-style: "gnu" -*-
00002  * kmail: KDE mail client
00003  * Copyright (c) 1996-1998 Stefan Taferner <taferner@kde.org>
00004  *
00005  * This program is free software; you can redistribute it and/or modify
00006  * it under the terms of the GNU General Public License as published by
00007  * the Free Software Foundation; either version 2 of the License, or
00008  * (at your option) any later version.
00009  *
00010  * This program is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013  * GNU General Public License for more details.
00014  *
00015  * You should have received a copy of the GNU General Public License
00016  * along with this program; if not, write to the Free Software
00017  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
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 ), // default identity
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   // Resend all mStorage signals
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   //FIXME: Centralize all the readConfig calls somehow - Zack
00130   // Meanwhile, readConfig must be done before registerWithMessageDict, since
00131   // that one can call writeConfig in some circumstances - David
00132   mStorage->readConfig();
00133 
00134    // trigger from here, since it needs a fully constructed FolderStorage
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   // make sure that we don't overwrite a valid id
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) // Not there or not writable
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       // We check for isEmpty because before 3.3 postAddress was just an
00582       // email@kde.org and that leaves protocol() field in the kurl class
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   // This isn't saved in the config anyway
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     // default setting
00624     const KPIM::Identity & identity =
00625       kmkernel->identityManager()->identityForUoidOrDefault( mIdentity );
00626 
00627     if ( isSystemFolder() && folderType() != KMFolderTypeImap ) {
00628       // local system folders
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       // drafts, templates or sent of the identity
00641       mWhoField = "To";
00642     else
00643       mWhoField = "From";
00644   } else if ( whoField == "From" || whoField == "To" )
00645     // set the whoField according to the user-setting
00646     mWhoField = whoField;
00647   else {
00648     // this should not happen...
00649     kdDebug(5006) << "Illegal setting " << whoField << " for userWhoField!"
00650                   << endl;
00651     return; // don't use the value
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   /* Escape [ and ] as they are disallowed for kconfig sections and that is
00679      what the idString is primarily used for. */
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: // Days
00745     return number;
00746   case expireWeeks: // Weeks
00747     return number * 7;
00748   case expireMonths: // Months - this could be better rather than assuming 31day months.
00749     return number * 31;
00750   default: // this avoids a compiler warning (not handled enumeration values)
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     // #82259: compact after expiring.
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"
KDE Home | KDE Accessibility Home | Description of Access Keys