TnbMfcRgnButton.h

[詳解]

#pragma once
#include "TnbMfcAbstractButton.h"
#include "TnbBitmapImage.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CRgnButton : public CAbstractButton
{
    DEFSUPER(CAbstractButton);
    CSize               m_size;             
    COLORREF            m_transColor;       
    HRGN                m_hRgnClip;         
    HRGN                m_hRgnCtrl;         
    bool                m_boIsDoSetRgn;     
    CBitmapImage        m_lastBitmap;       
    UINT                m_bitmapChangeTime; 
    CPoint              m_pushedOffset;     
    enum { TIMERID_DRAW = 1 };
    void m_DeleteRgn(HRGN& _hRgn)
    {
        if ( _hRgn != NULL )
        {
            _DeleteObject(_hRgn);
            _hRgn = NULL;
        }
    }
    void m_DeleteRgns(void)
    {
        if ( ::IsWindow(m_hWnd) )
        {
            _super::SetWindowRgn(NULL, false);
        }
        m_DeleteRgn(m_hRgnClip);
        m_DeleteRgn(m_hRgnCtrl);
    }
    void m_SetRgn(HRGN& _hRgn, HRGN h)
    {
        m_DeleteRgn(_hRgn);
        _hRgn = ::CreateRectRgn(0, 0, 1, 1);
        ::CombineRgn(_hRgn, h, NULL, RGN_COPY);
    }
    bool m_SetBaseBitmap(CBitmapHandle h, COLORREF color)
    {
        if ( h.GetSize(m_size) )
        {
            m_DeleteRgns();
            CBitmapImage bi;
            bi.Attach(h);
            m_hRgnClip = bi.CreateRgn(color);
            m_SetRgn(m_hRgnCtrl, m_hRgnClip);
            m_boIsDoSetRgn = true;
            _super::SetWindowPos(NULL, 0, 0, m_size.cx, m_size.cy, SWP_NOZORDER | SWP_NOMOVE);
            _super::SetWindowRgn(NULL, true);
            return true;
        }
        return false;
    }
    void m_DrawBmp(CDC* pDC, CBitmapHandle hb)
    {
        if ( hb == NULL ) { return; }
        CPoint pos1(0, 0);
        CPoint pos2((_super::GetButtonState() == ES_Pushed) ? m_pushedOffset : pos1);
        OnDrawingButton(pos2, pDC, true);
        MFCLIB::SelectClipRgnOrg(pDC, m_hRgnClip);
//      pDC->DrawState(pos1, m_size, hb, DST_BITMAP);
        hb.Draw(*pDC, pos1.x, pos1.y);
        OnDrawingButton(pos2, pDC, false);
        if ( m_focusMaskColor != CLR_INVALID )
        {
            if ( _super::HasFocus() && ! m_focusBitmap.IsEmpty() )
            {
                const SIZE& s = m_focusBitmap.GetSize();
                HDC hdc = m_focusBitmap.GetDC();
                ::TransparentBlt(*pDC, pos2.x, pos2.y, s.cx, s.cy, hdc, 0, 0, s.cx, s.cy, m_focusMaskColor);
                m_focusBitmap.ReleaseDC();
            }
        }
    }
 
protected:
 
    CBitmapHandle       m_bmpButtons[4];    
    CBitmapImage        m_focusBitmap;      
    COLORREF            m_focusMaskColor;   
 
    virtual void OnDrawingButton(CPoint& _pos, CDC* pDC, bool boIsFirst)
    {
    }
 
    virtual void OnDrawButton(CDC* pDC)
    {
        CBitmapHandle hb = m_bmpButtons[_super::GetButtonState()];
        if ( hb.IsNull() )
        {
            hb = m_bmpButtons[ES_Normal];
        }
        if ( m_focusMaskColor == CLR_INVALID )
        {
            //フォーカスは、イメージ
            if ( _super::GetButtonState() == ES_Normal && _super::HasFocus() && ! m_focusBitmap.IsEmpty() )
            {
                hb = m_focusBitmap.GetBitmapHandle();
            }
        }
        _super::KillTimer(TIMERID_DRAW);
        if ( m_lastBitmap.IsEmpty() )
        {
            m_lastBitmap.Attach(hb);
            m_DrawBmp(pDC, hb);
        }
        else if ( m_bitmapChangeTime == 0 || hb.IsNull() )
        {
            m_DrawBmp(pDC, hb);
        }
        else
        {
            CBitmapImage bi;
            VERIFYLIB( bi.Set(hb) );
//          VERIFYLIB( bi.InsertOnSemitransparect(0, 0, m_lastBitmap, 50) );//50%合成
            VERIFYLIB( bi.InsertOnAlphaBlend(0, 0, m_lastBitmap, 50) );//50%合成
            m_DrawBmp(pDC, bi.GetBitmapHandle());
            m_lastBitmap.Attach(hb);
            _super::SetTimer(TIMERID_DRAW, m_bitmapChangeTime, NULL);
        }
    }
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        if ( message == WM_PAINT )
        {
            if ( m_boIsDoSetRgn )
            {
                m_boIsDoSetRgn = false;
                _super::SetWindowRgn(m_hRgnCtrl, true);
                m_hRgnCtrl = NULL;  // 開放はWinが行う
                _super::RedrawWindow();
                return 0;
            }
        }
        else if ( message == WM_SHOWWINDOW )
        {
            m_lastBitmap.Empty();
        }
        else if ( message == WM_DESTROY )
        {
            m_DeleteRgns();
        }
        else if ( message == WM_SETTEXT )
        {
            CString s = reinterpret_cast<LPCTSTR>(lParam);
            int f = s.Find('&');
            if ( f >= 0 && (f + 1) < s.GetLength() )
            {
                SetShortcutKey(s[f + 1]);
            }
        }
        else if ( message == WM_TIMER && wParam == TIMERID_DRAW )
        {
            KillTimer(TIMERID_DRAW);
            CClientDC dc(this);
            m_DrawBmp(&dc, m_lastBitmap.GetBitmapHandle());
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
    virtual void PreSubclassWindow(void)
    {
        HBITMAP hBase = reinterpret_cast<HBITMAP>(::SendMessage(m_hWnd, STM_GETIMAGE, IMAGE_BITMAP, 0L));// GetBitmap()
        if ( ! m_bmpButtons[ES_Normal].IsNull() )
        {
            if ( ! m_SetBaseBitmap(m_bmpButtons[ES_Normal], m_transColor) )
            {
                m_bmpButtons[ES_Normal].Null();
            }
        }
        if ( m_bmpButtons[ES_Normal].IsNull() )
        {
            CRect rect;
            _super::GetClientRect(rect);
            if ( hBase == NULL )
            {
                HDC dc = ::GetDC(NULL);
                hBase = ::CreateCompatibleBitmap(dc, rect.Width(), rect.Height());
                ::ReleaseDC(NULL, dc);
                m_bmpButtons[ES_Normal] = hBase;
            }
            else
            {
                m_bmpButtons[ES_Normal].SetClone(hBase);
            }
            VERIFYLIB( m_SetBaseBitmap(m_bmpButtons[ES_Normal], m_transColor) );
        }
        _super::PreSubclassWindow();
    }
 
public:
 
    virtual ~CRgnButton(void)
    {
        m_DeleteRgns();
    }
 
    CRgnButton(void) 
        : m_boIsDoSetRgn(false), m_hRgnClip(NULL), m_hRgnCtrl(NULL), m_pushedOffset(0, 0)
        , m_transColor(CLR_AUTOSELECT), m_focusMaskColor(CLR_INVALID), m_bitmapChangeTime(40)
    {
    }
 
    CRgnButton& operator=(const CRgnButton& other)
    {
        _super::operator=(other);
        m_size = other.m_size;
        m_transColor = other.m_transColor;
        m_boIsDoSetRgn = other.m_boIsDoSetRgn;
        m_lastBitmap = other.m_lastBitmap;
        m_bitmapChangeTime = other.m_bitmapChangeTime;
        m_pushedOffset = other.m_pushedOffset;
        m_focusBitmap = other.m_focusBitmap;
        m_focusMaskColor = other.m_focusMaskColor;
        loop ( i, 4 )
        {
            m_bmpButtons[i] = other.m_bmpButtons[i];
        }
        m_SetRgn(m_hRgnClip, other.m_hRgnClip);
        if ( ! ::IsWindow(other) )
        {
            m_SetRgn(m_hRgnCtrl, other.m_hRgnCtrl);
        }
        else
        {
            other.GetWindowRgn(m_hRgnCtrl);
        }
        //
        if ( ::IsWindow(m_hWnd) ) 
        {
            m_SetBaseBitmap(m_bmpButtons[ES_Normal], m_transColor);
        }
        return *this;
    }
 
    void SetBitmapChangeTime(UINT ms)
    {
        m_bitmapChangeTime = ms;
    }
 
    bool SetBitmap(CBitmapHandle bmp, COLORREF color = CLR_AUTOSELECT)
    {
        if ( bmp.IsNull() ) { return false; }
        m_bmpButtons[ES_Normal] = bmp;
        m_transColor = color;
        if ( ::IsWindow(m_hWnd) ) 
        {
            if ( ! m_SetBaseBitmap(bmp, color) )
            {
                return false;
            }
        }
        return true;
    }
 
    void SetPushedBitmap(CBitmapHandle bmp)
    {
        m_bmpButtons[ES_Pushed] = bmp;
    }
 
    void SetDisableBitmap(CBitmapHandle bmp)
    {
        m_bmpButtons[ES_Disable] = bmp;
    }
 
    void SetHoverBitmap(CBitmapHandle bmp)
    {
        m_bmpButtons[ES_Hover] = bmp;
    }
 
    void SetFocusBitmap(CBitmapHandle bmp)
    {
        m_focusBitmap.Set(bmp);
        m_focusMaskColor = CLR_INVALID;
    }
 
    void SetFocusMarkBitmap(CBitmapHandle bmp, COLORREF color = CLR_AUTOSELECT)
    {
        m_focusBitmap.Set(bmp);
        if ( ! IS_RGBVALUE(color) )
        {
            const SIZE& s = m_focusBitmap.GetSize();
            HDC dc = m_focusBitmap.GetDC();
            color = ::GetPixel(dc, 0, s.cy - 1);
            m_focusBitmap.ReleaseDC();
        }
        m_focusMaskColor = color;
    }
 
    void SetPushedMarkOffset(const POINT& pos)
    {
        m_pushedOffset = pos;
    }
 
    bool SetAllBitmaps(CBitmapHandle bmp, COLORREF color = CLR_AUTOSELECT)
    {
        CBitmapImage baseImage;
        if ( baseImage.Set(bmp) )
        {
            CSize baseSize = baseImage.GetSize();
            bool r = true;
            int x = 0;
            int l = baseSize.cx / 5;
            CBitmapImage bi;
            for ( int i = 0; i < 5; i++ )
            {
                bi = baseImage.Cut(CRect(x, 0, x + l, baseSize.cy));
                if ( i == 0 )
                {
                    r &= SetBitmap(bi, color);
                }
                else if ( i == 4 )
                {
                    SetFocusBitmap(bi);
                }
                else
                {
                    m_bmpButtons[i] = bi;
                }
                x += l;
            }
            return r;
        }
        return false;
    }
 
    void SetValidRgn(HRGN h)
    {
        m_DeleteRgn(m_hRgnClip);
        m_SetRgn(m_hRgnCtrl, h);
        m_boIsDoSetRgn = true;
        _super::RedrawWindow();
    }
};
 
 
 
}; //MFC
}; //TNB