imapaccountbase.h

/*
 * imapaccountbase.h
 *
 * Copyright (c) 2000-2002 Michael Haeckel <haeckel@kde.org>
 * Copyright (c) 2002 Marc Mutz <mutz@kde.org>
 *
 * This file is based on work on pop3 and imap account implementations
 * by Don Sanders <sanders@kde.org> and Michael Haeckel <haeckel@kde.org>
 *
 *  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 __KMAIL_IMAPACCOUNTBASE_H__
#define __KMAIL_IMAPACCOUNTBASE_H__
 
#include <set>
 
#include "networkaccount.h"
 
#include <tqtimer.h>
#include <tqguardedptr.h>
#include <tdeio/global.h>
 
namespace KMail {
    class AccountManager;
}
class KMFolder;
class TDEConfig/*Base*/;
class KMMessagePart;
class DwBodyPart;
class DwMessage;
class FolderStorage;
template <typename T> class TQValueVector;
 
namespace TDEIO {
  class Job;
}
 
namespace KPIM {
  class ProgressItem;
}
 
namespace KMail {
  struct ACLListEntry;
  struct QuotaInfo;
  typedef TQValueVector<KMail::ACLListEntry> ACLList;
 
  class AttachmentStrategy;
 
  class ImapAccountBase : public KMail::NetworkAccount {
    TQ_OBJECT
  
  protected:
    ImapAccountBase( AccountManager * parent, const TQString & name, uint id );
  public:
    virtual ~ImapAccountBase();
 
    virtual void init();
 
    virtual void pseudoAssign( const KMAccount * a );
 
    bool autoExpunge() const { return mAutoExpunge; }
    virtual void setAutoExpunge( bool expunge );
 
    bool hiddenFolders() const { return mHiddenFolders; }
    virtual void setHiddenFolders( bool show );
 
    bool onlySubscribedFolders() const { return mOnlySubscribedFolders; }
    virtual void setOnlySubscribedFolders( bool show );
 
    bool onlyLocallySubscribedFolders() const { return mOnlyLocallySubscribedFolders; }
    virtual void setOnlyLocallySubscribedFolders( bool show );
 
 
    bool loadOnDemand() const { return mLoadOnDemand; }
    virtual void setLoadOnDemand( bool load );
 
    bool listOnlyOpenFolders() const { return mListOnlyOpenFolders; }
    virtual void setListOnlyOpenFolders( bool only );
 
    virtual TDEIO::MetaData slaveConfig() const;
 
    virtual void readConfig( TDEConfig& config );
    virtual void writeConfig( TDEConfig& config );
 
    enum ConnectionState { Error = 0, Connected, Connecting };
 
    // possible list types
    enum ListType {
      List,
      ListSubscribed,
      ListSubscribedNoCheck,
      ListFolderOnly,
      ListFolderOnlySubscribed
    };
 
    ConnectionState makeConnection();
 
    // namespace defines
    enum imapNamespace { PersonalNS=0, OtherUsersNS=1, SharedNS=2 };
 
    // map a namespace type to a list of namespaces
    typedef TQMap<imapNamespace, TQStringList> nsMap;
 
    // map a namespace to a delimiter
    typedef TQMap<TQString, TQString> namespaceDelim;
 
    // map a namespace type to a map with the namespace and the delimiter
    typedef TQMap<imapNamespace, namespaceDelim> nsDelimMap;
 
    struct jobData
    {
      // Needed by TQMap, don't use
      jobData() : url(TQString()), parent(0), current(0), total(1), done(0), offset(0), progressItem(0),
                  onlySubscribed(false), quiet(false), cancellable(false) {}
      // Real constructor
      jobData( const TQString& _url, KMFolder *_parent = 0,
          int _total = 1, int _done = 0, bool _quiet = false,
          bool _cancelable = false )
        : url(_url), parent(_parent), current(0), total(_total), done(_done), offset(0),
          progressItem(0), quiet(_quiet), cancellable(_cancelable) {}
 
      TQString path;
      TQString url;
      TQString curNamespace;
      TQByteArray data;
      TQCString cdata;
      TQStringList items;
      KMFolder *parent, *current;
      TQPtrList<KMMessage> msgList;
      int total, done, offset;
      KPIM::ProgressItem *progressItem;
      bool onlySubscribed, quiet, cancellable;
    };
 
    typedef TQMap<TDEIO::Job *, jobData>::Iterator JobIterator;
    void insertJob( TDEIO::Job* job, const jobData& data ) {
      mapJobData.insert( job, data );
    }
    JobIterator findJob( TDEIO::Job* job ) { return mapJobData.find( job ); }
    JobIterator jobsEnd() { return mapJobData.end(); }
    void removeJob( JobIterator& it );
 
    void removeJob( TDEIO::Job* job );
 
    void changeSubscription(bool subscribe, const TQString& imapPath, bool quiet = false );
 
    bool locallySubscribedTo( const TQString& imapPath );
 
    void changeLocalSubscription( const TQString& imapPath, bool subscribe );
 
 
    void getUserRights( KMFolder* folder, const TQString& imapPath );
 
    void getACL( KMFolder* folder, const TQString& imapPath );
 
    void getStorageQuotaInfo( KMFolder* folder, const TQString& imapPath );
 
    void setImapStatus( KMFolder* folder, const TQString& path, const TQCString& flags );
 
    void setImapSeenStatus( KMFolder* folder, const TQString& path, bool seen );
 
    void slaveDied() { mSlave = 0; killAllJobs(); }
 
    void killAllJobs( bool disconnectSlave=false ) = 0;
 
    virtual void cancelMailCheck();
 
    enum FolderListType { Single, Recursive };
    void processNewMailInFolder( KMFolder* folder, FolderListType type = Single );
 
    bool checkingSingleFolder() { return mCheckingSingleFolder; }
 
    void postProcessNewMail( bool setStatusMsg = true );
 
    bool checkingMail( KMFolder *folder );
 
    bool checkingMail() { return NetworkAccount::checkingMail(); }
 
    void handleBodyStructure( TQDataStream & stream, KMMessage * msg,
                              const AttachmentStrategy *as );
 
    virtual void setFolder(KMFolder*, bool addAccount = false);
 
    bool hasACLSupport() const { return mACLSupport; }
 
    bool hasAnnotationSupport() const { return mAnnotationSupport; }
 
    void setHasNoAnnotationSupport() { mAnnotationSupport = false; }
 
    bool hasQuotaSupport() const { return mQuotaSupport; }
 
    void setHasNoQuotaSupport() { mQuotaSupport = false; }
 
    bool handleJobError( TDEIO::Job* job, const TQString& context, bool abortSync = false );
 
    virtual FolderStorage* rootFolder() const = 0;
 
    KPIM::ProgressItem* listDirProgressItem();
 
    virtual unsigned int folderCount() const;
 
    nsMap namespaces() const { return mNamespaces; }
 
    virtual void setNamespaces( nsMap map )
    { mNamespaces = map; }
 
    nsDelimMap namespacesWithDelimiter();
 
     TQString namespaceForFolder( FolderStorage* );
 
     TQString addPathToNamespace( const TQString& ns );
 
     TQString delimiterForNamespace( const TQString& prefix );
 
     TQString delimiterForFolder( FolderStorage* );
 
     namespaceDelim namespaceToDelimiter() const
     { return mNamespaceToDelimiter; }
 
     void setNamespaceToDelimiter( namespaceDelim map )
     { mNamespaceToDelimiter = map; }
 
     bool isNamespaceFolder( TQString& name );
 
     bool hasCapability( const TQString& capa ) {
      return mCapabilities.contains( capa ); }
 
     TQString createImapPath( FolderStorage* parent, const TQString& folderName );
 
     TQString createImapPath( const TQString& parent, const TQString& folderName );
 
 
  public slots:
    void getNamespaces();
 
  private slots:
    void slotSubscriptionResult(TDEIO::Job * job);
 
  protected slots:
    virtual void slotCheckQueuedFolders();
 
    void slotSchedulerSlaveConnected(TDEIO::Slave *aSlave);
    void slotSchedulerSlaveError(TDEIO::Slave *aSlave, int, const TQString &errorMsg);
 
    void slotSetStatusResult(TDEIO::Job * job);
 
    void slotGetUserRightsResult( TDEIO::Job* _job );
 
    void slotGetACLResult( TDEIO::Job* _job );
 
    void slotGetStorageQuotaInfoResult( TDEIO::Job* _job );
 
    void slotNoopTimeout();
    void slotIdleTimeout();
 
    void slotAbortRequested( KPIM::ProgressItem* );
 
    void slotSimpleResult(TDEIO::Job * job);
 
    void slotNamespaceResult( TDEIO::Job*, const TQString& str );
 
    void slotSaveNamespaces( const ImapAccountBase::nsDelimMap& map );
 
    void slotCapabilitiesResult( TDEIO::Job*, const TQString& result );
 
  protected:
 
    virtual bool handleError( int error, const TQString &errorMsg, TDEIO::Job* job, const TQString& context, bool abortSync = false );
 
    bool handlePutError( TDEIO::Job* job, jobData& jd, KMFolder* folder );
 
    virtual TQString protocol() const;
    virtual unsigned short int defaultPort() const;
 
    void constructParts( TQDataStream & stream, int count, KMMessagePart* parentKMPart,
       DwBodyPart * parent, const DwMessage * dwmsg );
 
    void migratePrefix();
 
    // used for writing the blacklist out to the config file
    TQStringList locallyBlacklistedFolders() const;
    void localBlacklistFromStringList( const TQStringList & );
    TQString prettifyQuotaError( const TQString& _error, TDEIO::Job * job );
 
  protected:
    TQPtrList<TQGuardedPtr<KMFolder> > mOpenFolders;
    TQStringList mSubfolderNames, mSubfolderPaths,
        mSubfolderMimeTypes, mSubfolderAttributes;
    TQMap<TDEIO::Job *, jobData> mapJobData;
    TQTimer mIdleTimer;
    TQTimer mNoopTimer;
    int mTotal, mCountUnread, mCountLastUnread;
    TQMap<TQString, int> mUnreadBeforeCheck;
    bool mAutoExpunge : 1;
    bool mHiddenFolders : 1;
    bool mOnlySubscribedFolders : 1;
    bool mOnlyLocallySubscribedFolders : 1;
    bool mLoadOnDemand : 1;
    bool mListOnlyOpenFolders : 1;
    bool mProgressEnabled : 1;
 
    bool mErrorDialogIsActive : 1;
    bool mPasswordDialogIsActive : 1;
    bool mACLSupport : 1;
    bool mAnnotationSupport : 1;
    bool mQuotaSupport : 1;
    bool mSlaveConnected : 1;
    bool mSlaveConnectionError : 1;
    bool mCheckingSingleFolder : 1;
 
    // folders that should be checked for new mails
    TQValueList<TQGuardedPtr<KMFolder> > mMailCheckFolders;
    // folders that should be checked after the current check is done
    TQValueList<TQGuardedPtr<KMFolder> > mFoldersQueuedForChecking;
    // holds messageparts from the bodystructure
    TQPtrList<KMMessagePart> mBodyPartList;
    // the current message for the bodystructure
    KMMessage* mCurrentMsg;
 
    TQGuardedPtr<KPIM::ProgressItem> mListDirProgressItem;
 
    // our namespaces in the form section=namespaceList
    nsMap mNamespaces;
 
    // namespace - delimiter map
    namespaceDelim mNamespaceToDelimiter;
 
    // old prefix for migration
    TQString mOldPrefix;
 
    // capabilities
    TQStringList mCapabilities;
 
    std::set<TQString> mLocalSubscriptionBlackList;
 
  signals:
    void connectionResult( int errorCode, const TQString& errorMsg );
 
    void subscriptionChanged(const TQString& imapPath, bool subscribed);
 
    void subscriptionChangeFailed( const TQString &errorMessage );
 
    void imapStatusChanged( KMFolder*, const TQString& imapPath, bool cont );
 
    void receivedUserRights( KMFolder* folder );
 
    void receivedACL( KMFolder* folder, TDEIO::Job* job, const KMail::ACLList& entries );
 
    void receivedStorageQuotaInfo( KMFolder* folder, TDEIO::Job* job, const KMail::QuotaInfo& entries );
 
    void namespacesFetched( const ImapAccountBase::nsDelimMap& );
 
    void namespacesFetched();
  };
 
 
} // namespace KMail
 
#endif // __KMAIL_IMAPACCOUNTBASE_H__