summaryrefslogtreecommitdiffstats
path: root/kmail/kmfolderimap.h
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/kmfolderimap.h
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/kmfolderimap.h')
-rw-r--r--kmail/kmfolderimap.h548
1 files changed, 548 insertions, 0 deletions
diff --git a/kmail/kmfolderimap.h b/kmail/kmfolderimap.h
new file mode 100644
index 000000000..f7c027e0e
--- /dev/null
+++ b/kmail/kmfolderimap.h
@@ -0,0 +1,548 @@
+/*
+ * kmfolderimap.h
+ *
+ * Copyright (c) 2001 Kurt Granroth <granroth@kde.org>
+ * Copyright (c) 2000-2002 Michael Haeckel <haeckel@kde.org>
+ *
+ * This file is based on kmacctimap.h by Michael Haeckel which is
+ * based on popaccount.h by Don Sanders
+ *
+ * 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; version 2 of the License
+ *
+ * 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.
+ */
+
+#ifndef kmfolderimap_h
+#define kmfolderimap_h
+
+#include "kmacctimap.h"
+#include "kmfoldermbox.h"
+#include "kmmsgbase.h"
+
+#include "kio/job.h"
+#include "kio/global.h"
+
+#include <kstandarddirs.h>
+
+#include <qintdict.h>
+#include <qdict.h>
+template< typename T> class QPtrList;
+template< typename T> class QValueList;
+
+class KMFolderTreeItem;
+class KMFolderImap;
+class KMSearchPattern;
+class KMMessage;
+namespace KMail {
+ class FolderJob;
+ class ImapJob;
+ class AttachmentStrategy;
+ class ImapAccountBase;
+}
+namespace KPIM {
+ class ProgressItem;
+}
+using KMail::FolderJob;
+using KMail::ImapJob;
+using KMail::AttachmentStrategy;
+using KMail::ImapAccountBase;
+using KPIM::ProgressItem;
+
+class KMMsgMetaData
+{
+public:
+ KMMsgMetaData(KMMsgStatus aStatus)
+ :mStatus(aStatus), mSerNum(0) {}
+ KMMsgMetaData(KMMsgStatus aStatus, Q_UINT32 aSerNum)
+ :mStatus(aStatus), mSerNum(aSerNum) {}
+ ~KMMsgMetaData() {};
+ const KMMsgStatus status() const { return mStatus; }
+ const Q_UINT32 serNum() const { return mSerNum; }
+private:
+ KMMsgStatus mStatus;
+ Q_UINT32 mSerNum;
+};
+
+
+
+class KMFolderImap : public KMFolderMbox
+{
+ Q_OBJECT
+ friend class ::KMail::ImapJob;
+public:
+
+ static QString cacheLocation() {
+ return locateLocal("data", "kmail/imap" );
+ }
+
+ enum imapState {
+ imapNoInformation = 0,
+ imapListingInProgress = 1,
+ imapDownloadInProgress = 2,
+ imapFinished = 3
+ };
+
+ virtual imapState getContentState() { return mContentState; }
+ virtual void setContentState(imapState state) { mContentState = state; }
+
+ virtual imapState getSubfolderState() { return mSubfolderState; }
+ virtual void setSubfolderState(imapState state);
+
+ /** Usually a parent is given. But in some cases there is no
+ fitting parent object available. Then the name of the folder
+ is used as the absolute path to the folder file. */
+ KMFolderImap(KMFolder* folder, const char* name=0);
+ virtual ~KMFolderImap();
+
+ /** Returns the type of this folder */
+ virtual KMFolderType folderType() const { return KMFolderTypeImap; }
+
+ virtual KMMessage* getMsg(int idx);
+ /** The path to the imap folder on the server */
+ void setImapPath( const QString &path );
+ QString imapPath() const { return mImapPath; }
+
+ /** The highest UID in the folder */
+ ulong lastUid();
+
+ /** The uidvalidity of the last update */
+ void setUidValidity(const QString &validity) { mUidValidity = validity; }
+ QString uidValidity() { return mUidValidity; }
+
+ /** The imap account associated with this folder */
+ void setAccount(KMAcctImap *acct);
+ KMAcctImap* account() const;
+
+ /** Remove (first occurrence of) given message from the folder. */
+ virtual void removeMsg(int i, bool quiet = FALSE);
+ virtual void removeMsg(const QPtrList<KMMessage>& msgList, bool quiet = FALSE);
+
+ virtual int rename( const QString& newName, KMFolderDir *aParent = 0 );
+
+ /** Remove the IMAP folder on the server and if successful also locally */
+ virtual void remove();
+
+ /** Automatically expunge deleted messages when leaving the folder */
+ bool autoExpunge();
+
+ /** Write the config file */
+ virtual void writeConfig();
+
+ /** Read the config file */
+ virtual void readConfig();
+
+ /**
+ * List a directory and add the contents to kmfoldermgr
+ * It uses a ListJob to get the folders
+ * returns false if the connection failed
+ */
+ virtual bool listDirectory();
+
+ /**
+ * Retrieve all mails in a folder
+ */
+ void getFolder(bool force = FALSE);
+
+ /**
+ * same as above but also checks for new mails
+ */
+ void getAndCheckFolder(bool force = FALSE);
+
+ /**
+ * Get the whole message
+ */
+ void getMessage(KMFolder * folder, KMMessage * msg);
+
+ /**
+ * Create a new subfolder
+ * You may specify the root imap path or this folder will be used
+ * If you set askUser to false and the server can only handle folders
+ * that contain messages _or_ folders the new folder is set to "contains messages"
+ * by default
+ */
+ void createFolder(const QString &name,
+ const QString& imapPath = QString::null, bool askUser = true);
+
+ /**
+ * Delete a message
+ */
+ void deleteMessage(KMMessage * msg);
+ void deleteMessage(const QPtrList<KMMessage>& msgList);
+
+ /**
+ * Change the status of the message indicated by @p index
+ * Overloaded function for the following one
+ */
+ virtual void setStatus(int idx, KMMsgStatus status, bool toggle);
+
+ /**
+ * Change the status of several messages indicated by @p ids
+ */
+ virtual void setStatus(QValueList<int>& _ids, KMMsgStatus status, bool toggle);
+
+ /** generates sets of uids */
+ static QStringList makeSets( QValueList<ulong>&, bool sort = true);
+ static QStringList makeSets(const QStringList&, bool sort = true);
+
+ /** splits the message list according to sets. Modifies the @msgList. */
+ static QPtrList<KMMessage> splitMessageList(const QString& set,
+ QPtrList<KMMessage>& msgList);
+
+ /** gets the uids of the given ids */
+ void getUids(QValueList<int>& ids, QValueList<ulong>& uids);
+
+ /** same as above but accepts a Message-List */
+ void getUids(const QPtrList<KMMessage>& msgList, QValueList<ulong>& uids);
+
+ /**
+ * Expunge deleted messages from the folder
+ */
+ void expungeFolder(KMFolderImap * aFolder, bool quiet);
+
+ virtual int compact( bool ) { expungeFolder(this, false); return 0; };
+
+ /**
+ * Emit the folderComplete signal
+ */
+ void sendFolderComplete(bool success)
+ { emit folderComplete(this, success); }
+
+ /**
+ * Refresh the number of unseen mails
+ * Returns false in an error condition
+ */
+ bool processNewMail(bool interactive);
+
+ /**
+ * Tell the folder, this it is selected and shall also display new mails,
+ * not only their number, when checking for mail.
+ */
+ void setSelected(bool selected) { mIsSelected = selected; }
+ bool isSelected() { return mIsSelected; }
+
+ /**
+ * Encode the given string in a filename save 7 bit string
+ */
+ static QString encodeFileName(const QString &);
+ static QString decodeFileName(const QString &);
+ static QTextCodec * utf7Codec();
+
+ /**
+ * Convert message status to a list of IMAP flags
+ */
+ static QString statusToFlags(KMMsgStatus status, int supportedFalgs);
+
+ /**
+ * Return the filename of the folder (reimplemented from KFolder)
+ */
+ virtual QString fileName() const {
+ return encodeFileName( KMFolderMbox::fileName() ); }
+
+ /**
+ * Get the serial number for the given UID (if available)
+ */
+ const ulong serNumForUID( ulong uid );
+
+ /**
+ * Save the metadata for the UID
+ * If the UID is not supplied the one from the message is taken
+ */
+ void saveMsgMetaData( KMMessage* msg, ulong uid = 0 );
+
+ /**
+ * Splits a uid-set into single uids
+ */
+ static QValueList<ulong> splitSets(const QString);
+
+ virtual void ignoreJobsForMessage( KMMessage* );
+
+ /**
+ * If this folder should be included in new-mail-check
+ */
+ bool includeInMailCheck() { return mCheckMail; }
+ void setIncludeInMailCheck( bool check );
+
+ /** Inherited */
+ virtual int create();
+
+ /** imap folders cannot expire */
+ virtual bool isAutoExpire() const { return false; }
+
+ /** Closes and cancels all pending jobs. */
+ virtual void reallyDoClose(const char* owner);
+
+ void setCheckingValidity( bool val ) { mCheckingValidity = val; }
+
+ /** Return the trash folder. */
+ KMFolder* trashFolder() const;
+
+ /**
+ * Mark the folder as already removed from the server
+ * If set to true the folder will only be deleted locally
+ * This will recursively be applied to all children
+ */
+ void setAlreadyRemoved(bool removed);
+
+ /// Is the folder readonly?
+ bool isReadOnly() const { return KMFolderMbox::isReadOnly() || mReadOnly; }
+
+ /**
+ * The user's rights on this folder - see bitfield in ACLJobs namespace.
+ * @return 0 when not known yet
+ */
+ unsigned int userRights() const { return mUserRights; }
+
+ /** Set the user's rights on this folder - called by getUserRights */
+ void setUserRights( unsigned int userRights );
+
+ /**
+ * Search for messages
+ * The actual search is done in slotSearch and the end
+ * is signaled with searchDone()
+ */
+ virtual void search( const KMSearchPattern* );
+ virtual void search( const KMSearchPattern*, Q_UINT32 serNum );
+
+ /** Returns true if this folder can be moved */
+ virtual bool isMoveable() const;
+
+ /** Initialize this storage from another one. Used when creating a child folder */
+ void initializeFrom( KMFolderImap* parent, QString path, QString mimeType );
+
+ /** Returns the IMAP flags that can be stored on the server. */
+ int permanentFlags() const { return mPermanentFlags; }
+
+signals:
+ void folderComplete(KMFolderImap *folder, bool success);
+
+ /**
+ * Emitted, when the account is deleted
+ */
+ void deleted(KMFolderImap*);
+
+ /**
+ * Emitted at the end of the directory listing
+ */
+ void directoryListingFinished(KMFolderImap*);
+
+ /**
+ * Emitted when a folder creation has finished.
+ * @param name The name of the folder that should have been created.
+ * @param success True if the folder was created, false otherwise.
+ */
+ void folderCreationResult( const QString &name, bool success );
+
+public slots:
+ /** Add a message to a folder after is has been added on an IMAP server */
+ virtual void addMsgQuiet(KMMessage *);
+ virtual void addMsgQuiet(QPtrList<KMMessage>);
+
+ /** Add the given message to the folder. Usually the message
+ is added at the end of the folder. Returns zero on success and
+ an errno error code on failure. The index of the new message
+ is stored in index_return if given.
+ Please note that the message is added as is to the folder and the folder
+ takes ownership of the message (deleting it in the destructor).*/
+ virtual int addMsg(KMMessage* msg, int* index_return = 0);
+ virtual int addMsg(QPtrList<KMMessage>&, QValueList<int>& index_return);
+
+ /** Copy the messages to this folder */
+ void copyMsg(QPtrList<KMMessage>& msgList/*, KMFolder* parent*/);
+
+
+ /** Detach message from this folder. Usable to call addMsg() afterwards.
+ Loads the message if it is not loaded up to now. */
+ virtual KMMessage* take(int idx);
+ virtual void take(QPtrList<KMMessage>);
+
+ /**
+ * Add the data a KIO::Job retrieves to the buffer
+ */
+ void slotSimpleData(KIO::Job * job, const QByteArray & data);
+
+ /**
+ * Convert IMAP flags to a message status
+ * @param newMsg specifies whether unseen messages are new or unread
+ */
+ static void flagsToStatus(KMMsgBase *msg, int flags, bool newMsg = TRUE, int supportedFalgs = 31 );
+
+ /**
+ * Convert IMAP seen flag to a message status.
+ * @param newMsg specifies whether unseen messages are new or unread
+ */
+ static void seenFlagToStatus( KMMsgBase *msg, int flags, bool newMsg = true );
+
+ /**
+ * Connected to the result signal of the copy/move job
+ */
+ void slotCopyMsgResult( KMail::FolderJob* job );
+
+ /**
+ * Called from the SearchJob when the folder is done or messages where found
+ */
+ void slotSearchDone( QValueList<Q_UINT32> serNums,
+ const KMSearchPattern* pattern,
+ bool complete );
+
+ /**
+ * Called from the SearchJob when the message was searched
+ */
+ void slotSearchDone( Q_UINT32 serNum, const KMSearchPattern* pattern, bool matches );
+
+ /**
+ * Connected to ListJob::receivedFolders
+ * creates/removes folders
+ */
+ void slotListResult( const QStringList&, const QStringList&,
+ const QStringList&, const QStringList&, const ImapAccountBase::jobData& );
+
+ /**
+ * Connected to slotListNamespaces
+ * creates/removes namespace folders
+ */
+ void slotCheckNamespace( const QStringList&, const QStringList&,
+ const QStringList&, const QStringList&, const ImapAccountBase::jobData& );
+
+protected:
+ virtual FolderJob* doCreateJob( KMMessage *msg, FolderJob::JobType jt,
+ KMFolder *folder, QString partSpecifier,
+ const AttachmentStrategy *as ) const;
+ virtual FolderJob* doCreateJob( QPtrList<KMMessage>& msgList, const QString& sets,
+ FolderJob::JobType jt, KMFolder *folder ) const;
+
+ void getMessagesResult(KIO::Job * job, bool lastSet);
+
+ /** Called by KMFolder::expunge() to delete the actual contents.
+ At the time of the call the folder has already been closed, and
+ the various index files deleted. Returns 0 on success. */
+ virtual int expungeContents();
+
+ void setChildrenState( QString attributes );
+
+ /** Create or find the INBOX and initialize it */
+ void initInbox();
+
+ /** See if there is a better parent then this folder */
+ KMFolderImap* findParent( const QString& path, const QString& name );
+
+ /** See if all folders are still present on server, otherwise delete them */
+ void checkFolders( const QStringList& folderNames, const QString& ns );
+
+ void finishMailCheck( const char *func, imapState state );
+
+protected slots:
+
+ /**
+ * Retrieve the whole folder or only the changes
+ */
+ void checkValidity();
+ void slotCheckValidityResult(KIO::Job * job);
+
+ /**
+ * Get the folder now (internal)
+ */
+ void reallyGetFolder(const QString &startUid = QString::null);
+
+ /**
+ * For listing the contents of a folder
+ */
+ void slotListFolderResult(KIO::Job * job);
+ void slotListFolderEntries(KIO::Job * job, const KIO::UDSEntryList & uds);
+
+ /**
+ * For retrieving a message digest
+ */
+ void slotGetMessagesResult(KIO::Job * job);
+ void slotGetLastMessagesResult(KIO::Job * job);
+ void slotGetMessagesData(KIO::Job * job, const QByteArray & data);
+
+ /**
+ * For creating a new subfolder
+ */
+ void slotCreateFolderResult(KIO::Job * job);
+
+ /**
+ * Remove the folder also locally, if removing on the server succeeded
+ */
+ void slotRemoveFolderResult(KIO::Job *job);
+
+ /**
+ * Update the number of unseen messages
+ */
+ void slotStatResult(KIO::Job *job);
+
+ /**
+ * notify the progress item that the mail check for this folder is
+ * done.
+ */
+ void slotCompleteMailCheckProgress();
+
+ /**
+ * Is called when the slave is connected and triggers a newmail check
+ */
+ void slotProcessNewMail( int errorCode, const QString& errorMsg );
+
+ /**
+ * Is connected when there are folders to be created on startup and the
+ * account is still connecting. Once the account emits the connected
+ * signal this slot is called and the folders created.
+ */
+ void slotCreatePendingFolders( int errorCode, const QString& errorMsg );
+
+ /**
+ * Starts a namespace listing
+ */
+ void slotListNamespaces();
+
+protected:
+ QString mImapPath;
+ ulong mLastUid;
+ imapState mContentState, mSubfolderState;
+ bool mIsSelected;
+ bool mCheckFlags;
+ bool mReadOnly;
+ bool mCheckMail;
+ mutable QGuardedPtr<KMAcctImap> mAccount;
+ // the current uidvalidity
+ QString mUidValidity;
+ unsigned int mUserRights;
+
+private:
+ // if we're checking validity currently
+ bool mCheckingValidity;
+ // uid - metadata cache
+ QIntDict<KMMsgMetaData> mUidMetaDataMap;
+ // msgidMD5 - status map
+ QDict<KMMsgMetaData> mMetaDataMap;
+ // if the folder should be deleted without server roundtrip
+ bool mAlreadyRemoved;
+ // the progress for mailchecks
+ QGuardedPtr<ProgressItem> mMailCheckProgressItem;
+ // the progress for listings
+ ProgressItem *mListDirProgressItem;
+ // the progress for addMsg
+ ProgressItem *mAddMessageProgressItem;
+ // to-be-added folders
+ QStringList mFoldersPendingCreation;
+
+ // push all flags to the server instead of just the changed once
+ // when doing a flag change the next time
+ // this is needed for migrating local flags from the time where we didn't
+ // have the ability to store them on the server
+ bool mUploadAllFlags;
+
+ // PERMANENTFLAGS part of SELECT response, needed to determine if custom flags can be
+ // stored on the server
+ int mPermanentFlags;
+};
+
+#endif // kmfolderimap_h