TnbMfcDipswButton.h

[詳解]

#pragma once
#include "TnbMfcDrawingStatic.h"
#include "TnbBitmapImage.h"
 
 
 
#define DIPSW_CHANGED_T         0x100
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CDipswButton : public CDrawingStatic
{
    DEFSUPER(CDrawingStatic);
public:
 
    enum EMagicColorCode
    {
        MCC0 = RGB(128, 0, 0),      
        MCC1 = RGB(255, 0, 0),      
        MCC2 = RGB(0, 0, 128),      
        MCC3 = RGB(0, 0, 255),      
        MCC4 = RGB(0, 128, 0),      
        MCC5 = RGB(0, 255, 0),      
        MCC6 = RGB(0, 128, 128),    
        MCC7 = RGB(0, 255, 255),    
    };
 
    CDipswButton(void) : m_value(0x00)
    {
    }
 
    void SetImage(CBitmapHandle b, COLORREF onColor = RGB(255, 255, 255), COLORREF offColor = RGB(1, 1, 1))
    {
        m_onColor = onColor;
        m_offColor = offColor;
        m_base = b;
        m_base.ToHaveRgbData();
        m_ResetBitmap();
    }
 
    BYTE GetValue(void) const
    {
        return m_value;
    }
 
    void SetValue(BYTE value)
    {
        m_value = value;
        if ( ::IsWindow(_super::GetSafeHwnd()) )
        {
            m_ResetBitmap();
        }
    }
 
protected:
 
    virtual void PreSubclassWindow(void)
    {
        _super::PreSubclassWindow();
        m_ResetBitmap();
    }
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        switch ( message )
        {
        case WM_LBUTTONDOWN:
        case WM_LBUTTONDBLCLK:
            {
                CPoint po(lParam);
                int z = m_CheckPoint(po);
                if ( z >= 0 )
                {
                    BYTE b = m_value;
                    m_value ^= _BIT(z);
                    if ( b != m_value )
                    {
                        m_ResetBitmap();
                        MFCLIB::SendCommandMessage(this, DIPSW_CHANGED_T);
                    }
                }
            }
            break;
        default:
            break;
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
private:
 
    int m_CheckPoint(CPoint po)
    {
        CSize sz = m_base.GetSize();
        if ( sz.cy <= po.y || sz.cx <= po.x )
        {
            return -1;
        }
        const RGBQUAD* pRgb = m_base.GetRgbDataPtr(po.y);
        RGBQUAD q = pRgb[po.x];
        switch ( RGB(q.rgbRed, q.rgbGreen, q.rgbBlue) )
        {
        case MCC0:
        case MCC1:
            return 0;
        case MCC2:
        case MCC3:
            return 1;
        case MCC4:
        case MCC5:
            return 2;
        case MCC6:
        case MCC7:
            return 3;
        default:
            break;
        }
        return -1;
    }
 
    void m_ResetBitmap(void)
    {
        CBitmapImage bi;
        bi.Set(m_base);
        COLORREF on = m_onColor;
        COLORREF of = m_offColor;
        bi.ChangePixelColor(MCC0, (m_value & _BIT(0)) ? on : of);
        bi.ChangePixelColor(MCC1, (m_value & _BIT(0)) ? of : on);
        bi.ChangePixelColor(MCC2, (m_value & _BIT(1)) ? on : of);
        bi.ChangePixelColor(MCC3, (m_value & _BIT(1)) ? of : on);
        bi.ChangePixelColor(MCC4, (m_value & _BIT(2)) ? on : of);
        bi.ChangePixelColor(MCC5, (m_value & _BIT(2)) ? of : on);
        bi.ChangePixelColor(MCC6, (m_value & _BIT(3)) ? on : of);
        bi.ChangePixelColor(MCC7, (m_value & _BIT(3)) ? of : on);
        _super::SetDrawingBitmap(bi, true, true);
    }
 
    CBitmapImage    m_base;         
    COLORREF        m_onColor;      
    COLORREF        m_offColor;     
    BYTE            m_value;        
};
 
 
 
}; //MFC
}; //TNB