TnbMfcAbstractButton.h

[詳解]

#pragma once
#include "TnbMfcCommon.h"
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
#define BN_PUSHED_T         0x100
#define BN_UNPUSHED_T       0x101
#endif
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CAbstractButton : public CWnd
{
    DEFSUPER(CWnd);
public:
 
    CAbstractButton(void) 
        : m_shortcutKey(0), m_pushState(EP_Non), m_boHasHover(false)
        , m_nowState(ES_Normal), m_lastState(EState(-1)), m_hFont(NULL), m_boInBmClick(false)
        , m_boIsOnClickDisp(false), m_canSendDblClk(false), m_pressedMode(PM_Unused)
    {
    }
 
    CAbstractButton& operator=(const CAbstractButton& other)
    {
        m_shortcutKey = other.m_shortcutKey;
        m_hFont = other.m_hFont;
        return *this;
    }
 
    virtual ~CAbstractButton(void)
    {
    }
 
    void SetShortcutKey(TCHAR key)
    {
        m_shortcutKey = key;
    }
 
    void SetDefaultButtonStyle(void)
    {
        CWnd* P = _super::GetParent();
        if ( P != NULL ) 
        {
            P->SendMessage(DM_SETDEFID, _super::GetDlgCtrlID(), 0);
        }
    }
 
    UINT GetState(void) const
    {
        ASSERT(::IsWindow(m_hWnd));
        return static_cast<UINT>(::SendMessage(m_hWnd, BM_GETSTATE, 0, 0));
    } 
 
    enum EPressMode
    {
        PM_Unused,      
        PM_Message,     
        PM_Lockable,    
    };
 
    void SetPressedMode(bool isEnable)
    {
        m_pressedMode = isEnable ? PM_Lockable : PM_Unused;
    }   
    
    void SetPressedMode(EPressMode pm)
    {
        m_pressedMode = pm;
    }
 
protected:
    
    enum EState 
    {
        ES_Normal,              
        ES_Hover,               
        ES_Pushed,              
        ES_Disable,             
    };
 
    EState GetButtonState(void) const
    {
        return m_nowState;
    }
 
    void SetButtonState(EState s)
    {
        m_nowState = s;
    }
 
    void SetSendDblClkMode(bool canSendDblClk)
    {
        m_canSendDblClk = canSendDblClk;
    }
 
    virtual void OnDrawButton(CDC* pDC) = 0;
 
    virtual bool IsOnButton(const POINT& po) const
    {
        return ::WindowFromPoint(po) == m_hWnd;
    }
 
    virtual EState OnCheckState(EState st)
    {
        if ( m_IsAlive() )
        {
            if ( ! _super::IsWindowEnabled() )
            {
                st = ES_Disable;
            }
            else if ( m_pushState == EP_Mouse )
            {
                st = ES_Pushed;
                CPoint po = m_curpos;
                ClientToScreen(&po);
                if ( ! IsOnButton(po) )
                {
                    st = ES_Normal;
                }
            }
            else if ( m_pushState != EP_Non )
            {
                st = ES_Pushed;
            }
            else if ( m_boHasHover )
            {
                st = ES_Hover;
            }
            else
            {
                st = ES_Normal;
            }
        }
        return st;
    }
 
    virtual bool HasFocus(void) const
    {
        return ::GetFocus() == m_hWnd;
    }
 
    virtual void OnClickButton(void)
    {
    }
 
    virtual void OnChangeState(EState state)
    {
    }
 
    virtual BOOL OnChildNotify(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* _pResult)
    {
        if ( message == WM_COMMAND && lParam == reinterpret_cast<LPARAM>(m_hWnd) )
        {
            ASSERTLIB( (wParam & 0xFFFF) == static_cast<WPARAM>(GetDlgCtrlID()) );
            ASSERTLIB( (BN_CLICKED * 0x10000) == 0 );
            if ( (wParam & 0xFFFF0000) == 0 )
            {
                if ( ! m_boIsOnClickDisp )
                {
                    OnClickButton();
                }
                else
                {
                    m_boIsOnClickDisp = false;
                }
            }
        }
        return _super::OnChildNotify(message, wParam, lParam, _pResult);
    }
    
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        switch ( message )
        {
        case 0x0128/*WM_UPDATEUISTATE*/:
            TTRACE0("WM_UPDATEUISTATE\n");
            return 0;
        case WM_ERASEBKGND:
            TTRACE0("WM_ERASEBKGND\n");
            return 0;
        case WM_PRINTCLIENT:
            TTRACE0("WM_PRINTCLIENT\n");
            {
                CDC* pDC = CDC::FromHandle(reinterpret_cast<HDC>(wParam));
                if ( pDC != NULL )
                {
                    OnDrawButton(pDC);
                }
            }
            return 0;
        case WM_PAINT:
            TTRACE0("WM_PAINT\n");
            {
                CPaintDC dc(this); // 描画用のデバイス コンテキスト
                OnDrawButton(&dc);
            }
            return 0;
        case 0x031A/*WM_THEMECHANGED*/:
            OnChangeState(m_nowState);
            break;
        case WM_SETFOCUS:
            TTRACE0("WM_SETFOCUS\n");
            OnChangeState(m_nowState);
            m_RedrawWindow();
            return 0;
        case WM_KILLFOCUS:
            TTRACE0("WM_KILLFOCUS\n");
            if ( m_pushState != EP_Non && ! m_IsPressedLockMode() )
            {
                m_pushState = EP_Non;
                ::ReleaseCapture();
                m_HoverOff(false);
                m_CheckNowState(false);
                m_RedrawWindow();
            }
            else
            {
                OnChangeState(m_nowState);
            }
            m_RedrawWindow();
            return 0;
        case WM_GETDLGCODE:
            TTRACE0("WM_GETDLGCODE\n");
            if ( HasFocus() )
            {
                return DLGC_DEFPUSHBUTTON | DLGC_BUTTON;
            }
            return DLGC_UNDEFPUSHBUTTON | DLGC_BUTTON;
        case WM_GETTEXTLENGTH:
            TTRACE0("WM_GETTEXTLENGTH\n");
            if ( m_shortcutKey != 0 )
            {
                return 2 * sizeof(TCHAR);
            }
            break;
        case WM_GETTEXT:
            TTRACE0("WM_GETTEXT\n");
            if ( m_shortcutKey != 0 && wParam >= 2 )
            {
                TCHAR* P = reinterpret_cast<TCHAR*>(lParam);
                *P++ = '&';
                *P++ = m_shortcutKey;
                return 2;
            }
            break;
        case WM_KEYDOWN:
            TTRACE2("WM_KEYDOWN 0x%04X,0x%04X\n",wParam,lParam);
            if ( wParam == ' ' )
            {
                m_Push(EP_Key);
            }
            return 0;
        case WM_KEYUP:
            TTRACE2("WM_KEYUP 0x%04X,0x%04X\n",wParam,lParam);
            if ( wParam == ' ' )
            {
                m_Unpush(EP_Key);
                if ( m_IsPressedLockMode() )
                {
                    m_Unpush(EP_Mouse);
                }
            }
            return 0;
        case WM_LBUTTONDOWN:
            TTRACE0("WM_LBUTTONDOWN\n");
//          m_curpos.x = LOWORD(lParam);
//          m_curpos.y = HIWORD(lParam);
            m_curpos = CPoint(lParam);
            m_Push(m_boInBmClick ? EP_Key : EP_Mouse);
            return 0;
        case WM_LBUTTONUP:
            TTRACE0("WM_LBUTTONUP\n");
            m_Unpush(m_boInBmClick ? EP_Key : EP_Mouse);
            return 0;
        case WM_LBUTTONDBLCLK:
            TTRACE0("WM_LBUTTONDBLCLK\n");
            if ( ! m_canSendDblClk )
            {
                m_Push(EP_Mouse);
            }
            else
            {
                m_SendCommand(BN_DBLCLK/*BN_DOUBLECLICKED*/);
            }
            return 0;
        case WM_MOUSEMOVE:
            TTRACE1("WM_MOUSEMOVE %X\n", lParam);
            m_curpos = CPoint(lParam);
            if ( ! m_boHasHover && m_pushState == EP_Non )
            {
                m_HoverOn(true);
            }
            else
            {
                m_CheckNowState(true);
            }
            break;
        case WM_ENABLE:
            TTRACE0("WM_ENABLE\n");
            m_CheckNowState(true);
            return 0;
        case WM_GETFONT:
            TTRACE0("WM_GETFONT\n");
            {
                HFONT f = m_hFont;
                if ( f == NULL )
                {
                    f = reinterpret_cast<HFONT>(::SendMessage(::GetParent(m_hWnd), WM_GETFONT, 0, 0));
                }
                if ( f == NULL )
                {
                    f = reinterpret_cast<HFONT>(::GetStockObject(SYSTEM_FONT));
                }
                return reinterpret_cast<LRESULT>(f);
            }
            break;
        case WM_SETFONT:
            TTRACE0("WM_SETFONT\n");
            m_hFont = reinterpret_cast<HFONT>(wParam);
            if ( lParam != 0 )
            {
                m_RedrawWindow();
            }
            return 0;
        case WM_DESTROY:
            TTRACE0("WM_DESTROY\n");
            m_pushState = EP_Non;
            m_boHasHover = false;
            SetButtonState(ES_Normal);
            m_lastState = static_cast<EState>(-1);
            m_hFont = NULL;
            m_boInBmClick = false;
            m_boIsOnClickDisp = false;
            break;
        case BM_CLICK:
            TTRACE0("BM_CLICK\n");
            {
                m_boInBmClick = true;
                LRESULT r = _super::WindowProc(message, wParam, lParam);
                m_boInBmClick = false;
                return r;
            }
            break;
        case BM_GETSTATE:
            TTRACE0("BM_GETSTATE\n");
            {
                UINT r = 0;
                r |= (m_nowState == ES_Pushed) ? BST_PUSHED : 0;//強調
                r |= HasFocus() ? BST_FOCUS : 0;//フォーカス
                return r;
            }
            break;
        case BM_SETSTATE:
            TTRACE0("BM_SETSTATE\n");
            if ( wParam == 0 )
            {
                m_Unpush(EP_Message);
            }
            else
            {
                m_Push(EP_Message);
            }
            return 0;
        case 0x02A1/*WM_MOUSEHOVER*/:
            TTRACE0("WM_MOUSEHOVER\n");
            m_HoverOn(true);
            break;
        case 0x02A3/*WM_MOUSELEAVE*/:
            TTRACE0("WM_MOUSELEAVE\n");
            if ( m_boHasHover )
            {
                m_HoverOff(true);
            }
            else
            {
                m_CheckNowState(true);
            }
            break;
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
    virtual void PreSubclassWindow(void)
    {
        _super::ModifyStyle(0, SS_NOTIFY);
        _super::PreSubclassWindow();
        m_CheckNowState(false);
    }
 
private:
    enum EPush
    {
        EP_Non,     
        EP_Mouse,   
        EP_Key,     
        EP_Message  
    };
    EPush       m_pushState;            
    bool        m_boHasHover;           
    bool        m_boInBmClick;          
    bool        m_boIsOnClickDisp;      
    TCHAR       m_shortcutKey;          
    HFONT       m_hFont;                
    bool        m_canSendDblClk;        
    EState      m_nowState;             
    EState      m_lastState;            
    CPoint      m_curpos;               
    EPressMode  m_pressedMode;          
    bool m_WithPressedMessage(void) const
    {
        return m_pressedMode != PM_Unused;
    }
    bool m_IsPressedLockMode(void) const
    {
        return m_pressedMode == PM_Lockable;
    }
    bool m_IsAlive(void) const
    {
        return !! ::IsWindow(GetSafeHwnd());
    }
    void m_SendCommand(UINT uCmd)
    {
        if ( m_IsAlive() )
        {
            MFCLIB::SendCommandMessage(this, uCmd);
        }
    }
    void m_RedrawWindow(void)
    {
        if ( m_IsAlive() )
        {
            _super::RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE);
        }
    }
    void m_CheckNowState(bool boRedraw)
    {
        if ( m_IsAlive() )
        {
            SetButtonState(OnCheckState(m_nowState));
            if ( m_nowState != m_lastState )
            {
                m_lastState = m_nowState;
                OnChangeState(m_nowState);
                if ( boRedraw )
                {
                    m_RedrawWindow();
                }
            }
        }
    }
    void m_HoverOn(bool boRedraw)
    {
        #ifndef _WIN32_WCE
        if ( ! m_boHasHover )
        {
            m_boHasHover = true;
            m_CheckNowState(boRedraw);
            m_SendCommand(BN_HILITE);
            m_HoverSub();
        }
        #endif
    }
    void m_HoverOff(bool boRedraw)
    {
        #ifndef _WIN32_WCE
        if ( m_boHasHover )
        {
            m_boHasHover = false;
            m_CheckNowState(boRedraw);
            m_SendCommand(BN_UNHILITE);
        }
        #endif
    }
    void m_Push(EPush ep)
    {
        if ( ! m_IsAlive() ) { return; }
        if ( m_pushState == EP_Non )
        {
            m_pushState = ep;
            if ( ! m_IsPressedLockMode() )
            {
                _super::SetCapture();
                if ( m_WithPressedMessage() )
                {
                    m_SendCommand(BN_PUSHED_T);
                }
            }
            else
            {
                m_SendCommand(BN_PUSHED_T);
            }
            m_CheckNowState(true);
        }
        _super::SetFocus();
    }
    void m_Unpush(EPush ep)
    {
        if ( ! m_IsAlive() ) { return; }
        if ( m_pushState != ep ) { return; }
        m_pushState = EP_Non;
        ::ReleaseCapture();
        if ( ep != EP_Message ) 
        {
            CPoint po = m_curpos;
            ClientToScreen(&po);
            bool onButton = IsOnButton(po);
            if ( ep == EP_Key || onButton )
            {
                m_boIsOnClickDisp = true;
                OnClickButton();
                if ( ! m_IsAlive() ) { return; }
                #ifdef _WIN32_WCE
                    m_CheckNowState(false);
                    m_RedrawWindow();
                    if ( m_IsPressedLockMode() || m_WithPressedMessageMode() )
                    {
                        m_SendCommand(BN_UNPUSHED_T);
                    }
                    m_SendCommand(BN_CLICKED);
                    return;
                #endif
                if ( m_IsPressedLockMode() || m_WithPressedMessage() )
                {
                    m_SendCommand(BN_UNPUSHED_T);
                }
                m_SendCommand(BN_CLICKED);
            }
            if ( ! onButton )
            {
                m_HoverOff(false);
            }
        }
        m_CheckNowState(false);
        m_RedrawWindow();
    }
    void m_HoverSub(void)
    {
        #ifndef _WIN32_WCE
        TRACKMOUSEEVENT tme;
        tme.cbSize = sizeof (TRACKMOUSEEVENT);
        tme.hwndTrack = m_hWnd;
        tme.dwHoverTime = HOVER_DEFAULT;
        tme.dwFlags = TME_HOVER | TME_LEAVE;
        ::_TrackMouseEvent(&tme);
        #endif
    }
};
 
 
 
}; //MFC
}; //TNB