TnbMfcEditValue.h

[詳解]

#pragma once
#include "TnbMfcEditAscii.h"
#ifdef _WIN32_WCE
 #include "TnbCeMfcGesture.h"
#endif
 
#ifdef _WIN32_WCE
 #define _TnbEDIT_Spin_Horz
#endif
 
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
template<typename TYP, LONGLONG TMIN, LONGLONG TMAX>
class CEditValueT : public CEditAscii
{
    DEFSUPER(CEditAscii);
public:
 
    typedef TYP TYPE;   
 
    CEditValueT(void) 
        : _super(_T("-0123456789")), m_boOnPaint(false), m_iZeroPlace(0)
        , m_xMin(TMIN), m_xMax(TMAX), m_step(1)
    {
    }
 
    virtual ~CEditValueT(void)
    {
        if ( ::IsWindow(*this) )
        {
            _super::DestroyWindow();
        }
    }
 
    virtual CString ValueToString(TYPE xValue) const
    {
        LONGLONG l = AdjustValue(static_cast<LONGLONG>(xValue));
        return ToString(l);
    }
 
    virtual void SetValue(TYPE xValue)
    {
        _super::SetText(ValueToString(xValue));
    }
 
    virtual bool GetValue(TYPE& _xValue) const
    {
        CString s = m_lastText;//_super::GetText();
        if ( s.IsEmpty() )
        {
            return false;
        }
        _xValue = static_cast<TYPE>(AdjustValue(ToInteger(s)));
        return true;
    }
 
    TYPE GetValue(void) const
    {
        TYPE v;
        if ( GetValue(v) )
        {
            return v;
        }
        return TYPE();
    }
 
    void GetRange(TYPE& _xMin, TYPE& _xMax, TYPE& _step)
    {
        _xMin = static_cast<TYPE>(m_xMin);
        _xMax = static_cast<TYPE>(m_xMax);
        _step = static_cast<TYPE>(m_step);
    }
 
    virtual void SetRange(TYPE xMin, TYPE xMax, TYPE step = 0)
    {
        m_xMin = static_cast<LONGLONG>(xMin);
        m_xMax = static_cast<LONGLONG>(xMax);
        if ( m_xMin > m_xMax )
        {
            Swap(m_xMin, m_xMax);
        }
        if ( TMAX < m_xMax )
        {
            m_xMax = TMAX;
        }
        if ( TMIN > m_xMin )
        {
            m_xMin = TMIN;
        }
        if ( step <= 0 )
        {
            step = 1;
        }
        m_step = ToInt(step);
        OnChangeRange();
    }
 
    void SetPlace(int ii)
    {
        m_iZeroPlace = ii;
    }
 
    void AddSpinButton(int dummy = 0)
    {
        if ( ! ::IsWindow(m_spin) )
        {
            CRect rect;
            _super::GetClientRect(&rect);
            m_spinHeight = rect.Height();
            DWORD style = UDS_ALIGNRIGHT | UDS_ARROWKEYS | UDS_NOTHOUSANDS;
            #ifdef _TnbEDIT_Spin_Horz
                style |= UDS_HORZ;
            #endif
            m_spin.Create(style, rect, this, 1000);
            UDACCEL udacl[] = 
            {
                { 0,  1},   // 1づつ
                { 2,  5},   // 2秒後からは5づつ
                { 4, 10},   // 4秒後からは10づつ
                { 6, 50},   // 6秒後からは50づつ
            };
            m_spin.SetAccel(4, udacl);
            m_spin.SetRange(10000, -10000);
            m_spin.SetPos(0);
            m_AdjustSpinAndEdit();
        }
    }
 
protected:
 
    virtual BOOL OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* _pResult)
    {
        NMUPDOWN* pNmUpDown = reinterpret_cast<NMUPDOWN *>(lParam);
        if ( pNmUpDown->hdr.code == UDN_DELTAPOS )
        {
            if ( pNmUpDown->iDelta != 0 )
            {
                m_SetDelta(pNmUpDown->iDelta);
            }
            m_spin.SetPos(0);
            return TRUE;
        }
        return _super::OnNotify(wParam, lParam, _pResult);
    }
 
    #ifndef _WIN32_WCE
 
    virtual BOOL OnChildNotify(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* _pResult)
    {
        if ( message == WM_CTLCOLORSTATIC || message == WM_CTLCOLOREDIT )
        {
            if ( ::IsWindow(m_spin) && m_spin.IsWindowVisible() )
            {
                HDC dc = reinterpret_cast<HDC>(wParam);
                CPoint winPos(0, 0);
                if ( ! m_boOnPaint )
                {
                    _super::ClientToScreen(&winPos);
                }
                else
                {
                    m_boOnPaint = false;
                    CRect winRect;
                    _super::GetWindowRect(&winRect);
                    winPos = winRect.TopLeft();
                }
                CRect spinRect;
                m_spin.GetWindowRect(&spinRect);
                CPoint po = spinRect.TopLeft() - winPos;
                HRGN rgn = ::CreateRectRgnIndirect(CRect(po, spinRect.Size()));
                ::ExtSelectClipRgn(dc, rgn, RGN_DIFF);
                _DeleteObject(rgn);
            }
        }
        return _super::OnChildNotify(message, wParam, lParam, _pResult);
    }
 
    #endif //_WIN32_WCE
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        if ( ::IsWindow(m_spin) )
        {
            if ( message == WM_TIMER )
            {
                if ( lParam == TIMERID_SPIN_REPOS )
                {
                    KillTimer(TIMERID_SPIN_REPOS);
                    m_AdjustSpinAndEdit();
                }
            }
            else if ( message == 0x031A/*WM_THEMECHANGED*/ )
            {
                SetTimer(TIMERID_SPIN_REPOS, 1, NULL);
            }
            else if ( message == WM_MOUSEWHEEL )
            {
                short d = HIWORD(wParam);
                d /= 120;
                if ( d != 0 )
                {
                    m_SetDelta(-d);
                }
                return 0;
            }
            else if ( message == WM_KEYDOWN || message == WM_KEYUP )
            {
                if ( wParam == VK_DOWN || wParam == VK_UP )
                {
                    UINT msg = (message == WM_KEYDOWN) ? WM_LBUTTONDOWN : WM_LBUTTONUP;
                    #ifndef _TnbEDIT_Spin_Horz
                        int x = 0;
                        int y = (wParam == VK_DOWN) ? m_spinHeight - 1 : 0;
                    #else
                        int x = (wParam == VK_DOWN) ? m_spinHeight + 1 : 0;
                        int y = 0;
                    #endif
                    m_spin.SendMessage(msg, 0, MAKELONG(x, y));
                    return 0;
                }
                #ifdef _WIN32_WCE
                    if ( message == WM_KEYDOWN && (wParam == VK_LEFT || wParam == VK_RIGHT) )
                    {
                        DWORD s1 = GetSel();
                        LRESULT r = _super::WindowProc(message, wParam, lParam);
                        CWnd* pPrev = GetParent();
                        if ( s1 == GetSel() && pPrev != NULL )
                        {
                            CWnd* P = pPrev->GetNextDlgTabItem(this, (wParam == VK_LEFT));
                            if ( P != NULL )
                            {
                                LRESULT cd = P->SendMessage(WM_GETDLGCODE);
                                if ( (cd & DLGC_HASSETSEL) != 0 )
                                {
                                    P->SendMessage(EM_SETSEL, 0, 0x7FFFFFFE);
                                }
                                P->SetFocus();
                            }
                        }
                        return r;
                    }
                #endif //_WIN32_WCE
            }
            else if ( message == WM_PAINT || message == WM_PRINT )
            {
                m_boOnPaint = true;
                LRESULT r = _super::WindowProc(message, wParam, lParam);
                m_spin.RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW);
                return r;
            }
            else if ( message == WM_DESTROY )
            {
                m_spin.SetParent(GetParent());
            }
            else if ( message == WM_PRINTCLIENT )
            {
                #ifndef _WIN32_WCE
                    LRESULT r = _super::WindowProc(message, wParam, lParam);
                    if ( m_spin.IsWindowVisible() )
                    {
                        HDC dc = reinterpret_cast<HDC>(wParam);
                        CPoint winPos(0, 0);
                        _super::ClientToScreen(&winPos);
                        CPoint clientPos(0, 0);
                        m_spin.ClientToScreen(&clientPos);
                        CPoint orgOrg;
                        ::GetWindowOrgEx(dc, &orgOrg);
                        CPoint po = orgOrg - (clientPos - winPos);
                        ::SetWindowOrgEx(dc, po.x, po.y, NULL);
                        m_spin.SendMessage(WM_PRINT, wParam, lParam);
                        ::SetWindowOrgEx(dc, orgOrg.x, orgOrg.y, NULL);
                    }
                    return r;
                #endif //_WIN32_WCE
            }
            else if ( message == EM_SETREADONLY )
            {
                m_spin.EnableWindow(wParam == 0);
            }
            else if ( message == WM_ENABLE )
            {
                m_spin.EnableWindow(wParam != 0);
            }
            else if ( message == WM_GETDLGCODE )
            {
                #ifdef _WIN32_WCE
                    return _super::WindowProc(message, wParam, lParam) | DLGC_WANTARROWS;
                #endif
            }
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
    virtual bool IsValidChar(UINT& _nChar, LONG& _lFlags, const CString& strNowText)
    {
        if ( _nChar == '-' )
        {
            if ( m_xMin >= 0 )
            {
                return false;
            }
            DWORD g =_super::GetSel();
            if ( strNowText.Find('-') >= 0 )
            {
                if ( LOWORD(g) == 0 && HIWORD(g) > 0 )
                {
                    return true;
                }
                return false;
            }
            return LOWORD(g) == 0;
        }
        return _super::IsValidChar(_nChar, _lFlags, strNowText);
    }
 
    virtual void OnUpdateChar(void)
    {
        m_lastText = _super::GetText();     //変更状態を記憶しておく
        LONGLONG i = ToInteger(m_lastText);
        LONGLONG ii = i;
        if ( i > m_xMax )
        {
            i = m_xMax;
            if ( m_step != 1 )
            {
                i -= (i % m_step);
            }
            _super::SetText(ToString(i), true);
            if ( i != ii )
            {
                ::MessageBeep(MB_ICONASTERISK); //入力制限より内容が変化した時
            }
        }
    }
 
    virtual void OnEditEnd(void)
    {
        CString s = _super::GetText();
        if ( ! s.IsEmpty() )
        {
            LONGLONG i = ToInteger(s);
            LONGLONG ii = AdjustValue(i);
            CString s = ToString(ii);
            if ( _super::GetText() != s )
            {
                _super::SetText(s);
            }
            if ( i != ii )
            {
                ::MessageBeep(MB_ICONASTERISK); //入力制限より内容が変化した時
            }
        }
    }
 
    virtual void OnChangeRange(void)
    {
    }
    
    virtual CString ToString(LONGLONG ll) const
    {
        CString str;
        if ( m_iZeroPlace > 0 )
        {
            CString s;
            s.Format(_T("%%0%dI64d"), (ll >= 0) ? m_iZeroPlace : (m_iZeroPlace + 1)); 
            str.Format(s, ll);
        }
        else
        {
            str.Format(_T("%I64d"), ll);
        }
        return str;
    }
    
    virtual LONGLONG ToInteger(LPCTSTR s) const
    {
        return _ttoi64(s);
    }
 
    virtual LONGLONG AdjustValue(LONGLONG l) const
    {
        if ( l > m_xMax )
        {
            l = m_xMax;
        }
        if ( l < m_xMin )
        {
            l = m_xMin;
        }
        if ( m_step != 1 )
        {
            if ( m_xMin > 0 )
            {
                l -= m_xMin;
                l -= (l % m_step);
                l += m_xMin;
            }
            else
            {
                l -= (l % m_step);
            }
        }
        return l;
    }
 
    CSpinButtonCtrl& ReferSpinButton(void)
    {
        return m_spin;          
    }
 
    LONGLONG        m_xMin;         
    LONGLONG        m_xMax;         
    int             m_iZeroPlace;   
    int             m_step;         
    CString         m_lastText;     
 
private:
    enum
    {
        TIMERID_SPIN_REPOS = 1 
    };
    #ifndef _WIN32_WCE
        CSpinButtonCtrl     m_spin; 
    #else
        CSpinButtonCtrlDg   m_spin;
    #endif
    int             m_spinHeight;   
    bool            m_boOnPaint;    
    // デルタ
    void m_SetDelta(int delta)
    {
        if ( (GetStyle() & ES_READONLY) != 0 )
        {
            return;
        }
        ASSERTLIB( delta != 0 );
        LONGLONG d = delta;
        LONGLONG d0 = (d < 0) ? -d : d;
        LONGLONG r = ToInteger(GetText());
        LONGLONG r0 = r;
        LONGLONG step = (m_step == 1) ? d0 : m_step;
        d0 = m_step * d0;
        if ( delta > 0 )
        {
            d0 = -d0;
        }
        d0 -= (r % step);
        r += d0;
        if ( r > m_xMax )
        {
            r = m_xMax;
        }
        else if ( r < m_xMin )
        {
            r = m_xMin;
        }
        if ( r0 != r )
        {
            SetFocus();
            SetText(ToString(r), true);
            SetSel(0, 0);
        }
    }
    // スピンボタン調整
    void m_AdjustSpinAndEdit(void)
    {
        CRect rect;
        _super::GetClientRect(&rect);
        CRect rc;
        m_spin.GetWindowRect(&rc);
        UINT h = rc.Width();
        ASSERT( rc.Height() == m_spinHeight );
        #ifdef _TnbEDIT_Spin_Horz
            h = rc.Height() * 2;
            MFCLIB::ChangeClientSize(&m_spin, h, -1);
        #endif
        _super::SetMargins(3, 3 + h);
        MFCLIB::SetControlPos(&m_spin, rect.Width() - h, -1);
        m_spin.ShowWindow(SW_SHOW);
    }
};
 
 
 
class CEditULongLong : public CEditValueT<ULONGLONG, 0, 99999999999999999>
{
public:
    CEditULongLong(void)
    {}
};
 
 
 
class CEditDword : public CEditValueT<DWORD, 0, 0xFFFFFFFF>
{
public:
    CEditDword(void)
    {}
};
 
 
 
class CEditInt : public CEditValueT<int, -(0x7FFFFFFF), 0x7FFFFFFE>
{
public:
    CEditInt(void)
    {}
};
 
 
 
class CEditWord : public CEditValueT<WORD, 0, 65535>
{
public:
    CEditWord(void)
    {}
};
 
 
 
class CEditShort : public CEditValueT<short, -32768, 32767>
{
public:
    CEditShort(void)
    {}
};
 
 
 
class CEditByte : public CEditValueT<BYTE, 0, 255>
{
public:
    CEditByte(void)
    {}
};
 
 
 
class CEditChar : public CEditValueT<char, -128, 127>
{
public:
    CEditChar(void)
    {}
};
 
 
 
template<typename TYP, size_t WIDTH>
class CEditHexValueT : public TYP
{
    DEFSUPER(TYP);
public:
 
    CEditHexValueT(void) : _super()
    {
        _super::SetValidChars(_T("1234567890") _T("abcdef") _T("ABCDEF"));
    }
 
    void AddSpinButton(int dummy = 0)
    {
        _super::AddSpinButton(dummy);
        UDACCEL udacl[] = 
        {
            { 0, 0x01}, // 1づつ
            { 2, 0x08}, // 2秒後からは0x08づつ
            { 4, 0x10}, // 4秒後からは0x10づつ
            { 6, 0x20}, // 6秒後からは0x20づつ
        };
        ReferSpinButton().SetAccel(4, udacl);
    }
 
protected:
 
    virtual CString ToString(LONGLONG ll) const
    {
        CString s;
        s.Format(_T("%08I64X"), ll);
        return s.Right(WIDTH);
    }
    
    virtual LONGLONG ToInteger(LPCTSTR s) const
    {
//      return _tcstoul(s, NULL, 16);
        LONGLONG r = 0;
        while ( true )
        {
            int c = *s++;
            if ( c >= 'a' && c <= 'f' )
            {
                c = (c - 'a') + 10;
            }
            else if ( c >= 'A' && c <= 'F' )
            {
                c = (c - 'A') + 10;
            }
            else if ( c >= '0' && c <= '9' )
            {
                c = c - '0';
            }
            else
            {
                break;
            }
            r *= 16;
            r += c;
        }
        return r;
    }
};
 
 
 
class CEditHexDword : public CEditHexValueT<CEditDword, 8>
{
public:
    CEditHexDword(void)
    {}
};
 
 
 
class CEditHexWord : public CEditHexValueT<CEditWord, 4>
{
public:
    CEditHexWord(void)
    {}
};
 
 
 
class CEditHexByte : public CEditHexValueT<CEditByte, 2>
{
public:
    CEditHexByte(void)
    {}
};
 
 
 
template<typename TYP>
class CNonEmptyEditValueT : public TYP
{
    DEFSUPER(TYP);
protected:
 
    virtual void OnChangeRange(void)
    {
        if ( _super::GetText().IsEmpty() )
        {
            _super::SetValue(static_cast<TYPE>(_super::m_xMin));
        }
    }
 
    virtual void PreSubclassWindow(void)
    {
        _super::SetText(ToString(_super::m_xMin));
        _super::PreSubclassWindow();
    }
 
    virtual void OnEditEnd(void)
    {
        if ( _super::GetText().IsEmpty() )
        {
            _super::SetValue(static_cast<TYPE>(_super::m_xMin));
        }
        _super::OnEditEnd();
    }
};  
 
 
 
}; //MFC
}; //TNB