TnbMfcSmoothProgressCtrl.h

[詳解]

#pragma once
#include "TnbMfcCommon.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
template<typename PGC = CProgressCtrl>
class CSmoothProgressCtrlT : public PGC
{
    DEFSUPER(PGC);
public:
 
    CSmoothProgressCtrlT(void) : m_step(1), m_currentPos(0), m_maxDelta(-1.0)
    {
    }
 
    COLORREF SetBarColor(COLORREF color = CLR_DEFAULT) 
    {
        return _super::SendMessage(PBM_SETBARCOLOR, 0, color);
    }
 
    COLORREF SetBkColor(COLORREF color = CLR_DEFAULT)
    {
        return _super::SendMessage(PBM_SETBKCOLOR, 0, color);
    }
 
    void SetRange(short nLower, short nUpper)
    {
        SetRange32(nLower, nUpper);
    }
 
    void SetRange32(int nLower, int nUpper)
    {
        _super::SetRange32(nLower, nUpper);
        m_lower = nLower;
        m_upper = nUpper;
    }
 
    void GetRange(int& _nLower, int& _nUpper)
    {
        _super::GetRange(_nLower, _nUpper);
    }
 
    int GetPos(void)
    {
        return m_currentPos;
    }
 
    int SetPos(int nPos)
    {
        m_currentPos = nPos;
        m_viewPos = nPos;
        m_viewDelta = 0.0;
        return _super::SetPos(nPos);
    }
 
    int SetStep(int nStep)
    {
        Swap(m_step, nStep);
        return nStep;
    }
 
    int StepIt(void)
    {
        return OffsetPos(m_step);
    }
 
    int OffsetPos(int nPos)
    {
        int r = m_currentPos;
        m_currentPos += nPos;
        _super::SetTimer(TIMERID_MOVE, 10, NULL);
        return  r;
    }
 
    void SetMaxDelta(double d = -1.0)
    {
        m_maxDelta = d;         
    }
 
protected:
 
    virtual void PreSubclassWindow(void)
    {
        _super::GetRange(m_lower, m_upper);
        SetPos(0);
        _super::PreSubclassWindow();
    }
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        if ( message == WM_TIMER && wParam == TIMERID_MOVE )
        {
            OnMoveTimer(wParam);
            return 0;
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
    void OnMoveTimer(UINT nIDEvent)
    {
        ASSERT( nIDEvent == TIMERID_MOVE );
        if ( m_currentPos != ToInt(m_viewPos + 0.005) )
        {
            // 表示位置と、内部位置にずれがある。
            m_viewDelta = m_currentPos - m_viewPos;
            if ( m_upper != m_currentPos )
            {
                m_viewDelta /= 20.0; //20回で
            }
            else
            {
                m_viewDelta /= 5.0; //5回で
            }
        }
        else
        {
            m_viewDelta = 0.0;
//          _super::SetPos(m_currentPos);
            KillTimer(TIMERID_MOVE);
        }
        if ( m_viewDelta != 0.0 )
        {
            //== デルタがある。
            //TRACE1("delta = %.4f\n", m_viewDelta);
            if ( m_maxDelta > 0.0 )
            {
                if ( ::fabs(m_viewDelta) > ::fabs(m_maxDelta) )
                {
                    bool m = (m_viewDelta > 0.0);
                    m_viewDelta = m ? m_maxDelta : -m_maxDelta;
                }
            }
            m_viewPos += m_viewDelta;
            if ( m_viewPos < m_lower )
            {
                m_viewPos = m_lower;
            }
            if ( m_viewPos > m_upper )
            {
                m_viewPos = m_upper;
            }
            _super::SetPos(ToInt(m_viewPos + 0.005));
        }
    }
 
private:
    enum { TIMERID_MOVE = 1 };
    double  m_viewPos;          
    double  m_viewDelta;        
    double  m_maxDelta;         
    int     m_currentPos;       
    int     m_step;             
    int     m_lower;            
    int     m_upper;            
};
 
 
 
typedef CSmoothProgressCtrlT<> CSmoothProgressCtrl;
 
 
 
};
};