kmaccount.h

/*
 * kmail: KDE mail client
 * Copyright (c) 1996-1998 Stefan Taferner <taferner@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; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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 kmaccount_h
#define kmaccount_h
 
#include <tdeprocess.h>
#include <kaccount.h>
 
#include <tqstring.h>
#include <tqguardedptr.h>
#include <tqvaluelist.h>
#include <tqmap.h>
 
#include "kmmessage.h"
class TQTimer;
 
class KMFolder;
class KMAcctFolder;
class TDEConfig;
class KMFolderJob;
class KMFolderCachedImap;
class AccountsPageReceivingTab;
namespace  KMail {
  class FolderJob;
  class AccountManager;
}
using KMail::AccountManager;
namespace KPIM { class ProgressItem; }
using KMail::FolderJob;
using KPIM::ProgressItem;
 
class KMAccount;
typedef TQValueList< ::KMAccount* > AccountList;
 
class KMPrecommand : public TQObject
{
  TQ_OBJECT
  
 
public:
  KMPrecommand(const TQString &precommand, TQObject *parent = 0);
  virtual ~KMPrecommand();
  bool start();
 
protected slots:
  void precommandExited(TDEProcess *);
 
signals:
  void finished(bool);
 
protected:
  TDEProcess mPrecommandProcess;
  TQString mPrecommand;
};
 
 
class KMAccount: public TQObject, public KAccount
{
  TQ_OBJECT
  
  friend class KMail::AccountManager;
  friend class ::KMail::FolderJob;
  friend class ::AccountsPageReceivingTab; // part of the config dialog
  friend class ::KMFolderCachedImap; /* HACK for processNewMSg() */
 
public:
  virtual ~KMAccount();
 
  enum CheckStatus { CheckOK, CheckIgnored, CheckCanceled, CheckAborted,
                     CheckError };
 
  static const int DefaultCheckInterval = 5;
 
  virtual TQString type() const { return TQString(); }
 
  virtual void setName(const TQString&);
 
  virtual TQString name() const { return KAccount::name(); }
 
  virtual void clearPasswd();
 
  virtual void init();
 
  virtual void pseudoAssign(const KMAccount * a );
 
  KMFolder* folder(void) const { return ((KMFolder*)((KMAcctFolder*)mFolder)); }
  virtual void setFolder(KMFolder*, bool addAccount = false);
 
  TQString trash() const { return mTrash; }
  virtual void setTrash(const TQString& aTrash) { mTrash = aTrash; }
 
  virtual void processNewMail(bool interactive) = 0;
 
  virtual void readConfig(TDEConfig& config);
  void readTimerConfig();
 
  virtual void writeConfig(TDEConfig& config);
 
  virtual void setCheckInterval(int aInterval);
  int checkInterval() const;
 
  inline int defaultCheckInterval(void) const { return DefaultCheckInterval; }
 
  void deleteFolderJobs();
 
  virtual void ignoreJobsForMessage( KMMessage* );
  virtual void setCheckExclude(bool aExclude);
  bool checkExclude(void) const { return mExclude; }
 
  const TQString& precommand(void) const { return mPrecommand; }
  virtual void setPrecommand(const TQString &cmd) { mPrecommand = cmd; }
 
  bool runPrecommand(const TQString &precommand);
 
  static TQString encryptStr(const TQString& inStr);
  static TQString decryptStr(const TQString& inStr) { return  encryptStr(inStr); }
 
  static TQString importPassword(const TQString &);
 
  bool hasInbox() const { return mHasInbox; }
  virtual void setHasInbox( bool has ) { mHasInbox = has; }
 
  virtual void invalidateIMAPFolders();
 
  virtual bool mailCheckCanProceed() const { return true; }
 
  bool checkingMail() { return mCheckingMail; }
  virtual void setCheckingMail( bool checking ) { mCheckingMail = checking; }
 
  void checkDone( bool newMail, CheckStatus status );
 
  virtual void cancelMailCheck() {}
 
  ProgressItem *mailCheckProgressItem() const {
    return mMailCheckProgressItem;
  }
 
  void setIdentityId(uint identityId ) { mIdentityId = identityId; }
  uint identityId() const{ return mIdentityId; }
 
signals:
  virtual void finishedCheck( bool newMail, CheckStatus status );
 
  virtual void newMailsProcessed( const TQMap<TQString, int> & newInFolder );
 
protected slots:
  virtual void mailCheck();
  virtual void sendReceipts();
  virtual void precommandExited(bool);
 
protected:
  KMAccount( AccountManager* owner, const TQString& accountName, uint id);
 
  virtual bool processNewMsg(KMMessage* msg);
 
  virtual void sendReceipt(KMMessage* msg);
 
  virtual void installTimer();
  virtual void deinstallTimer();
 
  void addToNewInFolder( TQString folderId, int num );
 
protected:
  TQString       mPrecommand;
  TQString       mTrash;
  AccountManager*    mOwner;
  TQGuardedPtr<KMAcctFolder> mFolder;
  TQTimer *mTimer;
  int mInterval; // this is a switch and a scalar at the same time. If it is 0,
  // interval mail checking is turned off and the interval spinbox proposes a
  // default value. If it is non-null, it is the count of minutes between two
  // automated mail checks. This means that as soon as you disable interval
  // mail checking, the value in the spin box returns to a default value.
  bool mExclude;
  bool mCheckingMail : 1;
  bool mPrecommandSuccess;
  TQValueList<KMMessage*> mReceipts;
  TQPtrList<FolderJob>  mJobList;
  bool mHasInbox : 1;
  TQGuardedPtr<ProgressItem> mMailCheckProgressItem;
  uint mIdentityId;
private:
    virtual void setName( const char *name ) { TQObject::setName( name ); }
 
private:
  // for detailed (per folder) new mail notification
  TQMap<TQString, int> mNewInFolder;
};
 
#endif /*kmaccount_h*/