---

Progress.cpp

//  Progress - a wrapper around QProgressDialog
//  Copyright (C) 2000-2003 bozo & sgbeal @users.sourceforge.net
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version 2
//  of the License, or (at your option) any later version.
//
//  This program 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 General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#include <assert.h>

#include <fun/Progress.h>
#include "ProgressI.h"
#include <qapplication.h>
#include <qcursor.h>
#include <qptrstack.h>
#include <qprogressdialog.h>
#include <qpushbutton.h>

//  True if you want this to print elapsed times to cerr, false if not.
//  Maybe finish() should take a timeval * or something for returning the
//  elapsed time?
#define ELAPSED_TIME_TO_CERR 1

using namespace fun;

static QApplication *g_qApp = NULL;
static QProgressDialog *g_pd = NULL;
static QPtrStack<Progress> g_stack;
static bool g_cancelled = false;
static int g_suspended = 0;
static bool g_showOnResume = false;
static QPushButton *g_cancelBtn = NULL;
static InternalProgressHelper *g_helper = NULL;

Progress::Progress(int s, const QString &op, bool cc)
 :  steps(s),
    step(0),
    canCancel(cc),
    msg(op)
{
    if (msg.isNull()) msg = "Busy, busy, busy.  I'm a busy program.";
#if ELAPSED_TIME_TO_CERR
    gettimeofday(&startTime, NULL);
#endif
}

Progress::~Progress()
{
#if ELAPSED_TIME_TO_CERR
    if (g_cancelled) return;
    timeval tv;
    gettimeofday(&tv, NULL);
    tv.tv_sec -= startTime.tv_sec;
    tv.tv_usec -= startTime.tv_usec;
    if (tv.tv_usec < 0)
    {
        --tv.tv_sec;
        tv.tv_usec += 1000000;
    }
    cerr << __FILE__ << " " << dec << __LINE__ << ": ";
    for (int ii = g_stack.count(); ii > 0; --ii) cerr << "  ";
    cerr << "\"" << msg << "\" elapsed: " << tv.tv_sec << "s " << tv.tv_usec << "us\n";
#endif
}

void
Progress::start(const QString &msg, int steps, bool canCancel)
{
    Progress *p = new Progress(steps, msg, canCancel);
    g_stack.push(p);
    if (g_qApp && !g_pd)
    {
        QApplication::setOverrideCursor(Qt::WaitCursor);
        if (!g_helper) g_helper = new InternalProgressHelper();
        g_pd = new QProgressDialog(NULL, NULL, true);
        g_cancelled = false;
        g_suspended = 0;
        g_showOnResume = false;
        //  When the progress dialog finds out the cancel button has been hit,
        //  it hides itself.  To keep that from happening, we create our own
        //  cancel button, and disconnect its signals from the progress
        //  dialog's slots.  Keeping a pointer to the button also lets us
        //  enable/disable it as needed.
        g_cancelBtn = new QPushButton("Cancel", g_pd);
        g_pd->setCancelButton(g_cancelBtn);
        g_cancelBtn->disconnect(SIGNAL(clicked()));
        g_helper->connect(g_cancelBtn, SIGNAL(clicked()), SLOT(cancelBtnClicked()));
        g_helper->connect(g_cancelBtn, SIGNAL(destroyed()), SLOT(cancelBtnDeleted()));
        g_helper->connect(g_pd, SIGNAL(destroyed()), SLOT(dialogDeleted()));
        g_pd->setAutoReset(false);
        g_pd->setAutoClose(false);
    }
    if (g_pd && (!g_cancelled) && (!g_suspended))
    {
        g_pd->setLabelText(msg);
        g_pd->setTotalSteps(steps);
        g_pd->setProgress(0);
        if (g_cancelBtn) g_cancelBtn->setEnabled(canCancel);
    }
}

bool
Progress::update(int step)
{
    assert(g_stack.top());
    if (g_pd)
    {
        if ((!g_cancelled) && (!g_suspended))
        {
            g_stack.top()->step = step;
            g_pd->setProgress(step);
        }
        g_qApp->processEvents();
        return g_cancelled;
    }
    return false;
}

void
Progress::suspend()
{
    if ((!g_suspended) && g_pd)
    {
        g_showOnResume = g_pd->isVisible();
        g_pd->hide();
        QApplication::restoreOverrideCursor();
    }
    ++g_suspended;
}

void
Progress::resume()
{
    if (g_suspended) --g_suspended;
    if ((!g_suspended) && g_pd)
    {
        QApplication::setOverrideCursor(Qt::WaitCursor);
        if (g_showOnResume) g_pd->show();
    }
}

void
Progress::finish()
{
    Progress *p = g_stack.pop();
    assert(p);
    delete p;
    if (!g_pd) return;
    p = g_stack.top();
    if (p)
    {
        if ((!g_cancelled) && (!g_suspended))
        {
            //  We finished a nested operation; put things back the way the
            //  parent operation had them.
            if (g_pd)
            {
                g_pd->setLabelText(p->msg);
                g_pd->setTotalSteps(p->steps);
                g_pd->setProgress(p->step);
            }
            if (g_cancelBtn) g_cancelBtn->setEnabled(p->canCancel);
        }
    }
    else
    {
        //  We're done!  Close the dialog.
        QProgressDialog *tp = g_pd;
        g_pd = NULL;
        g_cancelBtn = NULL;  //  it will get deleted by the dialog anyway.
        if (g_helper) g_helper->disconnect();
        delete tp;
        QApplication::restoreOverrideCursor();
    }
}

bool
Progress::cancelled() { return g_cancelled; }

void
Progress::setQApplication(QApplication *qapp)
{
    g_qApp = qapp;
    if (!qapp)
    {
        NOT_DONE("setQApplication() doesn't make sure dialog is down etc.");
    }
}

void
InternalProgressHelper::dialogDeleted()
{
    g_pd = NULL;
}

void
InternalProgressHelper::cancelBtnClicked()
{
    if (g_cancelled) return;
    g_cancelled = true;
    if (g_cancelBtn) g_cancelBtn->setEnabled(false);
    if (g_pd) g_pd->setLabelText("Oooh, wise guy, eh?");
}

void
InternalProgressHelper::cancelBtnDeleted()
{
    g_cancelBtn = NULL;
}

---