TnbMfcMarqueeStatic.h

[詳解]

#pragma once
#include "TnbMfcCommon.h"
#include "TnbBitmapDrawer.h"
#include "TnbTextDrawer.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CMarqueeStatic : public CWnd
{
    DEFSUPER(CWnd);
public:
 
    CMarqueeStatic(void) : _super(), m_margin(0, 0), m_mode(Mode_Scroll)
        , m_direction(LEFT), m_amount(6), m_delay(85)
        , m_backColor(RGB(0, 0, 0)), m_withBackDraw(true)
    {
    }
 
    void SetMargin(size_t cx, size_t cy)
    {
        m_margin.cx = cx;
        m_margin.cy = cy;
        if ( ::IsWindow(_super::GetSafeHwnd()) )
        {
            CRect rc;
            _super::GetClientRect(&rc);
            m_clientSize = rc.Size() - m_margin - m_margin;
            m_Reset();
        }
    }
 
    enum EMode
    {
        Mode_Scroll,    
        Mode_Slide,     
    };
 
    void SetMode(EMode mode)
    {
        m_mode = mode;
        m_Reset();
    }
    
    enum EDirection
    {
        LEFT,       
        RIGHT,      
        UP,         
        DOWN,       
        IMMOVALE,   
    };
 
    void SetDirection(EDirection d)
    {
        m_direction = d;
        m_Reset();
    }
 
    void SetSpeed(DWORD amount, DWORD delay)
    {
        m_amount = amount;
        m_delay = delay;
        if ( ::IsWindow(GetSafeHwnd()) )
        {
            SetTimer(TIMERID_MARQUEE, m_delay, NULL);
        }
    }
 
    void SetBackColor(COLORREF c)
    {
        m_backColor = c;
        m_Reset();
    }
 
    void SetDrawingObject(const IDrawable& draw, bool withBackDraw = true)
    {
        m_withBackDraw = withBackDraw;
        m_pDrawing = draw.Clone();
        if ( ! m_pDrawing.IsNull() )
        {
            m_pDrawing->GetSize(m_drawingSize);
        }
        m_Reset();
    }
 
    void SetDrawingBitmap(CBitmapHandle bmp)
    {
        SetDrawingObject(CBitmapDrawer(bmp), true);
    }
 
    void SetDrawingText(HFONT font, COLORREF textColor, LPCTSTR lpszText, DWORD style = DT_CENTER | DT_VCENTER, int margin = 0)
    {
        CTextBkDrawer d(font, textColor, m_backColor, lpszText, style, margin);
        d.AdjustSize();
        SetDrawingObject(d, true);
    }
 
protected:
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        switch ( message )
        {
        case WM_ERASEBKGND:
            TTRACE0("WM_ERASEBKGND\n");
            return 0;
        case WM_PRINTCLIENT:
            TTRACE0("WM_PRINTCLIENT\n");
            {
                CDC* pDC = CDC::FromHandle(reinterpret_cast<HDC>(wParam));
                m_Draw(pDC);
            }
            return 0;
        case WM_PAINT:
            TTRACE0("WM_PAINT\n");
            {
                CPaintDC dc(this); // 描画用のデバイス コンテキスト
                m_Draw(&dc);
            }
            return 0;
        case WM_ENABLE:
            TTRACE0("WM_ENABLE\n");
            return 0;
        case WM_TIMER:
            if ( wParam == TIMERID_MARQUEE )
            {
                if ( _super::IsWindowVisible() )
                {
                    m_Next();
                    _super::RedrawWindow();
                }
            }
            break;
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
    virtual void PreSubclassWindow(void)
    {
        _super::ModifyStyle(0, SS_OWNERDRAW);
        _super::PreSubclassWindow();
        SetTimer(TIMERID_MARQUEE, m_delay, NULL);
        CRect rc;
        _super::GetClientRect(&rc);
        m_clientSize = rc.Size() - m_margin - m_margin;
        m_isStarted = false;
    }
 
private:
 
    void m_Reset(void)
    {
        m_isStarted = false;
        if ( ::IsWindow(GetSafeHwnd()) )
        {
            SetTimer(TIMERID_MARQUEE, m_delay, NULL);
        }
    }
 
    void m_Draw(CDC* pDC)
    {
        if ( ! m_pDrawing.IsNull() )
        {
            CRect rc;
            _super::GetClientRect(&rc);
            pDC->IntersectClipRect(&rc);
            CPoint po = m_drawPoint + m_margin;
            if ( m_withBackDraw )
            {
                //背景も描画するDrawerだ
                m_pDrawing->Draw(*pDC, po.x, po.y);
                pDC->ExcludeClipRect(CRect(po, m_drawingSize));
                pDC->FillSolidRect(&rc, m_backColor);
            }
            else
            {
                //背景は書いてくれないDrawerだ
                pDC->FillSolidRect(&rc, m_backColor);
                m_pDrawing->Draw(*pDC, po.x, po.y);
            }
        }
    }
 
    // メンバの状態から、 m_drawPoint を更新する。
    void m_Next(void)
    {
        if ( ! m_isStarted )
        {
            // 開始！
            switch ( m_direction )
            {
            case LEFT: //右から開始
                m_drawPoint = CPoint(m_clientSize.cx + m_margin.cx, 0);
                break;
            case RIGHT: //左から開始
                m_drawPoint = CPoint(-m_drawingSize.cx - m_margin.cx, 0);
                break;
            case UP: //下から開始
                m_drawPoint = CPoint(0, m_clientSize.cy + m_margin.cy);
                break;
            case DOWN: //上から開始
                m_drawPoint = CPoint(0, -m_drawingSize.cy - + m_margin.cy);
                break;
            case IMMOVALE: //不動
                m_drawPoint = CPoint(0, 0);
                KillTimer(TIMERID_MARQUEE);
                break;
            }
            m_isStarted = true;
        }
        int w = (m_clientSize.cx - m_drawingSize.cx);
        int h = (m_clientSize.cy - m_drawingSize.cy);
        switch ( m_direction )
        {
        case LEFT: //左へ
            m_drawPoint.x -= m_amount;
            break;
        case RIGHT: //右へ
            m_drawPoint.x += m_amount;
            break;
        case UP: //上へ
            m_drawPoint.y -= m_amount;
            break;
        case DOWN: //下へ
            m_drawPoint.y += m_amount;
            break;
        }
        if ( m_mode == Mode_Scroll )
        {
            switch ( m_direction )
            {
            case LEFT: //左を超えたら右から
                if ( m_drawPoint.x < -m_drawingSize.cx ) 
                {
                    m_drawPoint.x = m_clientSize.cx + m_margin.cx; 
                }
                break;
            case RIGHT: //右を超えたら左から
                if ( m_drawPoint.x > m_clientSize.cx )
                {
                    m_drawPoint.x = -m_drawingSize.cx - m_margin.cx;
                }
                break;
            case UP: //上を超えたら下から
                if ( m_drawPoint.y < -m_drawingSize.cy ) 
                {
                    m_drawPoint.y = m_clientSize.cy + m_margin.cy;
                }
                break;
            case DOWN: //下を超えたら上から
                if ( m_drawPoint.y > m_clientSize.cy )
                {
                    m_drawPoint.y = -m_drawingSize.cy - m_margin.cy;
                }
                break;
            }
        }
        if ( m_mode == Mode_Slide )
        {
            bool isContinue = true;
            switch ( m_direction )
            {
            case LEFT: //左で終わり
                if ( m_drawPoint.x < 0 ) { m_drawPoint.x = 0; isContinue = false; }
                break;
            case RIGHT: //右で終わり
                if ( m_drawPoint.x > w ) { m_drawPoint.x = w; isContinue = false; }
                break;
            case UP: //上で終わり
                if ( m_drawPoint.y < 0 ) { m_drawPoint.y = 0; isContinue = false; }
                break;
            case DOWN: //下で終わり
                if ( m_drawPoint.y > h ) { m_drawPoint.y = h; isContinue = false; }
                break;
            }
            if ( ! isContinue )
            {
                KillTimer(TIMERID_MARQUEE);
            }
        }
    }
 
    enum
    {
        TIMERID_MARQUEE = 1,    
    };
 
    IDrawable::Ptr  m_pDrawing;     
    CSize           m_margin;       
    EMode           m_mode;         
    EDirection      m_direction;    
    DWORD           m_amount;       
    DWORD           m_delay;        
    COLORREF        m_backColor;    
    bool            m_withBackDraw; 
    // -- work
    CSize           m_drawingSize;  
    CSize           m_clientSize;   
    CPoint          m_drawPoint;    
    bool            m_isStarted;    
};
 
 
 
}; //MFC
}; //TNB