ProcessProgressInfo.h

#ifndef PROCESSPROGRESSINFO_H
#define PROCESSPROGRESSINFO_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "XThreadSync.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
    typedef enum _ProgressStep
    {
        PROGRESS_INIT = 0x01,
        PROGRESS_POS_CHANGED = 0x02,
        PROGRESS_RANGE_CHANGED = 0x04,
        PROGRESS_TEXT_CHANGED = 0x08,
        PROGRESS_CHECK_CANCEL = 0x10,
        PROGRESS_END = 0x20,
    } ProgressStep;
 
    class ProcessProgressInfo;
    typedef bool (*ProcessProgressCallback)(unsigned int step, const ProcessProgressInfo& info, void *data);
 
    DLL_TOOLSFUNCTION bool progressCallCallback(unsigned int step, const ProcessProgressInfo& info);
    DLL_TOOLSFUNCTION void progressPushCallback(ProcessProgressCallback callback, void *data);
    DLL_TOOLSFUNCTION bool progressPopCallback();
    DLL_TOOLSFUNCTION ProcessProgressCallback progressGetCallback(void *&data);
    DLL_TOOLSFUNCTION bool progressUserCancel();
 
    class ProcessProgressInfo
    {
    protected:
        mutable CXCriticalSection threadLock;
        CXString title, text;
        int min, max, pos;
 
    public:
        ProcessProgressInfo(int min = 0, int max = 100, int pos = 0)
        {
            this->min = min;
            this->max = max;
            this->pos = pos;
        };
 
        ~ProcessProgressInfo()
        {
            progressCallCallback(PROGRESS_END, *this);
        };
 
        void SetRange(int refmin, int refmax)
        {
            CXSingleLock lock(&threadLock);
            this->min = refmin;
            this->max = refmax;
            pos = min;
        };
 
        void GetRange(int& refmin, int& refmax) const
        {
            refmin = min;
            refmax = max;
        }
        
        int GetRange() const
        {
            return max - min;
        }
 
        void AddMax(int max)
        {
            CXSingleLock lock(&threadLock);
            this->max += max;
        }
 
        void AddPos(int pos)
        {
            CXSingleLock lock(&threadLock);
            this->pos += pos;
        }
 
        void SetTitle(const CXString& reftitle)
        {
            CXSingleLock lock(&threadLock);
            this->title = reftitle;
        };
 
        CXString GetTitle() const
        {
            CXSingleLock lock(&threadLock);
            return title;
        }
 
        void SetText(const CXString& reftext)
        {
            CXSingleLock lock(&threadLock);
            this->text = reftext;
        };
 
        CXString GetText() const
        {
            CXSingleLock lock(&threadLock);
            return text;
        }
        
        void SetPos(int refpos)
        {
            CXSingleLock lock(&threadLock);
            this->pos = refpos;
        }
 
        int GetPos() const
        {
            return pos;
        }
 
        float GetPercent() const
        {
            CXSingleLock lock(&threadLock);
            return (float)pos/(float)(max-min);
        }
 
    };
 
    #define PROGRESS_CALLBACK_INIT(title, text, min, max) \
        bool processProgressCancel = FALSE; \
        ProcessProgressInfo progressCallbackInfo; \
        progressCallbackInfo.SetTitle(title); \
        progressCallbackInfo.SetText(text); \
        progressCallbackInfo.SetRange((int)min, (int)max); \
        progressCallCallback(PROGRESS_INIT|PROGRESS_POS_CHANGED|PROGRESS_RANGE_CHANGED|PROGRESS_TEXT_CHANGED, progressCallbackInfo);
 
    #define PROGRESS_CALLBACK_INIT2(title, text) \
        bool processProgressCancel = FALSE; \
        ProcessProgressInfo progressCallbackInfo; \
        progressCallbackInfo.SetTitle(title); \
        progressCallbackInfo.SetText(text); \
        progressCallCallback(PROGRESS_INIT|PROGRESS_TEXT_CHANGED, progressCallbackInfo);
 
    #define PROGRESS_SET_RANGE(min, max) \
            progressCallbackInfo.SetRange((int)min, (int)max); \
            progressCallCallback(PROGRESS_RANGE_CHANGED, progressCallbackInfo);
 
    #define PROGRESS_SET_POS(pos) \
            progressCallbackInfo.SetPos((int)pos); \
            progressCallCallback(PROGRESS_POS_CHANGED, progressCallbackInfo);
 
    #define PROGRESS_USER_CANCEL  processProgressCancel 
 
    #define PROGRESS_CHECK_CANCEL(action) \
        if (processProgressCancel) \
            action;
 
    #define PROGRESS_STEP(pos, modulo, action) \
        XASSERT(modulo); \
        if (((int)pos) % modulo) \
        { \
        PROGRESS_SET_POS(pos) \
        processProgressCancel = progressCallCallback(PROGRESS_POS_CHANGED|PROGRESS_CHECK_CANCEL, progressCallbackInfo); \
        if (processProgressCancel) \
            action; \
        }
 
END_MOOTOOLS_NAMESPACE
 
#endif // PROCESSPROGRESSINFO_H