progressmanager.h

/*
  progressmanager.h
 
  This file is part of TDEPIM.
 
  Author: Till Adam <adam@kde.org> (C) 2004
 
  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.
*/
 
#ifndef __KPIM_PROGRESSMANAGER_H__
#define __KPIM_PROGRESSMANAGER_H__
 
#include <tqobject.h>
#include <tqdict.h>
#include <tqstring.h>
 
#include <kdemacros.h>
 
namespace KPIM {
 
class ProgressItem;
class ProgressManager;
typedef TQMap<ProgressItem*, bool> ProgressItemMap;
 
class TDE_EXPORT ProgressItem : public TQObject
{
  TQ_OBJECT
  
  friend class ProgressManager;
  friend class TQDict< ProgressItem >; // so it can be deleted from dicts
 
  public:
 
    const TQString& id() const { return mId; }
 
    ProgressItem *parent() const { return mParent; }
 
    const TQString& label() const { return mLabel; }
 
    void setLabel( const TQString& v );
 
    const TQString& status() const { return mStatus; }
    void setStatus( const TQString& v );
 
    bool canBeCanceled() const { return mCanBeCanceled; }
 
    bool usesCrypto() const { return mUsesCrypto; }
 
    void setUsesCrypto( bool v );
 
    bool usesBusyIndicator() const { return mUsesBusyIndicator; }
 
    void setUsesBusyIndicator( bool useBusyIndicator );
 
    unsigned int progress() const { return mProgress; }
 
    void setProgress( unsigned int v );
 
    void setComplete();
 
    void reset() { setProgress( 0 ); setStatus( TQString() ); mCompleted = 0; }
 
    void cancel();
 
    // Often needed values for calculating progress.
    void setTotalItems( unsigned int v ) { mTotal = v; }
    unsigned int totalItems() const { return mTotal; }
    void setCompletedItems( unsigned int v ) { mCompleted = v; }
    void incCompletedItems( unsigned int v = 1 ) { mCompleted += v; }
    unsigned int completedItems() const { return mCompleted; }
 
    void updateProgress() { setProgress( mTotal? mCompleted*100/mTotal: 0 ); }
 
    void addChild( ProgressItem *kiddo );
    void removeChild( ProgressItem *kiddo );
 
    bool canceled() const { return mCanceled; }
 
signals:
    void progressItemAdded( KPIM::ProgressItem* );
    void progressItemProgress( KPIM::ProgressItem*, unsigned int );
    void progressItemCompleted( KPIM::ProgressItem* );
    void progressItemCanceled( KPIM::ProgressItem* );
    void progressItemStatus( KPIM::ProgressItem*, const TQString& );
    void progressItemLabel( KPIM::ProgressItem*, const TQString& );
    void progressItemUsesCrypto( KPIM::ProgressItem*, bool );
 
    void progressItemUsesBusyIndicator( KPIM::ProgressItem *item, bool value );
 
 
  protected:
    /* Only to be used by our good friend the ProgressManager */
    ProgressItem( ProgressItem* parent,
                             const TQString& id,
                             const TQString& label,
                             const TQString& status,
                             bool isCancellable,
                             bool usesCrypto );
    virtual ~ProgressItem();
 
 
  private:
    TQString mId;
    TQString mLabel;
    TQString mStatus;
    ProgressItem* mParent;
    bool mCanBeCanceled;
    unsigned int mProgress;
    ProgressItemMap mChildren;
    unsigned int mTotal;
    unsigned int mCompleted;
    bool mWaitingForKids;
    bool mCanceled;
    bool mUsesCrypto;
    bool mUsesBusyIndicator;
};
 
class TDE_EXPORT ProgressManager : public TQObject
{
 
  TQ_OBJECT
  
 
  public:
    virtual ~ProgressManager();
 
    static ProgressManager * instance();
 
    static TQString getUniqueID() { return TQString::number( ++uID ); }
 
     static ProgressItem * createProgressItem( const TQString &label ) {
       return instance()->createProgressItemImpl( 0, getUniqueID(), label,
                                                  TQString(), true, false );
     }
 
     static ProgressItem * createProgressItem( ProgressItem* parent,
                                               const TQString& id,
                                               const TQString& label,
                                               const TQString& status = TQString(),
                                               bool canBeCanceled = true,
                                               bool usesCrypto = false ) {
       return instance()->createProgressItemImpl( parent, id, label, status,
                                                  canBeCanceled, usesCrypto );
     }
 
     static ProgressItem * createProgressItem( const TQString& parent,
                                               const TQString& id,
                                               const TQString& label,
                                               const TQString& status = TQString(),
                                               bool canBeCanceled = true,
                                               bool usesCrypto = false ) {
       return instance()->createProgressItemImpl( parent, id, label,
                                                 status, canBeCanceled, usesCrypto );
     }
 
     static ProgressItem * createProgressItem( const TQString& id,
                                               const TQString& label,
                                               const TQString& status = TQString(),
                                               bool canBeCanceled = true,
                                               bool usesCrypto = false ) {
       return instance()->createProgressItemImpl( 0, id, label, status,
                                                  canBeCanceled, usesCrypto );
     }
 
 
    bool isEmpty() const { return mTransactions.isEmpty(); }
 
    ProgressItem* singleItem() const;
 
    static void emitShowProgressDialog() {
       instance()->emitShowProgressDialogImpl();
    }
 
  signals:
    void progressItemAdded( KPIM::ProgressItem* );
    void progressItemProgress( KPIM::ProgressItem*, unsigned int );
    void progressItemCompleted( KPIM::ProgressItem* );
    void progressItemCanceled( KPIM::ProgressItem* );
    void progressItemStatus( KPIM::ProgressItem*, const TQString& );
    void progressItemLabel( KPIM::ProgressItem*, const TQString& );
    void progressItemUsesCrypto( KPIM::ProgressItem*, bool );
    void progressItemUsesBusyIndicator( KPIM::ProgressItem*, bool );
 
    void showProgressDialog();
  public slots:
 
    void slotStandardCancelHandler( KPIM::ProgressItem* item );
 
    void slotAbortAll();
 
  private slots:
    void slotTransactionCompleted( KPIM::ProgressItem *item );
 
  private:
    ProgressManager();
     // prevent unsolicited copies
    ProgressManager( const ProgressManager& );
 
    virtual ProgressItem* createProgressItemImpl(
                ProgressItem* parent, const TQString& id,
                const TQString& label, const TQString& status,
                bool cancellable, bool usesCrypto );
    virtual ProgressItem* createProgressItemImpl(
                const TQString& parent,  const TQString& id,
                const TQString& label, const TQString& status,
                bool cancellable, bool usesCrypto );
    void emitShowProgressDialogImpl();
 
    TQDict< ProgressItem > mTransactions;
    static ProgressManager *mInstance;
    static unsigned int uID;
};
 
}
 
#endif // __KPIM_PROGRESSMANAGER_H__