folderstorage.h

/*
    Virtual base class for mail storage.
 
    This file is part of KMail.
 
    Copyright (c) 2004 Bo Thorsen <bo@sonofthor.dk>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library 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
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  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 FOLDERSTORAGE_H
#define FOLDERSTORAGE_H
 
// for large file support
#include <config.h>
 
#include "kmfoldernode.h"
#include "kmfoldertype.h"
#include "kmmsginfo.h"
#include "kmglobal.h"
#include "folderjob.h"
using KMail::FolderJob;
 
#include "mimelib/string.h"
 
#include <sys/types.h>
#include <stdio.h>
 
class KMMessage;
class KMAccount;
class KMFolderDir;
class KMMsgDict; // for the rDict manipulations
class KMMsgDictREntry;
class TQTimer;
class KMSearchPattern;
 
namespace KMail {
   class AttachmentStrategy;
}
using KMail::AttachmentStrategy;
 
typedef TQValueList<TQ_UINT32> SerNumList;
 
class FolderStorage : public TQObject
{
  TQ_OBJECT
  
 
public:
 
 
  FolderStorage( KMFolder* folder, const char* name=0 );
  virtual ~FolderStorage();
 
  KMFolder* folder() const { return mFolder; }
 
  virtual KMFolderType folderType() const { return KMFolderTypeUnknown; }
 
  virtual TQString fileName() const;
  TQString location() const;
 
  virtual TQString indexLocation() const = 0;
 
  virtual bool noContent() const { return mNoContent; }
 
  virtual void setNoContent(bool aNoContent);
 
  virtual bool noChildren() const { return mNoChildren; }
 
  virtual void setNoChildren( bool aNoChildren );
 
  enum ChildrenState {
    HasChildren,
    HasNoChildren,
    ChildrenUnknown
  };
  virtual ChildrenState hasChildren() const { return mHasChildren; }
 
  virtual void setHasChildren( ChildrenState state )
    { mHasChildren = state; }
 
  virtual void updateChildrenState();
 
  virtual KMMessage* getMsg(int idx);
 
  virtual KMMsgInfo* unGetMsg(int idx);
 
  virtual bool isMessage(int idx);
 
  virtual KMMessage* readTemporaryMsg(int idx);
 
  virtual DwString getDwString(int idx) = 0;
 
  virtual void ignoreJobsForMessage( KMMessage* );
 
  virtual FolderJob* createJob( KMMessage *msg, FolderJob::JobType jt = FolderJob::tGetMessage,
                                KMFolder *folder = 0, TQString partSpecifier = TQString(),
                                const AttachmentStrategy *as = 0 ) const;
  virtual FolderJob* createJob( TQPtrList<KMMessage>& msgList, const TQString& sets,
                                FolderJob::JobType jt = FolderJob::tGetMessage,
                                KMFolder *folder = 0 ) const;
 
  virtual const KMMsgBase* getMsgBase(int idx) const = 0;
  virtual KMMsgBase* getMsgBase(int idx) = 0;
 
  virtual const KMMsgBase* operator[](int idx) const { return getMsgBase(idx); }
 
  virtual KMMsgBase* operator[](int idx) { return getMsgBase(idx); }
 
  virtual KMMessage* take(int idx);
  virtual void take(TQPtrList<KMMessage> msgList);
 
  virtual int addMsg(KMMessage* msg, int* index_return = 0) = 0;
 
  virtual int addMsgKeepUID(KMMessage* msg, int* index_return = 0) {
    return addMsg(msg, index_return);
  }
 
  virtual int addMsg( TQPtrList<KMMessage>&, TQValueList<int>& index_return );
 
  void emitMsgAddedSignals(int idx);
 
  virtual bool canAddMsgNow(KMMessage* aMsg, int* aIndex_ret);
 
  virtual void removeMsg(int i, bool imapQuiet = false);
  virtual void removeMsg(const TQPtrList<KMMsgBase>& msgList, bool imapQuiet = false);
  virtual void removeMsg(const TQPtrList<KMMessage>& msgList, bool imapQuiet = false);
 
  virtual int expungeOldMsg(int days);
 
  virtual int moveMsg(KMMessage* msg, int* index_return = 0);
  virtual int moveMsg(TQPtrList<KMMessage>, int* index_return = 0);
 
  virtual int find(const KMMsgBase* msg) const = 0;
  int find( const KMMessage * msg ) const;
 
  virtual int count(bool cache = false) const;
 
  virtual int countUnread();
 
  TQ_INT64 folderSize() const;
 
  virtual bool isCloseToQuota() const;
 
  virtual void msgStatusChanged( const KMMsgStatus oldStatus,
                                 const KMMsgStatus newStatus,
                 int idx);
 
  virtual int open(const char* owner) = 0;
 
  virtual int canAccess() = 0;
 
  void close(const char* owner, bool force=false);
  virtual void reallyDoClose(const char* owner) = 0;
 
  virtual void tryReleasingFolder(KMFolder*) {}
 
  virtual void sync() = 0;
 
  bool isOpened() const { return (mOpenCount>0); }
 
  virtual void markNewAsUnread();
 
  virtual void markUnreadAsRead();
 
  virtual int create() = 0;
 
  virtual void remove();
 
  virtual int expunge();
 
  virtual int compact( bool silent ) = 0;
 
  virtual int rename(const TQString& newName, KMFolderDir *aParent = 0);
 
  bool autoCreateIndex() const { return mAutoCreateIndex; }
 
  virtual void setAutoCreateIndex(bool);
 
  bool dirty() const { return mDirty; }
 
  void setDirty(bool f);
 
  bool needsCompacting() const { return needsCompact; }
  virtual void setNeedsCompacting(bool f) { needsCompact = f; }
 
  virtual void quiet(bool beQuiet);
 
  virtual bool isReadOnly() const = 0;
 
  virtual bool canDeleteMessages() const;
 
  TQString label() const;
 
  virtual void correctUnreadMsgsCount();
 
  virtual int writeIndex( bool createEmptyIndex = false ) = 0;
 
  void registerWithMessageDict();
 
  void deregisterFromMessageDict();
 
  virtual void setStatus(int idx, KMMsgStatus status, bool toggle=false);
 
  virtual void setStatus(TQValueList<int>& ids, KMMsgStatus status, bool toggle=false);
 
  void removeJobs();
 
  static TQString dotEscape(const TQString&);
 
  virtual void readConfig();
 
  virtual void writeConfig();
 
  virtual KMFolder* trashFolder() const { return 0; }
 
  void addJob( FolderJob* ) const;
 
  bool compactable() const { return mCompactable; }
 
  // If quiet is true, the KMailIcalIface is not informed of the changed. That's usefull
  // for folder that are being copied around, should retain their type, but not cause
  // conflicts on copy because events are identical in two folders.
  virtual void setContentsType( KMail::FolderContentsType type, bool quiet = false );
  KMail::FolderContentsType contentsType() const { return mContentsType; }
 
  virtual void search( const KMSearchPattern* );
 
  virtual void search( const KMSearchPattern*, TQ_UINT32 serNum );
 
  virtual bool isMoveable() const;
 
  virtual KMAccount* account() const;
 
  virtual bool mailCheckInProgress() const;
 
signals:
  void changed();
 
  void cleared();
 
  void expunged( KMFolder* );
 
  void closed( KMFolder* );
 
  void invalidated( KMFolder * );
 
  void nameChanged();
 
  void locationChanged( const TQString &, const TQString & );
 
  void contentsTypeChanged( KMail::FolderContentsType type );
 
  void readOnlyChanged(KMFolder*);
 
  void noContentChanged();
 
  void msgRemoved(KMFolder*, TQ_UINT32 sernum);
 
  void msgRemoved( int idx, TQString msgIdMD5 );
  void msgRemoved( KMFolder* );
 
  void msgAdded(int idx);
  void msgAdded(KMFolder*, TQ_UINT32 sernum);
 
  void msgChanged(KMFolder*, TQ_UINT32 sernum, int delta);
 
  void msgHeaderChanged(KMFolder*, int);
 
  void statusMsg(const TQString&);
 
  void numUnreadMsgsChanged( KMFolder* );
 
  void removed(KMFolder*, bool);
 
  void searchResult( KMFolder*, TQValueList<TQ_UINT32>,
                     const KMSearchPattern*, bool complete );
 
  void searchDone( KMFolder*, TQ_UINT32, const KMSearchPattern*, bool );
 
  void folderSizeChanged();
 
  void syncStateChanged();
 
public slots:
  virtual int updateIndex() = 0;
 
  virtual void reallyAddMsg(KMMessage* aMsg);
 
  virtual void reallyAddCopyOfMsg(KMMessage* aMsg);
 
  void slotEmitChangedTimer();
 
protected slots:
  virtual void removeJob( TQObject* );
 
  void slotProcessNextSearchBatch();
 
protected:
 
  virtual FolderJob* doCreateJob( KMMessage *msg, FolderJob::JobType jt, KMFolder *folder,
                                  TQString partSpecifier, const AttachmentStrategy *as ) const = 0;
  virtual FolderJob* doCreateJob( TQPtrList<KMMessage>& msgList, const TQString& sets,
                                  FolderJob::JobType jt, KMFolder *folder ) const = 0;
 
  void headerOfMsgChanged(const KMMsgBase*, int idx);
 
  virtual KMMessage* readMsg(int idx) = 0;
 
  //--------- Message Dict manipulation
friend class KMMsgDict;
  virtual void fillMessageDict() {}
 
  void readFolderIdsFile();
 
  int writeFolderIdsFile() const;
 
  int touchFolderIdsFile();
 
  int appendToFolderIdsFile( int idx = -1 );
 
  void setRDict(KMMsgDictREntry *rentry) const;
 
  KMMsgDictREntry *rDict() const { return mRDict; }
 
 
  void replaceMsgSerNum( unsigned long sernum, KMMsgBase* msg, int idx );
 
  void invalidateFolder();
 
  virtual int removeContents() = 0;
 
  virtual int expungeContents() = 0;
 
  virtual bool readIndex() = 0;
  virtual KMMsgBase* takeIndexEntry( int idx ) = 0;
  virtual KMMsgInfo* setIndexEntry( int idx, KMMessage *msg ) = 0;
  virtual void clearIndex(bool autoDelete=true, bool syncDict = false) = 0;
  virtual void truncateIndex() = 0;
 
  virtual TQ_INT64 doFolderSize() const { return 0; };
 
  int mOpenCount;
  int mQuiet;
  bool mChanged :1;
  bool mAutoCreateIndex :1;
  bool mExportsSernums :1;
  bool mDirty :1;
  bool mFilesLocked :1;
 
  int mUnreadMsgs, mGuessedUnreadMsgs;
  int mTotalMsgs;
  TQ_INT64 mSize;
  bool mWriteConfigEnabled :1;
  bool needsCompact :1;
  bool mCompactable :1;
  bool mNoContent :1;
  bool mNoChildren :1;
  bool mConvertToUtf8 :1;
 
  mutable KMMsgDictREntry *mRDict;
  mutable TQPtrList<FolderJob> mJobList;
 
  TQTimer *mDirtyTimer;
  enum { mDirtyTimerInterval = 600000 }; // 10 minutes
 
  ChildrenState mHasChildren;
 
  KMail::FolderContentsType mContentsType;
 
  KMFolder* mFolder;
 
  TQTimer * mEmitChangedTimer;
 
  int mCurrentSearchedMsg;
  const KMSearchPattern* mSearchPattern;
};
 
#endif // FOLDERSTORAGE_H