[an error occurred while processing this directive]

hugin_base/appbase/ProgressDisplay.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
#ifndef _APPBASE_PROGRESSDISPLAY_H
#define _APPBASE_PROGRESSDISPLAY_H

#include <iostream>
#include <string>
#include <vector>

#include <hugin_shared.h>
#include <hugin_utils/utils.h>


namespace AppBase {

class IMPEX ProgressDisplay
{
        
    // -- Task object --
        
    protected:

        struct ProgressSubtask
        {
            std::string message;
            double maxProgress;
            double progressForParentTask;
            bool propagatesProgress;
            double progress;
            
            public:
                
                ProgressSubtask() { };
                
                ProgressSubtask(const std::string& message,
                                const double& maxProgress,
                                const double& progressForParentTask, 
                                const bool& propagatesProgress)
                    : message(message),
                      maxProgress(maxProgress),
                      progressForParentTask(progressForParentTask), 
                      propagatesProgress(propagatesProgress),
                      progress(0.0)
                {};
                
                inline bool measuresProgress()
                    { return maxProgress != 0.0; };
            
        };
        
        
    // -- Const/Destructors --
        
    protected:
        ProgressDisplay()
            : o_canceled(false), o_newSubtaskProgress(0), o_newSubtaskPropagates(true)
        {};
        
    public:
        virtual ~ProgressDisplay() {};
        
        
    // -- task interface --
        
    protected:
        void startSubtaskWithTask(const ProgressSubtask& newSubtask);
        
    public:
        void setParentProgressOfNewSubtasks(double subtaskTotalProgress, bool propagatesProgress = false);
        
        void startSubtask(const std::string& message,
                          const double& maxProgress,
                          const double& progressForParentTask,
                          const bool& propagatesProgress = false);
        
        void startSubtask(const std::string& message,
                          const double& maxProgress = 0);
        
        void startSubtask(const double& maxProgress);
           
        virtual void setSubtaskMessage(const std::string& message);
        
        virtual std::string getSubtaskMessage() const;
        
        virtual double getSubtaskMaxProgress() const;
            
        virtual double getSubtaskProgress() const;
        
        virtual void updateSubtaskProgress(const double& newValue);
        
        virtual void increaseSubtaskProgressBy(const double& deltaValue);
        
        virtual void finishSubtask();
        
        virtual bool wasCancelled();
        
    protected:
        virtual void cancelTask();
        
        
    // -- callback interface --
        
    protected:
        virtual void updateProgressDisplay() =0;
        
        virtual void subtaskStarted()
            { DEBUG_DEBUG("Subtask started."); };
        
        virtual void subtaskFinished()
            { DEBUG_DEBUG("Subtask finished."); };
             
        
    // -- utility methods --
        
    protected:
        virtual void propagateProgress(const double& newProgress);

        virtual ProgressSubtask& getCurrentSubtask() const;

        virtual bool noSubtasksAvailable() const;
        
        
    // -- accessable variables --
        
    protected:
        std::vector<ProgressSubtask> o_subtasks;
        bool o_canceled;
        
        double o_newSubtaskProgress;
        bool o_newSubtaskPropagates;
        
};


class IMPEX DummyProgressDisplay : public ProgressDisplay
{
    public:
        DummyProgressDisplay()
            : ProgressDisplay()
        {};

        virtual ~DummyProgressDisplay() {};

        virtual void updateProgressDisplay()
        { };
    protected:
};

class IMPEX StreamProgressDisplay : public ProgressDisplay
{
    public:
        StreamProgressDisplay(std::ostream & o)
            : ProgressDisplay(),
              m_stream(o),
              m_printedLines(0), m_whizz("-\\|/"), m_whizzCount(0)
        {};

        virtual ~StreamProgressDisplay() {};

        virtual void updateProgressDisplay();
    protected:
        std::ostream & m_stream;
        int m_printedLines;
        std::string m_whizz;
        int m_whizzCount;
};


}; //namespace
#endif // _H

---