summaryrefslogtreecommitdiffstats
path: root/libtdepim/progressmanager.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'libtdepim/progressmanager.cpp')
-rw-r--r--libtdepim/progressmanager.cpp248
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"