summaryrefslogtreecommitdiffstats
path: root/kmail/kmfolder.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit460c52653ab0dcca6f19a4f492ed2c5e4e963ab0 (patch)
tree67208f7c145782a7e90b123b982ca78d88cc2c87 /kmail/kmfolder.cpp
downloadtdepim-460c52653ab0dcca6f19a4f492ed2c5e4e963ab0.tar.gz
tdepim-460c52653ab0dcca6f19a4f492ed2c5e4e963ab0.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kmail/kmfolder.cpp')
-rw-r--r--kmail/kmfolder.cpp881
1 files changed, 881 insertions, 0 deletions
diff --git a/kmail/kmfolder.cpp b/kmail/kmfolder.cpp
new file mode 100644
index 000000000..71b9cfc89
--- /dev/null
+++ b/kmail/kmfolder.cpp
@@ -0,0 +1,881 @@
+/* -*- mode: C++; c-file-style: "gnu" -*-
+ * kmail: KDE mail client
+ * Copyright (c) 1996-1998 Stefan Taferner <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+#include <config.h>
+
+#include "kmfolder.h"
+#include "kmfolderdir.h"
+#include "kmfoldermbox.h"
+#include "folderstorage.h"
+#include "kmfoldercachedimap.h"
+#include "kmfoldersearch.h"
+#include "kmfolderimap.h"
+#include "kmfoldermgr.h"
+#include <libkpimidentities/identitymanager.h>
+#include <libkpimidentities/identity.h>
+#include "expirejob.h"
+#include "compactionjob.h"
+#include "kmfoldertree.h"
+#include "kmailicalifaceimpl.h"
+#include "kmaccount.h"
+
+#include <errno.h>
+
+#include <kdebug.h>
+#include <klocale.h>
+#include <kshortcut.h>
+#include <kmessagebox.h>
+#include <qfile.h>
+#include <qfileinfo.h>
+
+
+KMFolder::KMFolder( KMFolderDir* aParent, const QString& aFolderName,
+ KMFolderType aFolderType, bool withIndex, bool exportedSernums )
+ : KMFolderNode( aParent, aFolderName ), mStorage(0),
+ mChild( 0 ),
+ mIsSystemFolder( false ),
+ mHasIndex( withIndex ),
+ mExportsSernums( exportedSernums ),
+ mMoveInProgress( false ),
+ mExpireMessages( false ), mUnreadExpireAge( 28 ),
+ mReadExpireAge( 14 ), mUnreadExpireUnits( expireNever ),
+ mReadExpireUnits( expireNever ),
+ mExpireAction( ExpireDelete ),
+ mUseCustomIcons( false ), mMailingListEnabled( false ),
+ mAcctList( 0 ),
+ mIdentity( 0 ), // default identity
+ mPutRepliesInSameFolder( false ),
+ mIgnoreNewMail( false )
+{
+ if( aFolderType == KMFolderTypeCachedImap )
+ mStorage = new KMFolderCachedImap( this, aFolderName.latin1() );
+ else if( aFolderType == KMFolderTypeImap )
+ mStorage = new KMFolderImap( this, aFolderName.latin1() );
+ else if( aFolderType == KMFolderTypeMaildir )
+ mStorage = new KMFolderMaildir( this, aFolderName.latin1() );
+ else if( aFolderType == KMFolderTypeSearch )
+ mStorage = new KMFolderSearch( this, aFolderName.latin1() );
+ else
+ mStorage = new KMFolderMbox( this, aFolderName.latin1() );
+
+ assert( mStorage );
+
+ QFileInfo dirinfo;
+ dirinfo.setFile( mStorage->location() );
+ if ( !dirinfo.exists() ) {
+ int rc = mStorage->create();
+ QString msg = i18n("<qt>Error while creating file <b>%1</b>:<br>%2</qt>").arg(aFolderName).arg(strerror(rc));
+ if ( rc ) {
+ KMessageBox::information(0, msg);
+ }
+ }
+
+ if ( aParent ) {
+ connect( mStorage, SIGNAL( msgAdded( KMFolder*, Q_UINT32 ) ),
+ aParent->manager(), SIGNAL( msgAdded( KMFolder*, Q_UINT32 ) ) );
+ connect( mStorage, SIGNAL( msgRemoved( KMFolder*, Q_UINT32 ) ),
+ parent()->manager(), SIGNAL( msgRemoved( KMFolder*, Q_UINT32 ) ) );
+ connect( this, SIGNAL( msgChanged( KMFolder*, Q_UINT32, int ) ),
+ parent()->manager(), SIGNAL( msgChanged( KMFolder*, Q_UINT32, int ) ) );
+ connect( this, SIGNAL( msgHeaderChanged( KMFolder*, int ) ),
+ parent()->manager(), SIGNAL( msgHeaderChanged( KMFolder*, int ) ) );
+ connect( mStorage, SIGNAL( invalidated( KMFolder* ) ),
+ parent()->manager(), SIGNAL( folderInvalidated( KMFolder* ) ) );
+ }
+
+ // Resend all mStorage signals
+ connect( mStorage, SIGNAL( changed() ), SIGNAL( changed() ) );
+ connect( mStorage, SIGNAL( cleared() ), SIGNAL( cleared() ) );
+ connect( mStorage, SIGNAL( expunged( KMFolder* ) ),
+ SIGNAL( expunged( KMFolder* ) ) );
+ connect( mStorage, SIGNAL( nameChanged() ), SIGNAL( nameChanged() ) );
+ connect( mStorage, SIGNAL( msgRemoved( KMFolder*, Q_UINT32 ) ),
+ SIGNAL( msgRemoved( KMFolder*, Q_UINT32 ) ) );
+ connect( mStorage, SIGNAL( msgRemoved( int, QString ) ),
+ SIGNAL( msgRemoved( int, QString ) ) );
+ connect( mStorage, SIGNAL( msgRemoved( KMFolder* ) ),
+ SIGNAL( msgRemoved( KMFolder* ) ) );
+ connect( mStorage, SIGNAL( msgAdded( int ) ), SIGNAL( msgAdded( int ) ) );
+ connect( mStorage, SIGNAL( msgAdded( KMFolder*, Q_UINT32 ) ),
+ SIGNAL( msgAdded( KMFolder*, Q_UINT32 ) ) );
+ connect( mStorage, SIGNAL( msgChanged( KMFolder*, Q_UINT32 , int ) ),
+ SIGNAL( msgChanged( KMFolder*, Q_UINT32 , int ) ) );
+ connect( mStorage, SIGNAL( msgHeaderChanged( KMFolder*, int ) ),
+ SIGNAL( msgHeaderChanged( KMFolder*, int ) ) );
+ connect( mStorage, SIGNAL( statusMsg( const QString& ) ),
+ SIGNAL( statusMsg( const QString& ) ) );
+ connect( mStorage, SIGNAL( numUnreadMsgsChanged( KMFolder* ) ),
+ SIGNAL( numUnreadMsgsChanged( KMFolder* ) ) );
+ connect( mStorage, SIGNAL( removed( KMFolder*, bool ) ),
+ SIGNAL( removed( KMFolder*, bool ) ) );
+
+ connect( mStorage, SIGNAL( contentsTypeChanged( KMail::FolderContentsType ) ),
+ this, SLOT( slotContentsTypeChanged( KMail::FolderContentsType ) ) );
+
+ connect( mStorage, SIGNAL( folderSizeChanged() ),
+ this, SLOT( slotFolderSizeChanged() ) );
+
+ //FIXME: Centralize all the readConfig calls somehow - Zack
+ // Meanwhile, readConfig must be done before registerWithMessageDict, since
+ // that one can call writeConfig in some circumstances - David
+ mStorage->readConfig();
+
+ // trigger from here, since it needs a fully constructed FolderStorage
+ if ( mExportsSernums )
+ mStorage->registerWithMessageDict();
+ if ( !mHasIndex )
+ mStorage->setAutoCreateIndex( false );
+
+ if ( mId == 0 && aParent )
+ mId = aParent->manager()->createId();
+}
+
+KMFolder::~KMFolder()
+{
+ mStorage->close( "~KMFolder", true );
+ delete mAcctList;
+ if ( mHasIndex ) mStorage->deregisterFromMessageDict();
+ delete mStorage;
+}
+
+void KMFolder::readConfig( KConfig* config )
+{
+ if ( !config->readEntry("SystemLabel").isEmpty() )
+ mSystemLabel = config->readEntry("SystemLabel");
+ mExpireMessages = config->readBoolEntry("ExpireMessages", false);
+ mReadExpireAge = config->readNumEntry("ReadExpireAge", 3);
+ mReadExpireUnits = (ExpireUnits)config->readNumEntry("ReadExpireUnits", expireMonths);
+ mUnreadExpireAge = config->readNumEntry("UnreadExpireAge", 12);
+ mUnreadExpireUnits = (ExpireUnits)config->readNumEntry("UnreadExpireUnits", expireNever);
+ mExpireAction = config->readEntry("ExpireAction", "Delete") == "Move" ? ExpireMove : ExpireDelete;
+ mExpireToFolderId = config->readEntry("ExpireToFolder");
+
+ mUseCustomIcons = config->readBoolEntry("UseCustomIcons", false );
+ mNormalIconPath = config->readEntry("NormalIconPath" );
+ mUnreadIconPath = config->readEntry("UnreadIconPath" );
+
+ mMailingListEnabled = config->readBoolEntry("MailingListEnabled");
+ mMailingList.readConfig( config );
+
+ mIdentity = config->readUnsignedNumEntry("Identity",0);
+
+ setUserWhoField( config->readEntry("WhoField"), false );
+ uint savedId = config->readUnsignedNumEntry("Id", 0);
+ // make sure that we don't overwrite a valid id
+ if ( savedId != 0 && mId == 0 )
+ mId = savedId;
+ mPutRepliesInSameFolder = config->readBoolEntry( "PutRepliesInSameFolder", false );
+ mIgnoreNewMail = config->readBoolEntry( "IgnoreNewMail", false );
+
+ if ( mUseCustomIcons )
+ emit iconsChanged();
+
+ QString shortcut( config->readEntry( "Shortcut" ) );
+ if ( !shortcut.isEmpty() ) {
+ KShortcut sc( shortcut );
+ setShortcut( sc );
+ }
+}
+
+void KMFolder::writeConfig( KConfig* config ) const
+{
+ config->writeEntry("SystemLabel", mSystemLabel);
+ config->writeEntry("ExpireMessages", mExpireMessages);
+ config->writeEntry("ReadExpireAge", mReadExpireAge);
+ config->writeEntry("ReadExpireUnits", mReadExpireUnits);
+ config->writeEntry("UnreadExpireAge", mUnreadExpireAge);
+ config->writeEntry("UnreadExpireUnits", mUnreadExpireUnits);
+ config->writeEntry("ExpireAction", mExpireAction == ExpireDelete ? "Delete" : "Move");
+ config->writeEntry("ExpireToFolder", mExpireToFolderId);
+
+ config->writeEntry("UseCustomIcons", mUseCustomIcons);
+ config->writeEntry("NormalIconPath", mNormalIconPath);
+ config->writeEntry("UnreadIconPath", mUnreadIconPath);
+
+ config->writeEntry("MailingListEnabled", mMailingListEnabled);
+ mMailingList.writeConfig( config );
+
+ if ( mIdentity != 0 && ( !mStorage || !mStorage->account() || mIdentity != mStorage->account()->identityId() ) )
+ config->writeEntry("Identity", mIdentity);
+ else
+ config->deleteEntry("Identity");
+
+ config->writeEntry("WhoField", mUserWhoField);
+ config->writeEntry("Id", mId);
+ config->writeEntry( "PutRepliesInSameFolder", mPutRepliesInSameFolder );
+ config->writeEntry( "IgnoreNewMail", mIgnoreNewMail );
+ if ( !mShortcut.isNull() )
+ config->writeEntry( "Shortcut", mShortcut.toString() );
+ else
+ config->deleteEntry( "Shortcut" );
+}
+
+KMFolderType KMFolder::folderType() const
+{
+ return mStorage ? mStorage->folderType() : KMFolderTypeUnknown;
+}
+
+QString KMFolder::fileName() const
+{
+ return mStorage ? mStorage->fileName() : QString::null;
+}
+
+QString KMFolder::location() const
+{
+ return mStorage ? mStorage->location() : QString::null;
+}
+
+QString KMFolder::indexLocation() const
+{
+ return mStorage ? mStorage->indexLocation() : QString::null;
+}
+
+QString KMFolder::subdirLocation() const
+{
+ QString sLocation( path() );
+
+ if( !sLocation.isEmpty() )
+ sLocation += '/';
+ sLocation += '.' + FolderStorage::dotEscape( fileName() ) + ".directory";
+
+ return sLocation;
+}
+
+KMFolderDir* KMFolder::createChildFolder()
+{
+ if( mChild )
+ return mChild;
+
+ QString childName = "." + fileName() + ".directory";
+ QString childDir = path() + "/" + childName;
+ if (access(QFile::encodeName(childDir), W_OK) != 0) // Not there or not writable
+ {
+ if (mkdir(QFile::encodeName(childDir), S_IRWXU) != 0
+ && chmod(QFile::encodeName(childDir), S_IRWXU) != 0) {
+ QString wmsg = QString(" '%1': %2").arg(childDir).arg(strerror(errno));
+ KMessageBox::information(0,i18n("Failed to create folder") + wmsg);
+ return 0;
+ }
+ }
+
+ KMFolderDirType newType = KMStandardDir;
+ if( folderType() == KMFolderTypeCachedImap )
+ newType = KMDImapDir;
+ else if( folderType() == KMFolderTypeImap )
+ newType = KMImapDir;
+
+ mChild = new KMFolderDir( this, parent(), childName, newType );
+ if( !mChild )
+ return 0;
+ mChild->reload();
+ parent()->append( mChild );
+ return mChild;
+}
+
+void KMFolder::setChild( KMFolderDir* aChild )
+{
+ mChild = aChild;
+ mStorage->updateChildrenState();
+}
+
+bool KMFolder::noContent() const
+{
+ return mStorage ? mStorage->noContent() : true;
+}
+
+void KMFolder::setNoContent( bool aNoContent )
+{
+ mStorage->setNoContent( aNoContent );
+}
+
+bool KMFolder::noChildren() const
+{
+ return mStorage->noChildren();
+}
+
+void KMFolder::setNoChildren( bool aNoChildren )
+{
+ mStorage->setNoChildren( aNoChildren );
+}
+
+KMMessage* KMFolder::getMsg( int idx )
+{
+ return mStorage->getMsg( idx );
+}
+
+KMMsgInfo* KMFolder::unGetMsg( int idx )
+{
+ return mStorage->unGetMsg( idx );
+}
+
+bool KMFolder::isMessage( int idx )
+{
+ return mStorage->isMessage( idx );
+}
+
+DwString KMFolder::getDwString( int idx )
+{
+ return mStorage->getDwString( idx );
+}
+
+void KMFolder::ignoreJobsForMessage( KMMessage* m )
+{
+ mStorage->ignoreJobsForMessage( m );
+}
+
+FolderJob* KMFolder::createJob( KMMessage *msg, FolderJob::JobType jt,
+ KMFolder *folder, QString partSpecifier,
+ const AttachmentStrategy *as ) const
+{
+ return mStorage->createJob( msg, jt, folder, partSpecifier, as );
+}
+
+FolderJob* KMFolder::createJob( QPtrList<KMMessage>& msgList,
+ const QString& sets,
+ FolderJob::JobType jt, KMFolder *folder ) const
+{
+ return mStorage->createJob( msgList, sets, jt, folder );
+}
+
+const KMMsgBase* KMFolder::getMsgBase( int idx ) const
+{
+ return mStorage->getMsgBase( idx );
+}
+
+KMMsgBase* KMFolder::getMsgBase( int idx )
+{
+ return mStorage->getMsgBase( idx );
+}
+
+const KMMsgBase* KMFolder::operator[]( int idx ) const
+{
+ return mStorage->operator[]( idx );
+}
+
+KMMsgBase* KMFolder::operator[]( int idx )
+{
+ return mStorage->operator[]( idx );
+}
+
+KMMessage* KMFolder::take( int idx )
+{
+ return mStorage->take( idx );
+}
+
+void KMFolder::take( QPtrList<KMMessage> msgList ) // TODO const ref
+{
+ mStorage->take( msgList );
+}
+
+int KMFolder::addMsg( KMMessage* msg, int* index_return )
+{
+ return mStorage->addMsg( msg, index_return );
+}
+
+int KMFolder::addMsgKeepUID( KMMessage* msg, int* index_return )
+{
+ return mStorage->addMsgKeepUID( msg, index_return );
+}
+
+int KMFolder::addMsg( QPtrList<KMMessage>& list, QValueList<int>& index_return )
+{
+ return mStorage->addMsg( list, index_return );
+}
+
+void KMFolder::emitMsgAddedSignals( int idx )
+{
+ mStorage->emitMsgAddedSignals( idx );
+}
+
+void KMFolder::removeMsg( int i, bool imapQuiet )
+{
+ mStorage->removeMsg( i, imapQuiet );
+}
+
+void KMFolder::removeMsg( QPtrList<KMMessage> msgList, bool imapQuiet ) // TODO const ref
+{
+ mStorage->removeMsg( msgList, imapQuiet );
+}
+
+int KMFolder::expungeOldMsg( int days )
+{
+ return mStorage->expungeOldMsg( days );
+}
+
+int KMFolder::moveMsg( KMMessage* msg, int* index_return )
+{
+ return mStorage->moveMsg( msg, index_return );
+}
+
+int KMFolder::moveMsg(QPtrList<KMMessage> q, int* index_return )
+{
+ return mStorage->moveMsg( q, index_return );
+}
+
+int KMFolder::find( const KMMsgBase* msg ) const
+{
+ return mStorage ? mStorage->find( msg ) : -1;
+}
+
+int KMFolder::find( const KMMessage* msg ) const
+{
+ return mStorage ? mStorage->find( msg ) : -1;
+}
+
+int KMFolder::count( bool cache ) const
+{
+ return mStorage->count( cache );
+}
+
+int KMFolder::countUnread()
+{
+ return mStorage->countUnread();
+}
+
+int KMFolder::countUnreadRecursive()
+{
+ KMFolder *folder;
+ int count = countUnread();
+ KMFolderDir *dir = child();
+ if (!dir)
+ return count;
+
+ QPtrListIterator<KMFolderNode> it(*dir);
+ for ( ; it.current(); ++it )
+ if (!it.current()->isDir()) {
+ folder = static_cast<KMFolder*>(it.current());
+ count += folder->countUnreadRecursive();
+ }
+
+ return count;
+}
+
+void KMFolder::msgStatusChanged( const KMMsgStatus oldStatus,
+ const KMMsgStatus newStatus, int idx )
+{
+ mStorage->msgStatusChanged( oldStatus, newStatus, idx );
+}
+
+int KMFolder::open(const char *owner)
+{
+ return mStorage->open(owner);
+}
+
+int KMFolder::canAccess()
+{
+ return mStorage->canAccess();
+}
+
+void KMFolder::close( const char *owner, bool force )
+{
+ // do not emit closed() in here - as this would regain too early
+ mStorage->close( owner, force );
+}
+
+void KMFolder::sync()
+{
+ mStorage->sync();
+}
+
+bool KMFolder::isOpened() const
+{
+ return mStorage->isOpened();
+}
+
+void KMFolder::markNewAsUnread()
+{
+ mStorage->markNewAsUnread();
+}
+
+void KMFolder::markUnreadAsRead()
+{
+ mStorage->markUnreadAsRead();
+}
+
+void KMFolder::remove()
+{
+ /* The storage needs to be open before remove is called, otherwise
+ it will not unregister the corresponding serial numbers from
+ the message dict, since its message list is empty, and the .ids
+ file contents are not loaded. That can lead to lookups in the
+ dict returning stale pointers to the folder later. */
+ mStorage->open("kmfolder_remove");
+ mStorage->remove();
+}
+
+int KMFolder::expunge()
+{
+ return mStorage->expunge();
+}
+
+int KMFolder::rename( const QString& newName, KMFolderDir *aParent )
+{
+ return mStorage->rename( newName, aParent );
+}
+
+bool KMFolder::dirty() const
+{
+ return mStorage->dirty();
+}
+
+void KMFolder::setDirty( bool f )
+{
+ mStorage->setDirty( f );
+}
+
+bool KMFolder::needsCompacting() const
+{
+ return mStorage->needsCompacting();
+}
+
+void KMFolder::setNeedsCompacting( bool f )
+{
+ mStorage->setNeedsCompacting( f );
+}
+
+void KMFolder::quiet( bool beQuiet )
+{
+ mStorage->quiet( beQuiet );
+}
+
+bool KMFolder::isReadOnly() const
+{
+ return mStorage->isReadOnly();
+}
+
+QString KMFolder::label() const
+{
+ if ( !mSystemLabel.isEmpty() )
+ return mSystemLabel;
+ if ( !mLabel.isEmpty() )
+ return mLabel;
+ if ( isSystemFolder() )
+ return i18n( name().utf8() );
+ return name();
+}
+
+//-----------------------------------------------------------------------------
+QString KMFolder::prettyURL() const
+{
+ QString parentUrl;
+ if ( parent() )
+ parentUrl = parent()->prettyURL();
+ if ( !parentUrl.isEmpty() )
+ return parentUrl + '/' + label();
+ else
+ return label();
+}
+
+//--------------------------------------------------------------------------
+QString KMFolder::mailingListPostAddress() const
+{
+ if ( mMailingList.features() & MailingList::Post ) {
+ KURL::List::const_iterator it;
+ KURL::List post = mMailingList.postURLS();
+ for( it = post.begin(); it != post.end(); ++it ) {
+ // We check for isEmpty because before 3.3 postAddress was just an
+ // [email protected] and that leaves protocol() field in the kurl class
+ if ( (*it).protocol() == "mailto" || (*it).protocol().isEmpty() )
+ return (*it).path();
+ }
+ }
+ return QString::null;
+}
+
+void KMFolder::setMailingListEnabled( bool enabled )
+{
+ mMailingListEnabled = enabled;
+ mStorage->writeConfig();
+}
+
+void KMFolder::setMailingList( const MailingList& mlist )
+{
+ mMailingList = mlist;
+ mStorage->writeConfig();
+}
+
+void KMFolder::setIdentity( uint identity )
+{
+ mIdentity = identity;
+ kmkernel->slotRequestConfigSync();
+}
+
+uint KMFolder::identity() const
+{
+ // if we don't have one set ourselves, check our account
+ kdDebug() << "FOO: " << mIdentity << " :: " << mStorage << endl;
+ if ( !mIdentity && mStorage )
+ if ( KMAccount *act = mStorage->account() )
+ return act->identityId();
+ return mIdentity;
+}
+
+void KMFolder::setWhoField(const QString& aWhoField )
+{
+ mWhoField = aWhoField;
+#if 0
+ // This isn't saved in the config anyway
+ mStorage->writeConfig();
+#endif
+}
+
+void KMFolder::setUserWhoField( const QString& whoField, bool writeConfig )
+{
+ if ( mUserWhoField == whoField )
+ return;
+ if ( whoField.isEmpty() )
+ {
+ // default setting
+ const KPIM::Identity & identity =
+ kmkernel->identityManager()->identityForUoidOrDefault( mIdentity );
+
+ if ( isSystemFolder() && folderType() != KMFolderTypeImap ) {
+ // local system folders
+ if ( this == kmkernel->inboxFolder() ||
+ this == kmkernel->trashFolder() )
+ mWhoField = "From";
+ if ( this == kmkernel->outboxFolder() ||
+ this == kmkernel->sentFolder() ||
+ this == kmkernel->draftsFolder() ||
+ this == kmkernel->templatesFolder() )
+ mWhoField = "To";
+ } else if ( identity.drafts() == idString() ||
+ identity.templates() == idString() ||
+ identity.fcc() == idString() )
+ // drafts, templates or sent of the identity
+ mWhoField = "To";
+ else
+ mWhoField = "From";
+ } else if ( whoField == "From" || whoField == "To" )
+ // set the whoField according to the user-setting
+ mWhoField = whoField;
+ else {
+ // this should not happen...
+ kdDebug(5006) << "Illegal setting " << whoField << " for userWhoField!"
+ << endl;
+ return; // don't use the value
+ }
+ mUserWhoField = whoField;
+
+ if (writeConfig)
+ mStorage->writeConfig();
+ emit viewConfigChanged();
+}
+
+void KMFolder::correctUnreadMsgsCount()
+{
+ mStorage->correctUnreadMsgsCount();
+}
+
+QString KMFolder::idString() const
+{
+ KMFolderNode* folderNode = parent();
+ if (!folderNode)
+ return "";
+ while ( folderNode->parent() )
+ folderNode = folderNode->parent();
+ QString myPath = path();
+ int pathLen = myPath.length() - folderNode->path().length();
+ QString relativePath = myPath.right( pathLen );
+ if (!relativePath.isEmpty())
+ relativePath = relativePath.right( relativePath.length() - 1 ) + "/";
+ QString escapedName = name();
+ /* Escape [ and ] as they are disallowed for kconfig sections and that is
+ what the idString is primarily used for. */
+ escapedName.replace( "[", "%(" );
+ escapedName.replace( "]", "%)" );
+ return relativePath + escapedName;
+}
+
+void KMFolder::setAutoExpire( bool enabled )
+{
+ if( enabled != mExpireMessages ) {
+ mExpireMessages = enabled;
+ mStorage->writeConfig();
+ }
+}
+
+void KMFolder::setUnreadExpireAge( int age )
+{
+ if( age >= 0 && age != mUnreadExpireAge ) {
+ mUnreadExpireAge = age;
+ mStorage->writeConfig();
+ }
+}
+
+void KMFolder::setUnreadExpireUnits( ExpireUnits units )
+{
+ if (units >= expireNever && units < expireMaxUnits)
+ mUnreadExpireUnits = units;
+ mStorage->writeConfig();
+}
+
+void KMFolder::setReadExpireAge( int age )
+{
+ if( age >= 0 && age != mReadExpireAge ) {
+ mReadExpireAge = age;
+ mStorage->writeConfig();
+ }
+}
+
+void KMFolder::setReadExpireUnits( ExpireUnits units )
+{
+ if (units >= expireNever && units <= expireMaxUnits)
+ mReadExpireUnits = units;
+ mStorage->writeConfig();
+}
+
+
+void KMFolder::setExpireAction( ExpireAction a )
+{
+ if ( a != mExpireAction ) {
+ mExpireAction = a;
+ mStorage->writeConfig();
+ }
+}
+
+void KMFolder::setExpireToFolderId( const QString& id )
+{
+ if ( id != mExpireToFolderId ) {
+ mExpireToFolderId = id;
+ mStorage->writeConfig();
+ }
+}
+
+
+static int daysToExpire( int number, ExpireUnits units )
+{
+ switch (units) {
+ case expireDays: // Days
+ return number;
+ case expireWeeks: // Weeks
+ return number * 7;
+ case expireMonths: // Months - this could be better rather than assuming 31day months.
+ return number * 31;
+ default: // this avoids a compiler warning (not handled enumeration values)
+ ;
+ }
+ return -1;
+}
+
+void KMFolder::daysToExpire(int& unreadDays, int& readDays) {
+ unreadDays = ::daysToExpire( getUnreadExpireAge(), getUnreadExpireUnits() );
+ readDays = ::daysToExpire( getReadExpireAge(), getReadExpireUnits() );
+}
+
+void KMFolder::expireOldMessages( bool immediate )
+{
+ KMail::ScheduledExpireTask* task = new KMail::ScheduledExpireTask(this, immediate);
+ kmkernel->jobScheduler()->registerTask( task );
+ if ( immediate ) {
+ // #82259: compact after expiring.
+ compact( CompactLater );
+ }
+}
+
+void KMFolder::compact( CompactOptions options )
+{
+ if ( options == CompactLater ) {
+ KMail::ScheduledCompactionTask* task = new KMail::ScheduledCompactionTask(this, false);
+ kmkernel->jobScheduler()->registerTask( task );
+ } else {
+ mStorage->compact( options == CompactSilentlyNow );
+ }
+}
+
+KMFolder* KMFolder::trashFolder() const
+{
+ return mStorage ? mStorage->trashFolder() : 0;
+}
+
+int KMFolder::writeIndex( bool createEmptyIndex )
+{
+ return mStorage->writeIndex( createEmptyIndex );
+}
+
+void KMFolder::setStatus( int idx, KMMsgStatus status, bool toggle )
+{
+ mStorage->setStatus( idx, status, toggle );
+}
+
+void KMFolder::setStatus( QValueList<int>& ids, KMMsgStatus status,
+ bool toggle )
+{
+ mStorage->setStatus( ids, status, toggle);
+}
+
+void KMFolder::setIconPaths( const QString &normalPath,
+ const QString &unreadPath )
+{
+ mNormalIconPath = normalPath;
+ mUnreadIconPath = unreadPath;
+ mStorage->writeConfig();
+ emit iconsChanged();
+}
+
+void KMFolder::removeJobs()
+{
+ mStorage->removeJobs();
+}
+
+int KMFolder::updateIndex()
+{
+ return mStorage->updateIndex();
+}
+
+void KMFolder::reallyAddMsg( KMMessage* aMsg )
+{
+ mStorage->reallyAddMsg( aMsg );
+}
+
+void KMFolder::reallyAddCopyOfMsg( KMMessage* aMsg )
+{
+ mStorage->reallyAddCopyOfMsg( aMsg );
+}
+
+void KMFolder::setShortcut( const KShortcut &sc )
+{
+ if ( mShortcut != sc ) {
+ mShortcut = sc;
+ emit shortcutChanged( this );
+ }
+}
+
+bool KMFolder::isMoveable() const
+{
+ return !isSystemFolder();
+}
+
+void KMFolder::slotContentsTypeChanged( KMail::FolderContentsType type )
+{
+ kmkernel->iCalIface().folderContentsTypeChanged( this, type );
+ emit iconsChanged();
+}
+
+void KMFolder::slotFolderSizeChanged()
+{
+ emit folderSizeChanged( this );
+ KMFolder* papa = parent()->manager()->parentFolder( this );
+ if ( papa && papa != this ) {
+ papa->slotFolderSizeChanged();
+ }
+}
+
+
+#include "kmfolder.moc"