quotajobs.h

 
#ifndef QUOTAJOBS_H
#define QUOTAJOBS_H
 
#include <tqvariant.h>
 
#include <tdeio/job.h>
#include <tdelocale.h>
#include <tqvaluevector.h>
 
#include <math.h>
 
#include "globalsettings.h"
 
namespace KMail {
 
// One quota entry consisting of a name, the quota root,
// the current value and the maximal value
class QuotaInfo {
  public :
  QuotaInfo() {} // for TQValueVector
  QuotaInfo( const TQString& _name, const TQString& _root, const TQVariant& _current, const TQVariant& _max )
    : mName( _name ), mRoot( _root ), mCurrent( _current ),mMax( _max )  {}
  bool operator==( const QuotaInfo & other ) const {
    return mName == other.mName && mRoot == other.mRoot && mMax == other.mMax && mCurrent == other.mCurrent;
  }
  bool operator!=( const QuotaInfo & other ) const {
    return !(operator==(other) );
  }
  bool isValid() const { return !mName.isEmpty(); }
  bool isEmpty() const { return mName.isEmpty() || ( mRoot.isEmpty() && !mCurrent.isValid() && !mMax.isValid() ); }
 
  TQString name() const { return mName; }
  void setName( const TQString& n ) { mName = n; }
  TQString root() const { return mRoot; }
  void setRoot( const TQString& r ) { mRoot = r; }
  TQVariant max() const { return mMax; }
  void setMax( const TQVariant& m ) { mMax = m; }
  TQVariant current() const { return mCurrent; }
  void setCurrent( const TQVariant& c ) { mCurrent = c; }
 
  TQString toString() const {
    if ( isValid() && !isEmpty() ) {
      readConfig();
      int factor = static_cast<int> ( pow( 1000, mFactor ) );
      return i18n("%1 of %2 %3 used").arg( mCurrent.toInt() / factor )
                                .arg( mMax.toInt() / factor ).arg( mUnits );
    }
    return TQString();
  }
 
 private:
  void readConfig() const {
      if( GlobalSettings::self()->quotaUnit() == GlobalSettings::EnumQuotaUnit::KB )
      {
            mUnits = i18n("KB");
            mFactor = 0;
      }
      else if( GlobalSettings::self()->quotaUnit() == GlobalSettings::EnumQuotaUnit::MB )
           {
                mUnits = i18n("MB");
                mFactor = 1;
           }
      else if( GlobalSettings::self()->quotaUnit() == GlobalSettings::EnumQuotaUnit::GB )
           {
               mUnits = i18n("GB");
               mFactor = 2;
           }
   }
 
  TQString mName;  // e.g. STORAGE
  TQString mRoot; 
  TQVariant mCurrent;
  TQVariant mMax;
  mutable TQString mUnits; //used by readConfig (const) privately and is modified
  mutable int mFactor;
};
 
typedef TQValueVector<QuotaInfo> QuotaInfoList;
 
namespace QuotaJobs {
 
class GetQuotarootJob;
GetQuotarootJob* getQuotaroot( TDEIO::Slave* slave, const KURL& url );
 
class GetStorageQuotaJob;
GetStorageQuotaJob* getStorageQuota( TDEIO::Slave* slave, const KURL& url );
 
class GetQuotarootJob : public TDEIO::SimpleJob
{
  TQ_OBJECT
  
public:
  GetQuotarootJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo );
 
signals:
  void quotaRootResult( const TQStringList& roots );
 
  void quotaInfoReceived( const QuotaInfoList& info );
 
protected slots:
  void slotInfoMessage( TDEIO::Job*, const TQString& );
};
 
class GetStorageQuotaJob : public TDEIO::Job
{
  TQ_OBJECT
  
public:
  GetStorageQuotaJob( TDEIO::Slave* slave, const KURL& url );
 
  QuotaInfo storageQuotaInfo() const;
 
signals:
  void storageQuotaResult( const QuotaInfo& info );
 
 
protected slots:
  void slotQuotarootResult( const TQStringList& roots );
  void slotQuotaInfoReceived( const QuotaInfoList& roots );
private:
  QuotaInfo mStorageQuotaInfo;
};
 
} // QuotaJobs namespace
 
} // KMail namespace
 
 
#endif /* QUOTAJOBS_H */