kmfoldercachedimap.h

/*
 *  kmfoldercachedimap.cpp
 *
 *  Copyright (c) 2002-2004 Bo Thorsen <bo@sonofthor.dk>
 *  Copyright (c) 2002-2003 Steffen Hansen <steffen@klaralvdalens-datakonsult.se>
 *
 *  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.
 *
 *  In addition, as a special exception, the copyright holders give
 *  permission to link the code of this program with any edition of
 *  the TQt library by Trolltech AS, Norway (or with modified versions
 *  of TQt that use the same license as TQt), and distribute linked
 *  combinations including the two.  You must obey the GNU General
 *  Public License in all respects for all of the code used other than
 *  TQt.  If you modify this file, you may extend this exception to
 *  your version of the file, but you are not obligated to do so.  If
 *  you do not wish to do so, delete this exception statement from
 *  your version.
 */
 
#ifndef kmfoldercachedimap_h
#define kmfoldercachedimap_h
 
#include <kdialogbase.h>
#include <kstandarddirs.h>
#include <tqvaluelist.h>
#include <tqvaluevector.h>
#include <tqptrlist.h>
#include <tqdialog.h>
 
#include "kmfoldermaildir.h"
#include "kmfolderimap.h"
#include "kmacctcachedimap.h"
#include "kmfoldertype.h"
#include "folderjob.h"
#include "cachedimapjob.h"
#include "quotajobs.h"
 
#include <set>
 
using KMail::FolderJob;
using KMail::QuotaInfo;
class KMCommand;
 
class TQComboBox;
class TQRadioButton;
 
namespace KMail {
  class AttachmentStrategy;
  class ImapAccountBase;
  struct ACLListEntry;
}
using KMail::AttachmentStrategy;
 
class DImapTroubleShootDialog : public KDialogBase
{
  TQ_OBJECT
  
public:
  enum SelectedOperation {
    None = -1,
    ReindexCurrent = 0,
    ReindexRecursive = 1,
    ReindexAll = 2,
    RefreshCache
  };
 
  DImapTroubleShootDialog( TQWidget* parent=0, const char* name=0 );
 
  static int run();
 
private slots:
  void slotDone();
  void slotChanged();
private:
  TQRadioButton *mIndexButton, *mCacheButton;
  TQComboBox *mIndexScope;
  TQButtonGroup *mButtonGroup;
  int rc;
};
 
class KMFolderCachedImap : public KMFolderMaildir
{
  TQ_OBJECT
  
 
public:
  static TQString cacheLocation() {
     return locateLocal("data", "kmail/dimap" );
  }

  KMFolderCachedImap(KMFolder* folder, const char* name=0);
  virtual ~KMFolderCachedImap();

  void reallyDoClose(const char* owner);

  void initializeFrom( KMFolderCachedImap* parent );
 
  virtual void readConfig();
  virtual void writeConfig();
 
  void writeConfigKeysWhichShouldNotGetOverwrittenByReadConfig();

  virtual KMFolderType folderType() const { return KMFolderTypeCachedImap; }

  virtual int create();

  virtual void remove();

  virtual void serverSync( bool recurse, bool quotaOnly = false );

  void resetSyncState( );

  void setAlarmsBlocked( bool blocked );
  bool alarmsBlocked() const;
 
  void checkUidValidity();
 
  enum imapState { imapNoInformation=0, imapInProgress=1, imapFinished=2 };
 
  virtual imapState getContentState() const { return mContentState; }
  virtual void setContentState(imapState state) { mContentState = state; }
 
  virtual imapState getSubfolderState() { return mSubfolderState; }
  virtual void setSubfolderState(imapState state);

  void setImapPath(const TQString &path);
  TQString imapPath() const { return mImapPath; }

  void setLastUid( ulong uid );
  ulong lastUid();

  KMMsgBase* findByUID( ulong uid );

  void setUidValidity(const TQString &validity) { mUidValidity = validity; }
  TQString uidValidity() const { return mUidValidity; }

  void clearUidMap() { uidMap.clear(); }

  void setAccount(KMAcctCachedImap *acct);
  KMAcctCachedImap* account() const;

  TQString uidCacheLocation() const;

  int readUidCache();

  int writeUidCache();

  int progress() const { return mProgress; }
 
  /* Reimplemented from KMFolder. Moving is not supported, so aParent must be 0 */
  virtual int rename(const TQString& aName, KMFolderDir *aParent=0);

  virtual KMMessage* take(int idx);

  void takeTemporarily( int idx );
 
  /* Reimplemented from KMFolderMaildir */
  virtual int addMsg(KMMessage* msg, int* index_return = 0);
  /* internal version that doesn't remove the X-UID header */
  virtual int addMsgInternal(KMMessage* msg, bool, int* index_return = 0);
  virtual int addMsgKeepUID(KMMessage* msg, int* index_return = 0) {
    return addMsgInternal(msg, false, index_return);
  }
 
  /* Reimplemented from KMFolderMaildir */
  virtual void removeMsg(int i, bool imapQuiet = false);
  virtual void removeMsg( const TQPtrList<KMMsgBase> & msgList, bool imapQuiet = false)
    { FolderStorage::removeMsg(msgList, imapQuiet); }

  bool isReadOnly() const { return KMFolderMaildir::isReadOnly() || mReadOnly; }
  bool canDeleteMessages() const;
 

  void sendFolderComplete(bool success)
  { emit folderComplete(this, success); }

  void setSilentUpload( bool silent ) { mSilentUpload = silent; }
  bool silentUpload() { return mSilentUpload; }
 
  virtual int createIndexFromContents() {
    const int result = KMFolderMaildir::createIndexFromContents();
    reloadUidMap();
    return result;
  }
 
  int createIndexFromContentsRecursive();
 
  //virtual void holdSyncs( bool hold ) { mHoldSyncs = hold; }

  virtual bool listDirectory();
 
  virtual void listNamespaces();

  KMFolder* trashFolder() const;

  int userRights() const { return mUserRights; }
  KMail::ACLJobs::ACLFetchState userRightsState() const { return mUserRightsState; }

  void setUserRights( unsigned int userRights, KMail::ACLJobs::ACLFetchState state  );

  const QuotaInfo quotaInfo() const { return mQuotaInfo; }
  void setQuotaInfo( const QuotaInfo & );

  typedef TQValueVector<KMail::ACLListEntry> ACLList;
  const ACLList& aclList() const { return mACLList; }
  KMail::ACLJobs::ACLFetchState aclListState() const { return mACLListState; };

  void setACLList( const ACLList& arr );
 
  // Reimplemented so the mStatusChangedLocally bool can be set
  virtual void setStatus( int id, KMMsgStatus status, bool toggle );
  virtual void setStatus( TQValueList<int>& ids, KMMsgStatus status, bool toggle );
 
  TQString annotationFolderType() const { return mAnnotationFolderType; }
 
  // For kmailicalifaceimpl only
  void updateAnnotationFolderType();

  enum IncidencesFor { IncForNobody, IncForAdmins, IncForReaders };
 
  IncidencesFor incidencesFor() const { return mIncidencesFor; }
  void setIncidencesFor( IncidencesFor incfor );

  bool sharedSeenFlags() const { return mSharedSeenFlags; }
  void setSharedSeenFlags( bool b );

  virtual bool isMoveable() const;

  TQStringList namespacesToList() { return mNamespacesToList; }
  void setNamespacesToList( TQStringList list ) { mNamespacesToList = list; }

  const TQString& imapPathForCreation() { return mImapPathCreation; }
  void setImapPathForCreation( const TQString& path ) { mImapPathCreation = path; }

  bool isCloseToQuota() const;

  int permanentFlags() const { return mPermanentFlags; }
 
 
  TQString folderAttributes() const { return mFolderAttributes; }
 
  virtual bool mailCheckInProgress() const;
 
protected slots:
  void slotGetMessagesData(TDEIO::Job * job, const TQByteArray & data);
  void getMessagesResult(KMail::FolderJob *, bool lastSet);
  void slotGetLastMessagesResult(KMail::FolderJob *);
  void slotProgress(unsigned long done, unsigned long total);
  void slotPutProgress( unsigned long, unsigned long );
 
  //virtual void slotCheckValidityResult(TDEIO::Job * job);
  void slotSubFolderComplete(KMFolderCachedImap*, bool);
  void slotSubFolderCloseToQuotaChanged();
 
  // Connected to the imap account
  void slotConnectionResult( int errorCode, const TQString& errorMsg );
 
  void slotCheckUidValidityResult( KMail::FolderJob* job );
  void slotPermanentFlags( int flags );
  void slotTestAnnotationResult(TDEIO::Job *job);
  void slotGetAnnotationResult( TDEIO::Job* );
  void slotMultiUrlGetAnnotationResult( TDEIO::Job* );
  void slotSetAnnotationResult(TDEIO::Job *job);
  void slotReceivedUserRights( KMFolder* );
  void slotReceivedACL( KMFolder*, TDEIO::Job*, const KMail::ACLList& );
 
  void slotMultiSetACLResult(TDEIO::Job *);
  void slotACLChanged( const TQString&, int );
  void slotAnnotationResult(const TQString& entry, const TQString& value, bool found);
  void slotAnnotationChanged( const TQString& entry, const TQString& attribute, const TQString& value );
  void slotDeleteMessagesResult(KMail::FolderJob *);
  void slotImapStatusChanged(KMFolder* folder, const TQString&, bool);
  void slotStorageQuotaResult( const QuotaInfo& );
  void slotQuotaResult( TDEIO::Job* job );
 
protected:
  /* returns true if there were messages to delete
     on the server */
  bool deleteMessages();
  void listMessages();
  void uploadNewMessages();
  void uploadFlags();
  void uploadSeenFlags();
  void createNewFolders();
 
  void listDirectory2();
  void createFoldersNewOnServerAndFinishListing( const TQValueVector<int> foldersNewOnServer );
 

  virtual TQValueList<unsigned long> findNewMessages();
  virtual TQValueList<KMFolderCachedImap*> findNewFolders();

  virtual bool canRemoveFolder() const;

  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;
 
  virtual void timerEvent( TQTimerEvent* );
 
  /* update progress status */
  void newState( int progress, const TQString& syncStatus );

  KMFolderCachedImap* findParent( const TQString& path, const TQString& name );
 
 
 
public slots:
  void slotSimpleData(TDEIO::Job * job, const TQByteArray & data);

  void slotTroubleshoot();

  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& );
 
private slots:
  void serverSyncInternal();
  void slotIncreaseProgress();
  void slotUpdateLastUid();
  void slotFolderDeletionOnServerFinished();
  void slotRescueDone( KMCommand* command );
  void slotRenameFolderFinished();
 
signals:
  void folderComplete(KMFolderCachedImap *folder, bool success);
  void listComplete( KMFolderCachedImap* );

  void closeToQuotaChanged();
 
private:
  void setReadOnly( bool readOnly );
  TQString state2String( int state ) const;
  void rememberDeletion( int );
  KMCommand* rescueUnsyncedMessages();
  void rescueUnsyncedMessagesAndDeleteFolder( KMFolder *folder, bool root = true );

  void disconnectSubFolderSignals();

  void syncNextSubFolder( bool secondSync );

  void buildSubFolderList();

  enum {
    SYNC_STATE_INITIAL,
    SYNC_STATE_TEST_ANNOTATIONS,
    SYNC_STATE_PUT_MESSAGES,
    SYNC_STATE_UPLOAD_FLAGS,
    SYNC_STATE_CREATE_SUBFOLDERS,
    SYNC_STATE_LIST_NAMESPACES,
    SYNC_STATE_LIST_SUBFOLDERS,
    SYNC_STATE_LIST_SUBFOLDERS2,
    SYNC_STATE_DELETE_SUBFOLDERS,
    SYNC_STATE_LIST_MESSAGES,
    SYNC_STATE_DELETE_MESSAGES,
    SYNC_STATE_EXPUNGE_MESSAGES,
    SYNC_STATE_GET_MESSAGES,
    SYNC_STATE_HANDLE_INBOX,
    SYNC_STATE_GET_USERRIGHTS,
    SYNC_STATE_GET_ANNOTATIONS,
    SYNC_STATE_SET_ANNOTATIONS,
    SYNC_STATE_GET_ACLS,
    SYNC_STATE_SET_ACLS,
    SYNC_STATE_GET_QUOTA,
    SYNC_STATE_FIND_SUBFOLDERS,
    SYNC_STATE_SYNC_SUBFOLDERS,
    SYNC_STATE_CHECK_UIDVALIDITY,
    SYNC_STATE_RENAME_FOLDER,
    SYNC_STATE_CLOSE,
    SYNC_STATE_GET_SUBFOLDER_QUOTA
  } mSyncState;
 
  int mProgress;
  int mStatusFlagsJobs;
 
  TQString mUidValidity;
  TQString     mImapPath;
  imapState   mContentState, mSubfolderState;
  TQStringList mSubfolderNames, mSubfolderPaths,
              mSubfolderMimeTypes, mSubfolderAttributes;
  TQString     mFolderAttributes;
  TQString     mAnnotationFolderType;
  IncidencesFor mIncidencesFor;
  bool mSharedSeenFlags;
 
  bool        mHasInbox;
  bool        mIsSelected;
  bool        mCheckFlags;
  bool        mReadOnly;
  mutable TQGuardedPtr<KMAcctCachedImap> mAccount;
 
  TQIntDict<int> uidsOnServer;
  TQValueList<ulong> uidsForDeletionOnServer;
  TQValueList<KMail::CachedImapJob::MsgForDownload> mMsgsForDownload;
  TQValueList<ulong> mUidsForDownload;
  TQStringList       foldersForDeletionOnServer;
 
  TQValueList< TQGuardedPtr<KMFolderCachedImap> > mSubfoldersForSync;
  KMFolderCachedImap* mCurrentSubfolder;

  TQMap<ulong,int> uidMap;
  bool uidMapDirty;
  void reloadUidMap();
  int uidWriteTimer;

  ulong mLastUid;
  ulong mTentativeHighestUid;

  bool mFoundAnIMAPDigest;
 
  int mUserRights, mOldUserRights;
  KMail::ACLJobs::ACLFetchState mUserRightsState;
  ACLList mACLList;
  KMail::ACLJobs::ACLFetchState mACLListState;
 
  bool mSilentUpload;
  bool mFolderRemoved;
  //bool mHoldSyncs;
  bool mRecurse;
  bool mQuotaOnly;

  bool mAnnotationFolderTypeChanged;
  bool mIncidencesForChanged;
  bool mSharedSeenFlagsChanged;

  std::set<ulong> mUIDsOfLocallyChangedStatuses;

  bool mStatusChangedLocally;
 
  TQStringList mNamespacesToList;
  int mNamespacesToCheck;
  bool mPersonalNamespacesCheckDone;
  TQString mImapPathCreation;
 
  QuotaInfo mQuotaInfo;

  bool mSomeSubFolderCloseToQuotaChanged;
 
  TQMap<ulong,void*> mDeletedUIDsSinceLastSync;
  bool mAlarmsBlocked;
 
  TQValueList<KMFolder*> mToBeDeletedAfterRescue;
  int mRescueCommandCount;
 
  TQValueList< TQGuardedPtr<KMFolderCachedImap> > mNewlyCreatedSubfolders;
  int mPermanentFlags;
};
 
#endif /*kmfoldercachedimap_h*/