progressmonitor.inl

Go to the documentation of this file.

/*
    Sheep - A Rigid Body Dynamics Engine
    Copyright (C) 2001-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of Sheep.

    Sheep 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.

    Sheep 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 Sheep; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

inline
ProgressMonitor::ProgressMonitor() {
    Reset();
}

inline
void ProgressMonitor::Reset() {
    // The following members are set when a job starts:
    // m_job_start, m_job_duration, m_job_range_min, m_job_range_max, m_job_progress_scale.

    m_job_done = true;

    m_update_resolution = 1.0 / 100.0;
    m_message.erase();

    m_progress = 0.0;
    m_done = false;

    m_last_update = -2.0;   // trigger the update callback
}

inline
void ProgressMonitor::StartJob(Real range_min, Real range_max, Real duration /*= 1.0*/) {
    assert(m_job_done);
    assert(!m_done);

    assert(m_progress < 1.0);
    m_job_start = m_progress;

    assert(duration > 0.0);
    assert(m_job_start + duration <= 1.0);
    m_job_duration = duration;

    assert(range_min < range_max);
    m_job_range_min = range_min;
    m_job_range_max = range_max;
    m_job_progress_scale = m_job_duration / (m_job_range_max - m_job_range_min);

    m_job_done = false;

    post_update();
}

inline
void ProgressMonitor::EndJob() {
    assert(!m_job_done);

    m_progress = m_job_start + m_job_duration;
    m_job_done = true;

    // Bypass the post_update() mechanism because we want to trigger
    // the update callback even if no progress have been made.
    UpdateCallback();
}

inline
void ProgressMonitor::SetUpdateResolution(Real resolution) {
    assert(resolution <= 1.0);

    m_update_resolution = resolution;
}

inline
void ProgressMonitor::SetMessage(const std::string &message) {
    m_message = message;

    // Bypass the post_update() mechanism because we want to trigger
    // the update callback even if no progress have been made.
    UpdateCallback();
}

inline
const std::string &ProgressMonitor::GetMessage() const {
    return m_message;
}

inline
void ProgressMonitor::SetJobProgress(Real progress) {
    assert(!m_job_done);
    assert(!m_done);
    assert(progress >= m_job_range_min);
    assert(progress <= m_job_range_max);

    m_progress = m_job_start +
        (progress - m_job_range_min) * m_job_progress_scale;

    post_update();
}

inline
Real ProgressMonitor::GetProgress() const {
    return m_progress;
}

inline
void ProgressMonitor::Done() {
    assert(!m_done);

    if(!m_job_done)
        EndJob();

    assert(m_job_done);

    m_progress = 1.0;
    m_done = true;

    // Bypass the post_update() mechanism because we want to trigger
    // the update callback even if no progress have been made.
    UpdateCallback();
}

inline
bool ProgressMonitor::IsDone() const {
    return m_done;
}

inline
void ProgressMonitor::post_update() {
    const Real elapsed = m_progress - m_last_update;

    assert(elapsed >= 0.0);

    if(elapsed >= m_update_resolution) {
        UpdateCallback();

        m_last_update = m_progress;
    }
}

---