TnbMfcProcessingCtrl.h

[詳解]

#pragma once
#include "TnbMfcCommon.h"
#include "TnbThread.h"
#include "TnbDrawable.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CProcessingCtrl : public CWnd , TNB::CThread::IRunner
{
    DEFSUPER(CWnd);
public:
 
    enum EMode
    {
        Mode_GotoRight, 
        Mode_RoundTrip, 
    };
 
    CProcessingCtrl(void) 
        : _super(), m_size(0, 0), m_colorMark(::GetSysColor(COLOR_HIGHLIGHT))
        , m_isActing(false), m_interval(10), m_step(1), m_colorBack(::GetSysColor(COLOR_BTNFACE))
        , m_markWidth(6), m_pos(0), m_mode(1)
    {
        m_thread.SetRunner(this);
    }
 
    ~CProcessingCtrl(void)
    {
        m_thread.Stop();
        m_DeleteDrawer();
    }
 
    void SetParameter(EMode mode, DWORD interval, int step = 6, COLORREF colorBack = CLR_INVALID)
    {
        m_mode = mode;
        m_interval = interval;
        m_step = step;
        m_colorBack = (colorBack != CLR_INVALID) ? colorBack : ::GetSysColor(COLOR_BTNFACE);
    }
 
    void SetMarker(COLORREF colorMark, int width)
    {
        Action(false);
        m_DeleteDrawer();
        m_colorMark = (colorMark != CLR_INVALID) ? colorMark : ::GetSysColor(COLOR_HIGHLIGHT);
        m_markWidth = width;
    }
 
    void SetMarker(const IDrawable& draw)
    {
        Action(false);
        m_DeleteDrawer();
        SIZE s;
        if ( draw.GetSize(s) )
        {
            m_piMarkerDrawer = draw.Clone();
            m_markWidth = s.cx;
        }
    }
 
    void Action(bool isAction)
    {
        m_isActing = isAction;
        m_thread.Stop();
        if ( isAction )
        {
            m_pos = 0;
            m_thread.Start(_T("ProcessingCtrl"));
        }
        RedrawWindow();
    }
 
    bool IsActing(void) const
    {
        return m_isActing;
    }
 
    CThreadStatus& ReferThreadStatus(void)
    {
        return m_thread;
    }
 
protected:
 
    virtual void PreSubclassWindow(void)
    {
        CRect rc;
        _super::GetClientRect(rc);
        m_size = rc.Size();
    }
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        if ( message == WM_PAINT )
        {
            CPaintDC dc(this); // 描画用のデバイス コンテキスト
            m_Draw(&dc);
            return 0;
        }
        else if ( message == WM_PRINTCLIENT )
        {
            CDC* pDc = CDC::FromHandle(reinterpret_cast<HDC>(wParam));
            m_Draw(pDc);
            return 0;
        }
        else if ( message == WM_DESTROY )
        {
            m_isActing = false;
            m_thread.Stop();
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
    DWORD Run(void)
    {
        while ( IsRunnable() )
        {
            ::Sleep(m_interval);
            if ( m_isActing )
            {
                if ( m_mode > 0 )
                {
                    m_pos += m_step;
                    if ( m_pos + m_markWidth > m_size.cx )
                    {
                        m_pos = m_size.cx - m_markWidth;
                        m_mode = -1;
                    }
                }
                else if ( m_mode < 0 )
                {
                    if ( m_pos >= m_step )
                    {
                        m_pos -= m_step;
                    }
                    else
                    {
                        m_mode = 1;
                        m_pos = 0;
                    }
                }
                else 
                {
                    m_pos += m_step;
                    if ( m_pos > m_size.cx )
                    {
                        m_pos = -m_markWidth;
                    }
                }
                if ( IsRunnable() )
                {
                    _super::Invalidate();
                }
            }
        }
        return 0;
    }
 
private:
    void m_DeleteDrawer(void)
    {
        m_piMarkerDrawer.Null();
    }
    void m_Draw(CDC* pDC)
    {
        CRect cliRect(CPoint(0, 0), m_size);
        HRGN rgn = ::CreateRectRgnIndirect(&cliRect);
        MFCLIB::SelectClipRgnOrg(pDC, rgn);
        _DeleteObject(rgn);
        if ( m_isActing )
        {
            CRect markRect(m_pos, 0, m_pos + m_markWidth, m_size.cy);
            if ( m_piMarkerDrawer.IsNull() )
            {
                pDC->FillSolidRect(markRect, m_colorMark);
            }
            else
            {
                m_piMarkerDrawer->Draw(*pDC, m_pos, 0);
            }
            HRGN rgn = ::CreateRectRgnIndirect(&markRect);
            MFCLIB::SelectClipRgnOrg(pDC, rgn, RGN_DIFF);
            _DeleteObject(rgn);
        }
        pDC->FillSolidRect(cliRect, m_colorBack);
        pDC->SelectClipRgn(NULL);
    }
    CThread         m_thread;           
    CSize           m_size;             
    COLORREF        m_colorBack;        
    bool            m_isActing;         
    DWORD           m_interval;         
    int             m_step;             
    COLORREF        m_colorMark;        
    IDrawable::Ptr  m_piMarkerDrawer;   
    int             m_markWidth;        
    int             m_pos;              
    int             m_mode;             
};
 
 
 
}; //MFC
}; //TNB