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:

    enum CryptoStatus {
        Encrypted,
        Unencrypted,
        Unknown
    };

    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; }

    void setCanBeCanceled(bool b);

    CryptoStatus cryptoStatus() const { return mCryptoStatus; }

    void setCryptoStatus( ProgressItem::CryptoStatus 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();

    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();

    void addChild( ProgressItem *kiddo );
    void removeChild( ProgressItem *kiddo );

    bool canceled() const { return mCanceled; }

    unsigned int typeProgressItem() const;
    void setTypeProgressItem(unsigned int);

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 progressItemCryptoStatus( KPIM::ProgressItem *, KPIM::ProgressItem::CryptoStatus );

    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, CryptoStatus cryptoStatus );
    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;
    CryptoStatus mCryptoStatus;
    unsigned int mType;
    bool mWaitingForKids;
    bool mCanceled;
    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();

    static ProgressItem *createProgressItem( unsigned int progressType, const QString &label );

    static ProgressItem *createProgressItem( const QString &label );

    static ProgressItem *createProgressItem( ProgressItem *parent,
                                             const QString &id,
                                             const QString &label,
                                             const QString &status = QString(),
                                             bool canBeCanceled = true,
                                             KPIM::ProgressItem::CryptoStatus cryptoStatus = KPIM::ProgressItem::Unencrypted );

    static ProgressItem *createProgressItem( const QString &parent,
                                             const QString &id,
                                             const QString &label,
                                             const QString &status = QString(),
                                             bool canBeCanceled = true,
                                             KPIM::ProgressItem::CryptoStatus cryptoStatus = KPIM::ProgressItem::Unencrypted );

    static ProgressItem *createProgressItem( const QString &id,
                                             const QString &label,
                                             const QString &status = QString(),
                                             bool canBeCanceled = true,
                                             KPIM::ProgressItem::CryptoStatus cryptoStatus = KPIM::ProgressItem::Unencrypted );

    static ProgressItem *createProgressItem( ProgressItem *parent,
                                             const Akonadi::AgentInstance &agent,
                                             const QString &id,
                                             const QString &label,
                                             const QString &status = QString(),
                                             bool canBeCanceled = true,
                                             KPIM::ProgressItem::CryptoStatus cryptoStatus = KPIM::ProgressItem::Unencrypted );

    bool isEmpty() const;

    ProgressItem *singleItem() const;

    static void emitShowProgressDialog();

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 progressItemCryptoStatus( KPIM::ProgressItem *, KPIM::ProgressItem::CryptoStatus );
    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,
                                                  ProgressItem::CryptoStatus cryptoStatus, unsigned int progressType = 0);

    virtual ProgressItem *createProgressItemImpl(const QString &parent,
                                                  const QString &id,
                                                  const QString &label,
                                                  const QString &status,
                                                  bool cancellable,
                                                  ProgressItem::CryptoStatus cryptoStatus, unsigned int progressType = 0 );
    ProgressItem *createProgressItemForAgent( ProgressItem *parent,
                                              const Akonadi::AgentInstance &instance,
                                              const QString &id,
                                              const QString &label,
                                              const QString &status,
                                              bool cancellable,
                                              ProgressItem::CryptoStatus cryptoStatus, unsigned int progressType = 0 );
    void emitShowProgressDialogImpl();

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

}

#endif // __KPIM_PROGRESSMANAGER_H__