kmfolderimap.h

/*
 * 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 "acljobs.h"
#include "kmacctimap.h"
#include "kmfoldermbox.h"
#include "kmmsgbase.h"
 
#include "tdeio/job.h"
#include "tdeio/global.h"
 
#include <tdestandarddirs.h>
 
#include <tqintdict.h>
#include <tqdict.h>
template< typename T> class TQPtrList;
template< typename T> class TQValueList;
 
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, TQ_UINT32 aSerNum)
    :mStatus(aStatus), mSerNum(aSerNum) {}
  ~KMMsgMetaData() {};
  KMMsgStatus status() const { return mStatus; }
  TQ_UINT32 serNum() const { return mSerNum; }
private:
  KMMsgStatus mStatus;
  TQ_UINT32 mSerNum;
};
 
 
 
class KMFolderImap : public KMFolderMbox
{
  TQ_OBJECT
  
  friend class ::KMail::ImapJob;
public:
 
  static TQString cacheLocation() {
     return locateLocal("data", "kmail/imap" );
  }
 
  enum imapState {
    imapNoInformation = 0,
    imapListingInProgress = 1,
    imapDownloadInProgress = 2,
    imapFinished = 3
  };
 
  virtual imapState getContentState() const { return mContentState; }
  virtual void setContentState(imapState state) { mContentState = state; }
 
  virtual imapState getSubfolderState() { return mSubfolderState; }
  virtual void setSubfolderState(imapState state);
 
  KMFolderImap(KMFolder* folder, const char* name=0);
  virtual ~KMFolderImap();
 
  virtual KMFolderType folderType() const { return KMFolderTypeImap; }
 
  virtual KMMessage* getMsg(int idx);
  void setImapPath( const TQString &path );
  TQString imapPath() const { return mImapPath; }
 
  ulong lastUid();
 
  void setUidValidity(const TQString &validity) { mUidValidity = validity; }
  TQString uidValidity() { return mUidValidity; }
 
  void setAccount(KMAcctImap *acct);
  KMAcctImap* account() const;
 
  virtual void removeMsg(int i, bool quiet = FALSE);
  virtual void removeMsg(const TQPtrList<KMMessage>& msgList, bool quiet = FALSE);
 
  virtual int rename( const TQString& newName, KMFolderDir *aParent = 0 );
 
  virtual void remove();
 
  bool autoExpunge();
 
  virtual void writeConfig();
 
  virtual void readConfig();
 
  virtual bool listDirectory();
 
  void getFolder(bool force = FALSE);
 
  void getAndCheckFolder(bool force = FALSE);
 
  void getMessage(KMFolder * folder, KMMessage * msg);
 
  void createFolder(const TQString &name,
      const TQString& imapPath = TQString(), bool askUser = true);
 
  void deleteMessage(KMMessage * msg);
  void deleteMessage(const TQPtrList<KMMessage>& msgList);
 
  virtual void setStatus(int idx, KMMsgStatus status, bool toggle);
 
  virtual void setStatus(TQValueList<int>& _ids, KMMsgStatus status, bool toggle);
 
  static TQStringList makeSets( TQValueList<ulong>&, bool sort = true);
  static TQStringList makeSets(const TQStringList&, bool sort = true);
 
  static TQPtrList<KMMessage> splitMessageList(const TQString& set,
                                              TQPtrList<KMMessage>& msgList);
 
  void getUids(TQValueList<int>& ids, TQValueList<ulong>& uids);
 
  void getUids(const TQPtrList<KMMessage>& msgList, TQValueList<ulong>& uids);
 
  void expungeFolder(KMFolderImap * aFolder, bool quiet);
 
  virtual int compact( bool ) { expungeFolder(this, false); return 0; };
 
  void sendFolderComplete(bool success)
  { emit folderComplete(this, success); }
 
  bool processNewMail(bool interactive);
 
  void setSelected(bool selected) { mIsSelected = selected; }
  bool isSelected() { return mIsSelected; }
 
  static TQString encodeFileName(const TQString &);
  static TQString decodeFileName(const TQString &);
  static TQTextCodec * utf7Codec();
 
  static TQString statusToFlags(KMMsgStatus status, int supportedFalgs);
 
  virtual TQString fileName() const {
    return encodeFileName( KMFolderMbox::fileName() ); }
 
   ulong serNumForUID( ulong uid );
 
  void saveMsgMetaData( KMMessage* msg, ulong uid = 0 );
 
  static TQValueList<ulong> splitSets(const TQString);
 
  virtual void ignoreJobsForMessage( KMMessage* );
 
  bool includeInMailCheck() { return mCheckMail; }
  void setIncludeInMailCheck( bool check );
 
  virtual int create();
 
  virtual bool isAutoExpire() const { return false; }
 
  virtual void reallyDoClose(const char* owner);
 
  void setCheckingValidity( bool val ) { mCheckingValidity = val; }
 
  KMFolder* trashFolder() const;
 
  void setAlreadyRemoved(bool removed);
 
  bool isReadOnly() const { return KMFolderMbox::isReadOnly() || mReadOnly; }
  bool canDeleteMessages() const;
 
  unsigned int userRights() const { return mUserRights; }
  KMail::ACLJobs::ACLFetchState userRightsState() const { return mUserRightsState; }
 
  void setUserRights( unsigned int userRights, KMail::ACLJobs::ACLFetchState userRightsState );
 
  virtual void search( const KMSearchPattern* );
  virtual void search( const KMSearchPattern*, TQ_UINT32 serNum );
 
  virtual bool isMoveable() const;
 
  void initializeFrom( KMFolderImap* parent, TQString path, TQString mimeType );
 
  int permanentFlags() const { return mPermanentFlags; }
 
  virtual bool mailCheckInProgress() const;
 
signals:
  void folderComplete(KMFolderImap *folder, bool success);
 
  void deleted(KMFolderImap*);
 
  void directoryListingFinished(KMFolderImap*);
 
  void folderCreationResult( const TQString &name, bool success );
 
public slots:
  virtual void addMsgQuiet(KMMessage *);
  virtual void addMsgQuiet(TQPtrList<KMMessage>);
 
  virtual int addMsg(KMMessage* msg, int* index_return = 0);
  virtual int addMsg(TQPtrList<KMMessage>&, TQValueList<int>& index_return);
 
  void copyMsg(TQPtrList<KMMessage>& msgList/*, KMFolder* parent*/);
 
 
  virtual KMMessage* take(int idx);
  virtual void take(TQPtrList<KMMessage>);
 
  void slotSimpleData(TDEIO::Job * job, const TQByteArray & data);
 
  static void flagsToStatus(KMMsgBase *msg, int flags, bool newMsg = TRUE, int supportedFalgs = 31 );
 
  static void seenFlagToStatus( KMMsgBase *msg, int flags, bool newMsg = true );
 
  void slotCopyMsgResult( KMail::FolderJob* job );
 
  void slotSearchDone( TQValueList<TQ_UINT32> serNums,
                       const KMSearchPattern* pattern,
                       bool complete );
 
  void slotSearchDone( TQ_UINT32 serNum, const KMSearchPattern* pattern, bool matches );
 
  void slotListResult( const TQStringList&, const TQStringList&,
      const TQStringList&, const TQStringList&, const ImapAccountBase::jobData& );
 
  void slotCheckNamespace( const TQStringList&, const TQStringList&,
      const TQStringList&, const TQStringList&, const ImapAccountBase::jobData& );
 
protected:
  virtual FolderJob* doCreateJob( KMMessage *msg, FolderJob::JobType jt,
                                  KMFolder *folder, TQString partSpecifier,
                                  const AttachmentStrategy *as ) const;
  virtual FolderJob* doCreateJob( TQPtrList<KMMessage>& msgList, const TQString& sets,
                                  FolderJob::JobType jt, KMFolder *folder ) const;
 
  void getMessagesResult(TDEIO::Job * job, bool lastSet);
 
  virtual int expungeContents();
 
  void setChildrenState( TQString attributes );
 
  void initInbox();
 
  KMFolderImap* findParent( const TQString& path, const TQString& name );
 
  void checkFolders( const TQStringList& folderNames, const TQString& ns );
 
  void finishMailCheck( const char *func, imapState state );
 
protected slots:
 
  void checkValidity();
  void slotCheckValidityResult(TDEIO::Job * job);
 
  void reallyGetFolder(const TQString &startUid = TQString());
 
  void slotListFolderResult(TDEIO::Job * job);
  void slotListFolderEntries(TDEIO::Job * job, const TDEIO::UDSEntryList & uds);
 
  void slotGetMessagesResult(TDEIO::Job * job);
  void slotGetLastMessagesResult(TDEIO::Job * job);
  void slotGetMessagesData(TDEIO::Job * job, const TQByteArray & data);
 
  void slotCreateFolderResult(TDEIO::Job * job);
 
  void slotRemoveFolderResult(TDEIO::Job *job);
 
  void slotStatResult(TDEIO::Job *job);
 
  void slotCompleteMailCheckProgress();
 
  void slotProcessNewMail( int errorCode, const TQString& errorMsg );
 
  void slotCreatePendingFolders( int errorCode, const TQString& errorMsg );
 
  void slotListNamespaces();
 
protected:
  TQString     mImapPath;
  ulong       mLastUid;
  imapState   mContentState, mSubfolderState;
  bool        mIsSelected;
  bool        mCheckFlags;
  bool        mReadOnly;
  bool        mCheckMail;
  mutable TQGuardedPtr<KMAcctImap> mAccount;
  // the current uidvalidity
  TQString mUidValidity;
  unsigned int mUserRights;
  KMail::ACLJobs::ACLFetchState mUserRightsState;
 
private:
  // if we're checking validity currently
  bool        mCheckingValidity;
  // uid - metadata cache
  TQIntDict<KMMsgMetaData> mUidMetaDataMap;
  // msgidMD5 - status map
  TQDict<KMMsgMetaData> mMetaDataMap;
  // if the folder should be deleted without server roundtrip
  bool        mAlreadyRemoved;
  // the progress for mailchecks
  TQGuardedPtr<ProgressItem> mMailCheckProgressItem;
  // the progress for listings
  ProgressItem *mListDirProgressItem;
  // the progress for addMsg
  ProgressItem *mAddMessageProgressItem;
  // to-be-added folders
  TQStringList 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