diff options
Diffstat (limited to 'libtdepim/progressmanager.cpp')
| -rw-r--r-- | libtdepim/progressmanager.cpp | 248 |
1 files changed, 248 insertions, 0 deletions
diff --git a/libtdepim/progressmanager.cpp b/libtdepim/progressmanager.cpp new file mode 100644 index 000000000..a00970c5e --- /dev/null +++ b/libtdepim/progressmanager.cpp @@ -0,0 +1,248 @@ +/* + progressmanager.cpp + + This file is part of KDEPIM. + + 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. +*/ + +#include <tqvaluevector.h> +#include <kdebug.h> + +#include <klocale.h> +#include <kstaticdeleter.h> + +#include "progressmanager.h" + +namespace KPIM { + +KPIM::ProgressManager * KPIM::ProgressManager::mInstance = 0; +unsigned int KPIM::ProgressManager::uID = 42; + +ProgressItem::ProgressItem( + ProgressItem* parent, const TQString& id, + const TQString& label, const TQString& status, bool canBeCanceled, + bool usesCrypto ) + :mId( id ), mLabel( label ), mtqStatus( status ), mParent( parent ), + mCanBeCanceled( canBeCanceled ), mProgress( 0 ), mTotal( 0 ), + mCompleted( 0 ), mWaitingForKids( false ), mCanceled( false ), + mUsesCrypto( usesCrypto ), mUsesBusyIndicator( false ) + {} + +ProgressItem::~ProgressItem() +{ +} + +void ProgressItem::setComplete() +{ +// kdDebug(5300) << "ProgressItem::setComplete - " << label() << endl; + + if ( mChildren.isEmpty() ) { + if ( !mCanceled ) + setProgress( 100 ); + emit progressItemCompleted( this ); + if ( parent() ) + parent()->removeChild( this ); + deleteLater(); + } else { + mWaitingForKids = true; + } +} + +void ProgressItem::addChild( ProgressItem *kiddo ) +{ + mChildren.replace( kiddo, true ); +} + +void ProgressItem::removeChild( ProgressItem *kiddo ) +{ + mChildren.remove( kiddo ); + // in case we were waiting for the last kid to go away, now is the time + if ( mChildren.count() == 0 && mWaitingForKids ) { + emit progressItemCompleted( this ); + deleteLater(); + } +} + +void ProgressItem::cancel() +{ + if ( mCanceled || !mCanBeCanceled ) return; + kdDebug(5300) << "ProgressItem::cancel() - " << label() << endl; + mCanceled = true; + // Cancel all tqchildren. + TQValueList<ProgressItem*> kids = mChildren.keys(); + TQValueList<ProgressItem*>::Iterator it( kids.begin() ); + TQValueList<ProgressItem*>::Iterator end( kids.end() ); + for ( ; it != end; it++ ) { + ProgressItem *kid = *it; + if ( kid->canBeCanceled() ) + kid->cancel(); + } + setqStatus( i18n( "Aborting..." ) ); + emit progressItemCanceled( this ); +} + + +void ProgressItem::setProgress( unsigned int v ) +{ + mProgress = v; + // kdDebug(5300) << "ProgressItem::setProgress(): " << label() << " : " << v << endl; + emit progressItemProgress( this, mProgress ); +} + +void ProgressItem::setLabel( const TQString& v ) +{ + mLabel = v; + emit progressItemLabel( this, mLabel ); +} + +void ProgressItem::setqStatus( const TQString& v ) +{ + mtqStatus = v; + emit progressItemtqStatus( this, mtqStatus ); +} + +void ProgressItem::setUsesCrypto( bool v ) +{ + mUsesCrypto = v; + emit progressItemUsesCrypto( this, v ); +} + +void ProgressItem::setUsesBusyIndicator( bool useBusyIndicator ) +{ + mUsesBusyIndicator = useBusyIndicator; + emit progressItemUsesBusyIndicator( this, useBusyIndicator ); +} + +// ====================================== + +ProgressManager::ProgressManager() :TQObject() { + mInstance = this; +} + +ProgressManager::~ProgressManager() { mInstance = 0; } +static KStaticDeleter<ProgressManager> progressManagerDeleter; + +ProgressManager* ProgressManager::instance() +{ + if ( !mInstance ) { + progressManagerDeleter.setObject( mInstance, new ProgressManager() ); + } + return mInstance; +} + +ProgressItem* ProgressManager::createProgressItemImpl( + ProgressItem* parent, const TQString& id, + const TQString &label, const TQString &status, + bool cancellable, bool usesCrypto ) +{ + ProgressItem *t = 0; + if ( !mTransactions[ id ] ) { + t = new ProgressItem ( parent, id, label, status, cancellable, usesCrypto ); + mTransactions.insert( id, t ); + if ( parent ) { + ProgressItem *p = mTransactions[ parent->id() ]; + if ( p ) { + p->addChild( t ); + } + } + // connect all signals + connect ( t, TQT_SIGNAL( progressItemCompleted(KPIM::ProgressItem*) ), + this, TQT_SLOT( slotTransactionCompleted(KPIM::ProgressItem*) ) ); + connect ( t, TQT_SIGNAL( progressItemProgress(KPIM::ProgressItem*, unsigned int) ), + this, TQT_SIGNAL( progressItemProgress(KPIM::ProgressItem*, unsigned int) ) ); + connect ( t, TQT_SIGNAL( progressItemAdded(KPIM::ProgressItem*) ), + this, TQT_SIGNAL( progressItemAdded(KPIM::ProgressItem*) ) ); + connect ( t, TQT_SIGNAL( progressItemCanceled(KPIM::ProgressItem*) ), + this, TQT_SIGNAL( progressItemCanceled(KPIM::ProgressItem*) ) ); + connect ( t, TQT_SIGNAL( progressItemtqStatus(KPIM::ProgressItem*, const TQString&) ), + this, TQT_SIGNAL( progressItemtqStatus(KPIM::ProgressItem*, const TQString&) ) ); + connect ( t, TQT_SIGNAL( progressItemLabel(KPIM::ProgressItem*, const TQString&) ), + this, TQT_SIGNAL( progressItemLabel(KPIM::ProgressItem*, const TQString&) ) ); + connect ( t, TQT_SIGNAL( progressItemUsesCrypto(KPIM::ProgressItem*, bool) ), + this, TQT_SIGNAL( progressItemUsesCrypto(KPIM::ProgressItem*, bool) ) ); + connect ( t, TQT_SIGNAL( progressItemUsesBusyIndicator(KPIM::ProgressItem*, bool) ), + this, TQT_SIGNAL( progressItemUsesBusyIndicator(KPIM::ProgressItem*, bool) ) ); + + emit progressItemAdded( t ); + } else { + // Hm, is this what makes the most sense? + t = mTransactions[id]; + } + return t; +} + +ProgressItem* ProgressManager::createProgressItemImpl( + const TQString& parent, const TQString &id, + const TQString &label, const TQString& status, + bool canBeCanceled, bool usesCrypto ) +{ + ProgressItem * p = mTransactions[parent]; + return createProgressItemImpl( p, id, label, status, canBeCanceled, usesCrypto ); +} + +void ProgressManager::emitShowProgressDialogImpl() +{ + emit showProgressDialog(); +} + + +// slots + +void ProgressManager::slotTransactionCompleted( ProgressItem *item ) +{ + mTransactions.remove( item->id() ); + emit progressItemCompleted( item ); +} + +void ProgressManager::slotStandardCancelHandler( ProgressItem *item ) +{ + item->setComplete(); +} + +ProgressItem* ProgressManager::singleItem() const +{ + ProgressItem *item = 0; + TQDictIterator< ProgressItem > it( mTransactions ); + for ( ; it.current(); ++it ) { + + // No single item for progress possible, as one of them is a busy indicator one. + if ( (*it)->usesBusyIndicator() ) + return 0; + + if ( !(*it)->parent() ) { // if it's a top level one, only those count + if ( item ) + return 0; // we found more than one + else + item = (*it); + } + } + return item; +} + +void ProgressManager::slotAbortAll() +{ + TQDictIterator< ProgressItem > it( mTransactions ); + for ( ; it.current(); ++it ) { + it.current()->cancel(); + } +} + +} // namespace + +#include "progressmanager.moc" |