progressmanager.h

Go to the documentation of this file.

/*
  progressmanager.h

  This file is part of libkdepim.

  Copyright (C) 2004 Till Adam <adam@kde.org>

  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 KDEPIM_PROGRESSMANAGER_H
#define KDEPIM_PROGRESSMANAGER_H

#include "kdepim_export.h"

#include <QObject>
#include <QString>
#include <QMap>
#include <QHash>
#include <QWeakPointer>
#include <QPointer>
namespace Akonadi {
class AgentInstance;
}

namespace KPIM {

class ProgressItem;
class ProgressManager;
typedef QMap<ProgressItem *, bool> ProgressItemMap;

class KDEPIM_EXPORT ProgressItem : public QObject
{
    Q_OBJECT
    friend class ProgressManager;

public:

    const QString &id() const { return mId; }

    ProgressItem *parent() const { return mParent.data(); }

    const QString &label() const { return mLabel; }

    void setLabel( const QString &v );

    const QString &status() const { return mStatus; }
    void setStatus( const QString &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( QString() );
        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; }

Q_SIGNALS:
    void progressItemAdded( KPIM::ProgressItem * );

    void progressItemProgress( KPIM::ProgressItem *, unsigned int );

    void progressItemCompleted( KPIM::ProgressItem * );

    void progressItemCanceled( KPIM::ProgressItem * );

    void progressItemStatus( KPIM::ProgressItem *, const QString & );

    void progressItemLabel( KPIM::ProgressItem *, const QString & );

    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 QString &id, const QString &label,
                  const QString &status, bool isCancellable, bool usesCrypto );
    virtual ~ProgressItem();

private:
    QString mId;
    QString mLabel;
    QString mStatus;
    QWeakPointer<ProgressItem>mParent;
    bool mCanBeCanceled;
    unsigned int mProgress;
    ProgressItemMap mChildren;
    unsigned int mTotal;
    unsigned int mCompleted;
    bool mWaitingForKids;
    bool mCanceled;
    bool mUsesCrypto;
    bool mUsesBusyIndicator;
    bool mCompletedCalled;
};

struct ProgressManagerPrivate;

class KDEPIM_EXPORT ProgressManager : public QObject
{

    Q_OBJECT

    friend struct ProgressManagerPrivate;

public:
    virtual ~ProgressManager();

    static ProgressManager *instance();

    static QString getUniqueID()
    {
        return QString::number( ++uID );
    }

    static ProgressItem *createProgressItem( const QString &label )
    {
        return instance()->createProgressItemImpl( 0, getUniqueID(), label,
                                                   QString(), true, false );
    }

    static ProgressItem *createProgressItem( ProgressItem *parent,
                                             const QString &id,
                                             const QString &label,
                                             const QString &status = QString(),
                                             bool canBeCanceled = true,
                                             bool usesCrypto = false )
    {
        return instance()->createProgressItemImpl( parent, id, label, status,
                                                   canBeCanceled, usesCrypto );
    }

    static ProgressItem *createProgressItem( const QString &parent,
                                             const QString &id,
                                             const QString &label,
                                             const QString &status = QString(),
                                             bool canBeCanceled = true,
                                             bool usesCrypto = false )
    {
        return instance()->createProgressItemImpl( parent, id, label,
                                                   status, canBeCanceled, usesCrypto );
    }

    static ProgressItem *createProgressItem( const QString &id,
                                             const QString &label,
                                             const QString &status = QString(),
                                             bool canBeCanceled = true,
                                             bool usesCrypto = false )
    {
        return instance()->createProgressItemImpl( 0, id, label, status,
                                                   canBeCanceled, usesCrypto );
    }

    static ProgressItem *createProgressItem( ProgressItem *parent,
                                             const Akonadi::AgentInstance &agent,
                                             const QString &id,
                                             const QString &label,
                                             const QString &status = QString(),
                                             bool canBeCanceled = true,
                                             bool usesCrypto = false )
    {
        return instance()->createProgressItemForAgent( parent, agent, id, label,
                                                       status, canBeCanceled, usesCrypto );
    }

    bool isEmpty() const
    {
        return mTransactions.isEmpty();
    }

    ProgressItem *singleItem() const;

    static void emitShowProgressDialog()
    {
        instance()->emitShowProgressDialogImpl();
    }

Q_SIGNALS:
    void progressItemAdded( KPIM::ProgressItem * );
    void progressItemProgress( KPIM::ProgressItem *, unsigned int );
    void progressItemCompleted( KPIM::ProgressItem * );
    void progressItemCanceled( KPIM::ProgressItem * );
    void progressItemStatus( KPIM::ProgressItem *, const QString & );
    void progressItemLabel( KPIM::ProgressItem *, const QString & );
    void progressItemUsesCrypto( KPIM::ProgressItem *, bool );
    void progressItemUsesBusyIndicator( KPIM::ProgressItem*, bool );

    void showProgressDialog();

public Q_SLOTS:

    void slotStandardCancelHandler( KPIM::ProgressItem *item );

    void slotAbortAll();

private Q_SLOTS:
    void slotTransactionCompleted( KPIM::ProgressItem *item );

private:
    ProgressManager();
    // prevent unsolicited copies
    ProgressManager( const ProgressManager & );

    virtual ProgressItem *createProgressItemImpl( ProgressItem *parent,
                                                  const QString &id,
                                                  const QString &label,
                                                  const QString &status,
                                                  bool cancellable,
                                                  bool usesCrypto );
    virtual ProgressItem *createProgressItemImpl( const QString &parent,
                                                  const QString &id,
                                                  const QString &label,
                                                  const QString &status,
                                                  bool cancellable,
                                                  bool usesCrypto );
    ProgressItem *createProgressItemForAgent( ProgressItem *parent,
                                              const Akonadi::AgentInstance &instance,
                                              const QString &id,
                                              const QString &label,
                                              const QString &status,
                                              bool cancellable,
                                              bool usesCrypto );
    void emitShowProgressDialogImpl();

    QHash< QString, ProgressItem* > mTransactions;
    static unsigned int uID;
};

}

#endif // __KPIM_PROGRESSMANAGER_H__