You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdepim/libtdepim/progressmanager.cpp

249 lines
7.3 KiB

/*
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"