CGridCellNumeric - A numeric cell class for the MFC Grid

// We now have all the locale specific settings we need
// Now we can tackle the string
if (m_dwFlags & (Real | Currency))
{
    // replace locale decimal seperator with a decimal point
    str.Replace(cDecimal, _T('.'));

    // Addition for Implied decimal digits

    // Inserts a decimal point if it is not already present
    if (NULL != m_pNumberFmt && str.Find(_T('.'), 0) == -1)
    {
        // Add leading zeroes if needed
        for (int x = str.GetLength(); x < m_pNumberFmt->NumDigits; ++x)
            str.Insert(0, _T('0'));

        // Insert the decimal point
        str.Insert(str.GetLength() - m_pNumberFmt->NumDigits, _T('.'));
    }

    // End of Addition for Implied decimal digits

    // add the decimal point to the allowable characters
    sDigits += _T('.');
}

GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ILZERO | LOCALE_RETURN_NUMBER, (LPTSTR)&m_NumberFmt.LeadingZero, sizeof(UINT) / sizeof(TCHAR));
GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_INEGNUMBER | LOCALE_RETURN_NUMBER, (LPTSTR)&m_NumberFmt.NegativeOrder, sizeof(UINT) / sizeof(TCHAR));
GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, DecimalSep, sizeof(DecimalSep));
GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, ThousandSep, sizeof(ThousandSep));

m_NumberFmt.NumDigits = 1;
m_NumberFmt.Grouping = 3;
m_NumberFmt.lpDecimalSep = DecimalSep;
m_NumberFmt.lpThousandSep = ThousandSep;

// Numeric editbox columns
case ColumnBelow:
case ColumnAbove:
case ColumnMore:
case ColumnLess:
    SetCellType(row, col, RUNTIME_CLASS(CGridCellNumeric));
    CGridCellNumeric *pCell = dynamic_cast<CGridCellNumeric *>(GetCell(row, col));
    if (pCell)
    {
        pCell->SetFlags(CGridCellNumeric::Real | CGridCellNumeric::Negative);
        pCell->SetNumberFmt(&m_NumberFmt);
        pCell->SetFormat(DT_RIGHT);
    }
}

CGridCellNumeric *pCell1 = dynamic_cast<CGridCellNumeric *>(GetCell(row1, col1));
CGridCellNumeric *pCell2 = dynamic_cast<CGridCellNumeric *>(GetCell(row2, col2));
CGridCellNumeric *pCell3 = dynamic_cast<CGridCellNumeric *>(GetCell(row3, col3));
if (pCell1 && pCell2 && pCell3)
{
    pCell3->SetNumber(pCell1->GetNumber() + pCell2->GetNumber());
}

BOOL CGridCellNumeric::Format(CString &TheString)
{
    int count = 0;
    CString str = TheString;
    CString buffer;
    CString sDigits;
    TCHAR cDecimal = 0;
    TCHAR cSystemDecimal = 0;
    TCHAR cNegative = 0;
    int iNegative = -1;
 
    // Get the locale's native digits
    count = GetLocaleInfo(LOCALE_USER_DEFAULT,
                          LOCALE_SNATIVEDIGITS,
                          NULL,
                          0);
    count = GetLocaleInfo(LOCALE_USER_DEFAULT,
                          LOCALE_SNATIVEDIGITS,
                          sDigits.GetBuffer(count),
                          count);
    sDigits.ReleaseBuffer();
    if (!count)
        sDigits = _T("0123456789");
 
    // Get the locale's decimal point
    if (m_dwFlags & Currency)
    {
        count = GetLocaleInfo(LOCALE_USER_DEFAULT,
                              LOCALE_SMONDECIMALSEP,
                              NULL,
                              0);
        count = GetLocaleInfo(LOCALE_USER_DEFAULT,
                              LOCALE_SMONDECIMALSEP,
                              buffer.GetBuffer(count),
                              count);
        buffer.ReleaseBuffer();
        cDecimal = count ? buffer[0] : _T('.');
        sDigits += cDecimal;
 
        count = GetLocaleInfo(LOCALE_SYSTEM_DEFAULT,
                              LOCALE_SMONDECIMALSEP,
                              NULL,
                              0);
        count = GetLocaleInfo(LOCALE_SYSTEM_DEFAULT,
                              LOCALE_SMONDECIMALSEP,
                              buffer.GetBuffer(count),
                              count);
        buffer.ReleaseBuffer();
        cSystemDecimal = count ? buffer[0] : _T('.');
        sDigits += cDecimal;
    }
    else
    {
        count = GetLocaleInfo(LOCALE_USER_DEFAULT,
                              LOCALE_SDECIMAL,
                              NULL,
                              0);
        count = GetLocaleInfo(LOCALE_USER_DEFAULT,
                              LOCALE_SDECIMAL,
                              buffer.GetBuffer(count),
                              count);
        buffer.ReleaseBuffer();
        cDecimal = count ? buffer[0] : _T('.');
 
        count = GetLocaleInfo(LOCALE_SYSTEM_DEFAULT,
                              LOCALE_SDECIMAL,
                              NULL,
                              0);
        count = GetLocaleInfo(LOCALE_SYSTEM_DEFAULT,
                              LOCALE_SDECIMAL,
                              buffer.GetBuffer(count),
                              count);
        buffer.ReleaseBuffer();
        cSystemDecimal = count ? buffer[0] : _T('.');
    }
 
    if (m_dwFlags & Negative)
    {
        // Get the locale's negative sign
        count = GetLocaleInfo(LOCALE_USER_DEFAULT,
                              LOCALE_SNEGATIVESIGN,
                              NULL,
                              0);
        count = GetLocaleInfo(LOCALE_USER_DEFAULT,
                              LOCALE_SNEGATIVESIGN,
                              buffer.GetBuffer(count),
                              count);
        buffer.ReleaseBuffer();
        cNegative = count ? buffer[0] : _T('-');
        sDigits += cNegative;
 
        // Get the locale's negative format
        if (m_dwFlags & Currency)
            count = GetLocaleInfo(LOCALE_USER_DEFAULT,
                                  LOCALE_INEGCURR | LOCALE_RETURN_NUMBER,
                                  (LPTSTR)&iNegative,
                                  sizeof(int) / sizeof(TCHAR));
        else
            count = GetLocaleInfo(LOCALE_USER_DEFAULT,
                                  LOCALE_INEGNUMBER | LOCALE_RETURN_NUMBER,
                                  (LPTSTR)&iNegative,
                                  sizeof(int) / sizeof(TCHAR));
        if (!count)
            iNegative = 1;
 
        if (m_dwFlags & Currency)
        {
            if (iNegative == 0 || iNegative == 4 || iNegative == 14 || iNegative == 15)
                sDigits += _T("()");
        }
        else if (iNegative == 0)
            sDigits += _T("()");
    }
 
    // We now have all the locale specific settings we need
    // Now we can tackle the string
    if (m_dwFlags & (Real | Currency))
    {
        // replace locale decimal seperator with a decimal point
        str.Replace(cDecimal, cSystemDecimal);
 
        // add the decimal point to the allowable characters
        sDigits += cSystemDecimal;
    }
 
    if ((m_dwFlags & TypeMask) == Integer)
    {
        // we are dealing with integers, so we will find the decimal point
        // and chop it off. No rounding will occur.
        int pos = str.Find(_T('.'), 0);
        if (pos != -1)
            // chop chop
            str.Delete(pos, str.GetLength() - pos);
    }
 
    LPCTSTR digits = sDigits;
    for(int i = str.GetLength() - 1; i >= 0; --i)
    {
        // Remove invalid characters such as currency signs
        TCHAR *ptr = _tcschr(digits, str[i]);
        if (ptr == NULL)
            str.Delete(i);
        else
        {
            // No idea if this is really necessary, but this is
            // supposed to convert from native digits to ASCII 0-9
            // that is required for GetNumberFormat and GetCurrencyFormat
            // Maybe there is a windows API that already does this???
            int diff = (int)(ptr - digits);
            if (diff < 10 && (*ptr < _T('0') || *ptr > _T('9')))
            {
                TCHAR ch = (TCHAR)(0x30 + diff);
                str.SetAt(i, ch);                
            }
        }
    }
 
    if (m_dwFlags & Negative)
    {
        // remove locale negative formatting and replace
        // with leading minus sign
        CString neg = (iNegative ? _T("") : _T("()"));
        neg += cNegative;
        if (str.FindOneOf(neg) != -1)
        {
            str.Remove(cNegative);
            str.Remove(_T('('));
            str.Remove(_T(')'));
            str.Insert(0, _T('-'));
        }
    }
 
    // The string should now be in the correct format
    // for the locale formatting functions.
    // Here we set a local Number variable, and at
    // same time confirm that the formatting will work.
    // m_nNumber will be updated later to this Number if
    // everything succeeds. Don't want to get out of sync do we?
    TCHAR *EndPtr = NULL;
    double Number = _tcstod(str, &EndPtr);
//    ASSERT (*EndPtr == NULL);
 
    // GetCurrencyFormat/GetNumberFormat require the decimal point (.)
    str.Replace(cSystemDecimal, _T('.'));
 
    if (*EndPtr == NULL)
    {
        CString Formatted;
        if (m_dwFlags & Currency)
        {
            count = GetCurrencyFormat(LOCALE_USER_DEFAULT,
                                      NULL,
                                      str,
                                      m_pCurrencyFmt,
                                      NULL,
                                      0);
            count = GetCurrencyFormat(LOCALE_USER_DEFAULT,
                                      NULL,
                                      str,
                                      m_pCurrencyFmt,
                                      Formatted.GetBuffer(count),
                                      count);
            Formatted.ReleaseBuffer();
        }
        else
        {
            count = GetNumberFormat(LOCALE_USER_DEFAULT,
                                    NULL,
                                    str,
                                    m_pNumberFmt,
                                    NULL,
                                    0);
            count = GetNumberFormat(LOCALE_USER_DEFAULT,
                                    NULL,
                                    str,
                                    m_pNumberFmt,
                                    Formatted.GetBuffer(count),
                                    count);
            Formatted.ReleaseBuffer();
        }
 
        if (count)
        {
            if ((m_dwFlags & TypeMask) == Integer)
            {
                // remove the decimal point and any trailing zeroes
                // we cannot simply chop it off as the formatting
                // may have left trailing sign characters
                int pos = Formatted.Find(cDecimal, 0);
                if (pos != -1)
                {
                    Formatted.Delete(pos);
                    while (pos < Formatted.GetLength() && Formatted[pos] == sDigits[0])
                        Formatted.Delete(pos);
                }
            }
 
            // Only update m_nNumber if everything above succeeded
            m_nNumber = Number;
            TheString = Formatted;
            return TRUE;
        }
    }
    TRACE (_T("CGridCellNumeric::Format() - Failed to correctly format string."));
//    ASSERT(0);
    return FALSE;
}