自定义控件在中文模式下不能输入数字

Question

大家好！自己写了一个控件，发现有个问题，输入法中文模式下不能输入数字，比如在微软拼音输入法中文模式下不能输入数字，改成英文模式就可以输入，请帮忙改下代码，谢谢！

#include "StdAfx.h"
#include "TimeWnd.h"
 
CTimeWnd::CTimeWnd(void)
{
    for (int i=0; i<valCount; i++)
    {
        m_nValue[i] = 0;
        m_Rect[i].SetRectEmpty();
    }
    m_nValueMax[valHours] = 24;
    m_nValueMax[valMinutes] = 60;
    m_nValueMax[valSeconds] = 60;
    m_nValueMax[valMilliseconds] = 1000;
 
    m_dPower[valHours] = 3600;
    m_dPower[valMinutes] = 60;
    m_dPower[valSeconds] = 1;
    m_dPower[valMilliseconds] = 0.001000;
    m_nFirst = 0;
            
    m_nCurSel = -1;
    m_nOldSel = 0;
    m_pFont = NULL;
    m_dMinTime = 0;
    m_dMaxTime = 90000;
    m_bFocus = false;

    m_nFontColor = RGB(0,0,0);
    m_nBackColor = RGB(255,255,255);
}
 
CTimeWnd::~CTimeWnd(void)
{
}
 
BEGIN_MESSAGE_MAP(CTimeWnd, CWnd)
 
ON_WM_PAINT()
    ON_WM_CREATE()
    ON_WM_LBUTTONDOWN()
    ON_WM_KEYDOWN()
    ON_NOTIFY(UDN_DELTAPOS, 1051, &CTimeWnd::OnDeltaposSpin1)
    ON_WM_KILLFOCUS()
    ON_WM_SIZE()
    ON_WM_CAPTURECHANGED()
    ON_WM_ENABLE()
END_MESSAGE_MAP()
 
void CTimeWnd::OnDeltaposSpin1(NMHDR *pNMHDR, LRESULT *pResult)
{
    LPNMUPDOWN pNMUpDown = reinterpret_cast<LPNMUPDOWN>(pNMHDR);
    *pResult = 0;
    SetFocus();
    ChangeSpin(pNMUpDown->iDelta*(-1));
}
 
void CTimeWnd::ChangeSpin(int nDelta)
{
    if(m_nCurSel == -1)
    {
        m_nCurSel = m_nOldSel;
    }
    if (nDelta > 0)
    {
        m_nValue[m_nCurSel] = (m_nValue[m_nCurSel]+nDelta)%m_nValueMax[m_nCurSel];
    }
    else
    {
        m_nValue[m_nCurSel] = (m_nValue[m_nCurSel]+nDelta+m_nValueMax[m_nCurSel])%m_nValueMax[m_nCurSel];
    }
    
    VarifyRange();
    ReDraw(true);
    GetParent()->PostMessage(WM_TIMECHNGE, (WPARAM)GetDlgCtrlID(), (LPARAM)GetTime());
}
 
void CTimeWnd::OnPaint()
{
    CPaintDC dc(this); // device context for painting
    CRect rcBounds;   
    GetClientRect(&rcBounds);   
    CPen penWhite;   
    penWhite.CreatePen(PS_SOLID, 1, RGB(127,157,185));   
    CPen *pOldPen = dc.SelectObject(&penWhite); 
    dc.FillSolidRect(rcBounds, m_nBackColor);
    CString    str;
    int xoffset = 5;
    CRect rc;
    rc.SetRectEmpty();
    for(int i=0; i<valCount; i++)
    {
        str = GetString(i);
        rc = rcBounds;
        DrawSingleString(&dc,str,rc,&xoffset,(i == m_nCurSel));
        m_Rect[i] = rc;
        switch (i)
        {
        case 0:
        case 1:
            str = _T(":");
            rc = rcBounds;
            DrawSingleString(&dc, str, rc, &xoffset);
            break;
        case 2:
            str = _T(".");
            rc = rcBounds;
            DrawSingleString(&dc, str, rc, &xoffset);
            break;
        }
    }
    dc.SelectObject(pOldPen); 
}
 
void CTimeWnd::PreSubclassWindow()
{
    CWnd::PreSubclassWindow();
}
 
int CTimeWnd::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
    if (CWnd::OnCreate(lpCreateStruct) == -1)
        return -1;
 
    m_Spin.Create(UDS_ALIGNRIGHT|UDS_AUTOBUDDY|WS_VISIBLE, CRect(0,0,20,19), this, 1051);
    m_Spin.SetBuddy(this);
 
    return 0;
}
 
void CTimeWnd::OnLButtonDown(UINT nFlags, CPoint point)
{
    for (int i=0; i<valCount; i++)
    {
        if (m_Rect[i].PtInRect(point))
        {
            if (m_nCurSel == i)break;
            m_nFirst = 0;
            ReDraw(false);
            m_nCurSel = i;
            ReDraw(true);
            break;
        }
    }
    SetFocus();
    m_bFocus = true;
    CWnd::OnLButtonDown(nFlags, point);
}
 
void CTimeWnd::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
     if (m_nCurSel == -1)
    {
        m_nCurSel = m_nOldSel;
    }
    if ((nChar>='0') && (nChar<='9'))
    {
        ChangeChar(nChar, '0');
    }
    else if ((nChar>=VK_NUMPAD0) && (nChar<=VK_NUMPAD9))
    {
        ChangeChar(nChar, VK_NUMPAD0);
    }
    ReDraw(true);
    CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
}
 
CString CTimeWnd::GetString(int nType)
{
    CString str = NULL;
    int nCount = 0;
    int nZero = 0;
    nCount = GetNumberCount(m_nValueMax[nType]-1);
    nZero = nCount - GetNumberCount(m_nValue[nType]) ;
    m_nValue[nType] %= m_nValueMax[nType];
    str.Format(_T("%d"), m_nValue[nType]);
    while (nZero--)
    {
        str = _T("0") + str;
    }
    return str;
}

void CTimeWnd::SetRange( double dMinTime, double dMaxTime )
{
    m_dMinTime = dMinTime;
    m_dMaxTime = dMaxTime;
    VarifyRange();
}

void CTimeWnd::SetRangeMax( int nHour, int nMin, int nSecond, int nMilliSecond )
{
    double dMaxTime = 0;
    dMaxTime += nHour * m_dPower[valHours];
    dMaxTime += nMin * m_dPower[valMinutes];
    dMaxTime += nSecond * m_dPower[valSeconds];
    dMaxTime += nMilliSecond * m_dPower[valMilliseconds];
    m_dMaxTime = dMaxTime;
    VarifyRange();
}
void CTimeWnd::SetRangeMin( int nHour, int nMin, int nSecond, int nMilliSecond )
{
    double dMinTime = 0;
    dMinTime += nHour * m_dPower[valHours];
    dMinTime += nMin * m_dPower[valMinutes];
    dMinTime += nSecond * m_dPower[valSeconds];
    dMinTime += nMilliSecond * m_dPower[valMilliseconds];
    m_dMinTime = dMinTime;
    VarifyRange();
}
bool CTimeWnd::VarifyRange()
{
    bool bRet = false;
    double dCur = GetTime();
    if(    m_dMinTime > dCur )
    {
        dCur = m_dMinTime;
        bRet = true;
    }
    if(    m_dMaxTime < dCur )
    {
        dCur = m_dMaxTime;
        bRet = true;
    }
    if(bRet)
    {
        double nTemVal = 0;
        for (int i=0; i<valCount; i++)
        {
            m_nValue[i] = (int)((dCur+0.0005 - nTemVal) / m_dPower[i]);
            nTemVal += m_nValue[i] * m_dPower[i];
            m_nValue[i] %= m_nValueMax[i]; 
        }
        CRect   rcBounds;   
        GetClientRect(&rcBounds);
        rcBounds.right -= 20;
        RedrawWindow( &rcBounds );
    }
    return bRet;
}
void CTimeWnd::DrawSingleString(CDC *pDC, CString &str, CRect &rc, int *pOffset/*= -1*/, bool bSelect/* = false*/)
{
    int nHeight = rc.Height();
    int offset = 0;
    if (pOffset == NULL)
    {
        offset = rc.left;
    }
    else
    {
        offset = *pOffset;
    }
    CFont *pOldFont = NULL;
    if (m_pFont)
    {
        pOldFont = pDC->SelectObject(m_pFont);
    }
    pDC->DrawText(str, rc, DT_CALCRECT);
    rc.MoveToXY(offset, (nHeight - rc.Height())/2);
    COLORREF clr;
    int nMode = 0;
    BOOL bEnable = IsWindowEnabled();
    if (bSelect && bEnable)
    {
        pDC->FillSolidRect(rc, RGB(49,106,197));
        clr = pDC->SetTextColor(RGB(255,255,255));
        nMode = pDC->SetBkMode(TRANSPARENT);
    }
    else
    {
        pDC->FillSolidRect(rc, m_nBackColor);
        clr = pDC->SetTextColor(m_nFontColor);
    }
    if (bEnable)
         pDC->DrawState(CPoint(rc.left, rc.top), CSize(rc.Width(), rc.Height()), str, DSS_NORMAL, TRUE, 0, (HBRUSH)NULL);
    else
        pDC->DrawState(CPoint(rc.left, rc.top), CSize(rc.Width(), rc.Height()), str, DSS_NORMAL, TRUE, 0, (HBRUSH)NULL);
    offset += rc.Width();
    offset = offset + 1;  // 2023.3.25 by yeyizhou
    if (bSelect)
    {
        pDC->SetTextColor(clr);
        pDC->SetBkMode(nMode);
    }
    if (pOffset) *pOffset = offset;
    if (pOldFont) pDC->SelectObject(pOldFont);
}
 
void CTimeWnd::OnKillFocus(CWnd *pNewWnd)
{
    CWnd::OnKillFocus(pNewWnd);
    ReDraw(false);
    m_nOldSel = m_nCurSel;
    m_nCurSel = -1;
    m_bFocus = false; 
}
 
void CTimeWnd::ReDraw(bool bNeedBk/*= true*/)
{
    if (m_nCurSel == -1)
    {
        return;
    }
    CDC *pDC = GetDC();
    CString str = GetString(m_nCurSel);
    CRect   rcBounds;   
    GetClientRect(&rcBounds);   
    rcBounds.left = m_Rect[m_nCurSel].left;
    rcBounds.right = m_Rect[m_nCurSel].right;
    DrawSingleString(pDC, str, rcBounds, NULL, bNeedBk);
    ReleaseDC(pDC);
}
 
void CTimeWnd::SetFont(CFont *pFont, BOOL bRedraw/*=false*/)
{
    m_pFont = pFont;
    if (bRedraw)
    {
        Invalidate();
    }
}
 
CFont *CTimeWnd::GetFont()
{
    return m_pFont;
}
 
void CTimeWnd::ChangeChar(UINT nChar, int refer)
{
    if (!IsCountValid(m_nCurSel)) return;
    int iCharValue = nChar - refer;
    int iTemVal = m_nValue[m_nCurSel] * 10 + iCharValue;
    //m_nValue[m_nCurSel] = (iTemVal >= m_nValueMax[m_nCurSel]) ? iCharValue : iTemVal;
    m_nValue[m_nCurSel] = (m_nFirst<=0) ? iCharValue : (iTemVal%m_nValueMax[m_nCurSel]);
    if(m_nCurSel==3)
    {
        if(++m_nFirst>2 )
            m_nFirst = 0;
    }
    else
        m_nFirst = !m_nFirst;
    VarifyRange();
    GetParent()->PostMessage(WM_TIMECHNGE, (WPARAM)GetDlgCtrlID(), (LPARAM)GetTime());
}
 
 
BOOL CTimeWnd::PreTranslateMessage(MSG *pMsg)
{
    if (pMsg->message == WM_KEYDOWN)
    {
        if (pMsg->wParam == VK_UP)
        {
            ChangeSpin(1);
            return true;
        }
        if (pMsg->wParam == VK_DOWN)
        {
            ChangeSpin(-1);
            return true;
        }
        if (pMsg->wParam == VK_LEFT)
        {
            ReDraw(false);
            m_nCurSel = (m_nCurSel + valCount - 1) % valCount;
            ReDraw(true);
            return true;
        }
        if (pMsg->wParam == VK_RIGHT)
        {
            ReDraw(false);
            m_nCurSel = (m_nCurSel + 1) % valCount;
            ReDraw(true);
            return true;
        }
        if (pMsg->wParam == VK_END)
        {        
            m_nValue[m_nCurSel] = m_nValueMax[m_nCurSel];
        }
        if (pMsg->wParam == VK_HOME)
        {
            m_nValue[m_nCurSel] = 0;
        }
    }
    return CWnd::PreTranslateMessage(pMsg);
}
 
double CTimeWnd::GetTime()
{
    double dTime = 0;
    for (int i=0; i<valCount; i++)
    {
        dTime += m_nValue[i] * m_dPower[i];
    }
    return dTime;
}
 
int CTimeWnd::GetValue(int nType)
{
    if (!IsCountValid(nType)) 
        return 0;
    else 
        return m_nValue[nType];
}
 
void CTimeWnd::SetValue(int nType, int nVal)
{
    if ((!IsCountValid(nType)) || nVal<0) return;
    else m_nValue[nType] = nVal % m_nValueMax[nType];
    
    VarifyRange();
}
 
void CTimeWnd::SetTime(double dTime)
{
    double nTemVal = 0;
    for (int i=0; i<valCount; i++)
    {
        m_nValue[i] = (int)((dTime+0.0005 - nTemVal) / m_dPower[i]);
        nTemVal += m_nValue[i] * m_dPower[i];
        m_nValue[i] %= m_nValueMax[i]; 
    }
    VarifyRange();
}
 
bool CTimeWnd::IsFocus()
{
    return m_bFocus;
}
 
void CTimeWnd::OnSize(UINT nType, int cx, int cy)
{
    CWnd::OnSize(nType, cx, cy);
    m_Spin.MoveWindow(cx-19, 1, 18, cy-2);
    
    MoveWindow(x, y, width, height); // 2024/3/4
    Invalidate();
}
 
void CTimeWnd::OnCaptureChanged(CWnd *pWnd)
{
    CWnd::OnCaptureChanged(pWnd);
}
 
void CTimeWnd::OnEnable(BOOL bEnable)
{
    CWnd::OnEnable(bEnable);
    Invalidate();
    m_Spin.EnableWindow(bEnable);
}
 
int CTimeWnd::GetNumberCount(int num)
{
    int i = 0;
    if (num == 0)
    {
        return 1;
    }
    while (num)
    {
        num /= 10;    
        i++;
    };
    return i;
}
 
bool CTimeWnd::IsCountValid(int nCount)
{
    if ((nCount>=0) && (nCount<valCount))
    {
        return true;
    }
    return false;
}

void CTimeWnd::SetColorStyle(COLORREF nFont, COLORREF nBack, COLORREF nFrame)
{
    m_nFontColor = nFont;
    m_nBackColor = nBack;
    m_Spin.SetColorStyle(m_nFontColor,m_nBackColor,nFrame);
    m_oBackBrush.CreateSolidBrush(nBack);
}

Answer 1

以下参考免费微信小程序：皆我百晓生 作答，并由阿齐Archie整理回复，若还有疑问可评论或留言。

从您提供的代码来看，这个自定义控件似乎是一个时间选择控件。问题出现在中文输入法模式下不能输入数字，这通常是因为某些中文输入法屏蔽了数字的输入。为了解决这个问题，您可以尝试以下步骤：

1. 检查键盘输入：在OnKeyDown方法中，您已经处理了数字和数字键盘的输入。确保当用户按下数字键时，无论输入法的状态如何，都能正确处理。

2. 使用WM_CHAR消息：除了WM_KEYDOWN消息，还可以通过WM_CHAR消息来处理字符输入。WM_CHAR消息在用户按下键盘上的键并释放时发送，并包含了实际的字符代码。您可以在OnKeyDown方法中添加对WM_CHAR的处理。

3. 修改PreTranslateMessage：在PreTranslateMessage方法中，您可以处理向上、向下、向左、向右键的输入，也可以在这里处理数字输入。

下面是修改后的代码片段，展示了如何在OnKeyDown和PreTranslateMessage中处理数字输入：

void CTimeWnd::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
    if (m_nCurSel == -1)
    {
        m_nCurSel = m_nOldSel;
    }

    // 处理数字输入
    if ((nChar >= '0' && nChar <= '9'))
    {
        ChangeChar(nChar, '0');
    }
    else if ((nChar >= VK_NUMPAD0 && nChar <= VK_NUMPAD9))
    {
        ChangeChar(nChar, VK_NUMPAD0);
    }
    ReDraw(true);
    CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
}

BOOL CTimeWnd::PreTranslateMessage(MSG *pMsg)
{
    if (pMsg->message == WM_KEYDOWN)
    {
        if (pMsg->wParam == VK_UP)
        {
            ChangeSpin(1);
            return TRUE;
        }
        if (pMsg->wParam == VK_DOWN)
        {
            ChangeSpin(-1);
            return TRUE;
        }
        if (pMsg->wParam == VK_LEFT)
        {
            ReDraw(false);
            m_nCurSel = (m_nCurSel + valCount - 1) % valCount;
            ReDraw(true);
            return TRUE;
        }
        if (pMsg->wParam == VK_RIGHT)
        {
            ReDraw(false);
            m_nCurSel = (m_nCurSel + 1) % valCount;
            ReDraw(true);
            return TRUE;
        }
        if (pMsg->wParam == VK_END)
        {        
            m_nValue[m_nCurSel] = m_nValueMax[m_nCurSel];
        }
        if (pMsg->wParam == VK_HOME)
        {
            m_nValue[m_nCurSel] = 0;
        }
    }
    else if (pMsg->message == WM_CHAR)
    {
        if ((pMsg->wParam >= '0' && pMsg->wParam <= '9'))
        {
            ChangeChar(pMsg->wParam, '0');
            return TRUE;
        }
    }
    return CWnd::PreTranslateMessage(pMsg);
}

1. 测试：在进行了上述修改后，您需要测试控件在不同输入法状态下的行为，确保数字输入在中文模式下也能被正确处理。

2. 考虑输入法兼容性：不同的输入法可能有不同的行为，您可能需要针对不同的输入法进行额外的测试和调整。

通过这些步骤，您应该能够解决中文输入法下数字输入的问题。如果问题仍然存在，可能需要进一步检查您的控件代码，或者考虑是否有其他因素影响了输入。