Aug 28

Custom-Drawn Tooltips

C, Win32 3 Comments »

Like many common controls, the tooltip control supports custom drawing for maximum flexibility. This is a quick tutorial on how to use the tooltip custom draw facility.

Read the rest of this entry »

Aug 22

Win32: Getting LOGFONT from HFONT

Win32 1 Comment »

To convert a HFONT to a LOGFONT, use the GDI function GetObject(), as in:

  1. LOGFONT lf;
  2. int ret = GetObject(hfont, sizeof(lf), &lf);
  3. // Be sure to check the return value of GetObject

The code is trivial but the function took me forever to find.

Jul 12

Microsoft’s XmlLite

Win32, XML No Comments »

Microsoft has created a new, lightweight C++ XML processing library called XmlLite. It includes a streaming XML writing class patterned after .NET’s System.Xml.XmlWriter.

This library makes the IXmlWriter in Implementing IXmlWriter Series obsolete for Windows developers.

Jul 11

Generating and Parsing Localized Numbers In Windows

C++, Win32 3 Comments »

While Windows supports dozens or even hundreds of languages, its localization APIs require quite a bit of getting used to. Below is how I solved some common problems related to formatting and parsing a number for a specific locale.

Formatting a Number for a Locale

The function GetNumberFormat() formats a number for a particular locale. Its simplest usage looks something like:

  1. #define ARRAYSIZE(x) ( sizeof(x) / sizeof(x[0]) )
  2.  
  3. TCHAR buf[80];
  4. int ret = GetNumberFormat
  5.     (
  6.     LOCALE_USER_DEFAULT, // locale
  7.     0,                   // dwFlags
  8.     TEXT("1234567.89"),  // lpValue
  9.     NULL,                // lpFormat
  10.     buf,                 // lpNumberStr
  11.     ARRAYSIZE(buf)       // cchNumber
  12.     );
  13. ASSERT(ret != 0);

buf now contains the number 1234567.89 formatted for the user’s default locale. For example, for the English-United States locale, buf will contain “1,234,567.89″; for German-Germany, “1.234.567,89″; for Hindi, “12,34,567.89″.

The format of the lpValue parameter is important. From GetNumberFormat()’s MSDN documentation:

lpValue

[in] Pointer to a null-terminated string containing the number string to format. This string can only contain the following characters. All other characters are invalid. The function returns an error if the string indicated by lpValue deviates from these rules.

  • Characters ‘0′ through ‘9′.
  • One decimal point (dot) if the number is a floating-point value.
  • A minus sign in the first character position if the number is a negative value.

Given these constraints, I’ve found the easiest way to convert, say, a double to a string for use as lpValue is to use StringCchPrintf() (or, equivalently, wnsprintf() or _sntprintf()), as in:

  1. int GetNumberFormatDbl(LCID locale, DWORD dwFlags, double value,
  2.                        const NUMBERFMT* lpFormat, LPTSTR lpNumberStr,
  3.                        int cchNumber)
  4. {
  5.     // DBL_MAX is 1.7976931348623158e+308 and 317 characters
  6.     // (including null terminator)
  7.     TCHAR szBuf[317];
  8.     HRESULT hr = StringCchPrintf(szBuf, ARRAYSIZE(szBuf),
  9.                                  TEXT("%lf"), value);
  10.     if (hr != S_OK)
  11.     {
  12.         SetLastError(ERROR_INVALID_PARAMETER);
  13.         return 0;
  14.     }
  15.     return GetNumberFormat(locale, dwFlags, szBuf, lpFormat,
  16.                            lpNumberStr, cchNumber);
  17. }

One caveat: GetNumberFormatDbl() does not deal well with very small numbers (below 1e-5 or so).

Parsing a Localized Number String

I spent a lot of time trying to figure out the best way to parse a localized number string until Michael Kaplan mentioned VariantChangeTypeEx(). Once I had that, the rest was (relatively) easy:

  1. // Convert szStr to a BSTR.  Returns NULL on failure.  Result must be
  2. // freed with SysFreeString.
  3. BSTR TstrToBstr(LPCTSTR szStr)
  4. {
  5. #if defined(UNICODE)
  6.     return SysAllocString(szStr);
  7. #else
  8.     BSTR bstrRet = NULL;
  9.     int cch = MultiByteToWideChar(CP_ACP, 0, szStr, -1, NULL, 0);
  10.     if (cch != 0)
  11.     {
  12.         WCHAR* pswz = new WCHAR[cch];
  13.         cch = MultiByteToWideChar(CP_ACP, 0, szStr, -1, pswz, cch);
  14.         if (cch != 0)
  15.         {
  16.             bstrRet = SysAllocString(pswz);
  17.         }
  18.         delete[] pswz;
  19.     }
  20.  
  21.     return bstrRet;
  22. #endif
  23. }
  24.  
  25. // Converts the localized number string szNumber to a double using the
  26. // given locale.  Returns TRUE and sets *pVal on success, FALSE
  27. // otherwise.
  28. BOOL LocalizedStrToDbl(LCID lcid, LPCTSTR szNumber, double* pVal)
  29. {
  30.     BOOL bSuccess = FALSE;
  31.  
  32.     // Set out parameter regardless
  33.     *pVal = 0;
  34.  
  35.     BSTR bstr = TstrToBstr(szNumber);
  36.     if (bstr != NULL)
  37.     {
  38.         VARIANT var;
  39.         VariantInit(&var);
  40.         // bstr will be freed on VariantClear
  41.         var.bstrVal = bstr;
  42.         var.vt = VT_BSTR;
  43.  
  44.         HRESULT hr = VariantChangeTypeEx(&var, &var, lcid, 0, VT_R8);
  45.         if (hr == S_OK)
  46.         {
  47.             *pVal = var.dblVal;
  48.             bSuccess = TRUE;
  49.         }
  50.  
  51.         VariantClear(&var);
  52.     }
  53.  
  54.     return bSuccess;
  55. }

Using VarR8FromStr() instead of VariantChangeTypeEx() is also an option.

Customizing of the Output of GetNumberFormat()

If you pass NULL as the lpFormat parameter to GetNumberFormat(), you use the locale’s default number formatting information. I often find this to be unacceptable — for example, many times I want to control the number of fractional digits I display. To do this, you need to provide a filled-in NUMBERFMT structure to GetNumberFormat().

I suggest starting with the locale’s default NUMBERFMT and then change only the members you require. Because Windows does not seem to provide a way to retrieve a locale’s default NUMBERFMT, we’ll have to roll our own.

To populate the members of NUMBERFMT we are going to use the function GetLocaleInfo(). The map between NUMBERFMT members and LCTYPEs to pass to GetLocaleInfo() is as follows:

NUMBERFMT Member LCTYPE Constant
NumDigits LOCALE_IDIGITS
LeadingZero LOCALE_ILZERO
Grouping LOCALE_SGROUPING
lpDecimalSep LOCALE_SDECIMAL
lpThousandSep LOCALE_STHOUSAND
NegativeOrder LOCALE_INEGNUMBER

GetLocaleInfo() always returns strings, but many of these strings need to be converted to UINTs. Furthermore, the conversion between the LOCALE_SGROUPING string and the Grouping member is quite tricky; read How to fill in that number grouping member of NUMBERFMT for more information.

We now have enough information to write the function to retrieve a locale-default NUMBERFMT:

  1. // Converts a grouping string returned by
  2. // GetLocaleInfo(LOCALE_SGROUPING) into a UINT understood by NUMBERFMT.
  3. UINT GroupingStrToUint(LPCTSTR szGrouping)
  4. {
  5.     LPCTSTR szCurr = szGrouping;
  6.     UINT ret = 0;
  7.  
  8.     while (true)
  9.     {
  10.         ret *= 10;
  11.         if (*szCurr == TEXT(‘\\0′))
  12.             break;
  13.  
  14.         TCHAR* pch;
  15.         ret += _tcstol(szCurr, &pch, 10);
  16.  
  17.         if (_tcscmp(pch, TEXT(";0")) == 0)
  18.             break;
  19.  
  20.         szCurr = pch + 1;
  21.     }
  22.  
  23.     return ret;
  24. }
  25.  
  26. // Fills the default NUMBERFMT structure for a given locale.
  27. // pFmt->lpDecimalSep and pFmt->lpThousandSep must point to valid
  28. // buffers of size cchDecimalSep and cchThousandSep respectively.
  29. BOOL GetDefaultNumberFmt(LCID lcid, NUMBERFMT* pFmt, int cchDecimalSep,
  30.                          int cchThousandSep)
  31. {
  32.     TCHAR szBuf[80];
  33.  
  34.     int ret = ::GetLocaleInfo(lcid, LOCALE_IDIGITS, szBuf,
  35.                               ARRAYSIZE(szBuf));
  36.     if (ret == 0)
  37.         return FALSE;
  38.     pFmt->NumDigits = _tcstol(szBuf, NULL, 10);
  39.  
  40.     ret = ::GetLocaleInfo(lcid, LOCALE_ILZERO, szBuf, ARRAYSIZE(szBuf));
  41.     if (ret == 0)
  42.         return FALSE;
  43.     pFmt->LeadingZero = _tcstol(szBuf, NULL, 10);
  44.  
  45.     ret = ::GetLocaleInfo(lcid, LOCALE_SGROUPING, szBuf,
  46.                           ARRAYSIZE(szBuf));
  47.     if (ret == 0)
  48.         return FALSE;
  49.     pFmt->Grouping = GroupingStrToUint(szBuf);
  50.  
  51.     ret = ::GetLocaleInfo(lcid, LOCALE_SDECIMAL, pFmt->lpDecimalSep,
  52.                           cchDecimalSep);
  53.     if (ret == 0)
  54.         return FALSE;
  55.  
  56.     ret = ::GetLocaleInfo(lcid, LOCALE_STHOUSAND, pFmt->lpThousandSep,
  57.                           cchThousandSep);
  58.     if (ret == 0)
  59.         return FALSE;
  60.  
  61.     ret = ::GetLocaleInfo(lcid, LOCALE_INEGNUMBER, szBuf,
  62.                           ARRAYSIZE(szBuf));
  63.     if (ret == 0)
  64.         return FALSE;
  65.     pFmt->NegativeOrder = _tcstol(szBuf, NULL, 10);
  66.  
  67.     return TRUE;
  68. }

Now that we have these functions, we can use them to better control the output from GetNumberFormat(), as in:

  1. // Converts the double value to a localized string for the specified
  2. // locale with the given number of fractional digits.
  3. BOOL DblToLocalizedStr(LCID lcid, double value, int nDigits,
  4.                        LPTSTR szStr, int cchStr)
  5. {
  6.     // Get locale-default NUMBERFMT
  7.     TCHAR szDecimalSep[5];
  8.     TCHAR szThousandSep[5];
  9.  
  10.     NUMBERFMT fmt;
  11.     fmt.lpDecimalSep = szDecimalSep;
  12.     fmt.lpThousandSep = szThousandSep;
  13.     if (!GetDefaultNumberFmt(lcid, &fmt, ARRAYSIZE(szDecimalSep),
  14.                              ARRAYSIZE(szThousandSep)))
  15.         return FALSE;
  16.  
  17.     // Override the NumDigits member of NUMBERFMT
  18.     fmt.NumDigits = nDigits;
  19.  
  20.     // Format the number with the custom NUMBERFMT
  21.     int ret = GetNumberFormatDbl(lcid, 0, value, &fmt, szStr, cchStr);
  22.     return (ret != 0);
  23. }
Jun 16

XmlTextWriter Can Produce Invalid XML

C# 1 Comment »

XmlTextWriter is .NET’s class for writing XML in a forward-only streaming manner. It is highly efficient and is the preferred way to generate XML in .NET in most circumstances. I find XmlTextWriter so useful I wrote a partial C++ implementation of it in Implenting IXmlWriter Series.

Unfortunately, XmlTextWriter isn’t quite as strict as it could be. It will let slip some invalid XML such as duplicate attributes, invalid Unicode characters in the range 0×0 to 0×20, and invalid element and attribute names. You can read about XmlTextWriter’s limitations in the article Customized XML Writer Creation.

If these limitations are an issue for you, I suggest following the instructions in “Customized XML Writer Creation” by writing a custom writer that extends the current XmlTextWriter and adds this functionality. This class can be used directly or passed to any functions which are designed to use XmlTextWriter.

May 24

Vista Does Not Virtualize Creation Of Shell Links

Win32 No Comments »

Windows Vista developers beware: Vista does not perform file virtualization on the creation of shell links. Consider the following code:

  1. // Creates a shell link (a.k.a. shortcut) located at swzLinkFile that
  2. // points to szTargetFile with a description of szDescription.
  3. BOOL CreateLink(LPCTSTR szTargetFile, LPCTSTR szDescription,
  4.                 LPCOLESTR swzLinkFile)
  5. {
  6.     BOOL bRet = FALSE;
  7.  
  8.     IShellLink* psl;
  9.     HRESULT hr = ::CoCreateInstance(CLSID_ShellLink, NULL,
  10.                                     CLSCTX_INPROC_SERVER,
  11.                                     IID_IShellLink,
  12.                                     (void**) &psl);
  13.     if (SUCCEEDED(hr))
  14.     {
  15.         IPersistFile* ppf;
  16.         hr = psl->QueryInterface(IID_IPersistFile, (void**) &ppf);
  17.         if (SUCCEEDED(hr))
  18.         {          
  19.             hr = psl->SetPath(szTargetFile);
  20.             if (SUCCEEDED(hr))
  21.             {
  22.                 hr = psl->SetDescription(szDescription);
  23.                 if (SUCCEEDED(hr))
  24.                 {
  25.                     hr = ppf->Save(swzLinkFile, TRUE);
  26.                     if (SUCCEEDED(hr))
  27.                     {
  28.                         bSuccess = TRUE;
  29.                     }
  30.                 }
  31.             }
  32.             ppf->Release();
  33.         }
  34.         psl->Release();
  35.     }
  36.     return bSuccess;
  37. }
  38.  
  39. // NOTE: Hardcoding C:\\WINDOWS and C:\\Program Files is a bad practice.
  40. // Use something like ::SHGetFolderPath().
  41. BOOL bSuccess = CreateLink
  42.     (
  43.     _T("C:\\WINDOWS\\SYSTEM32\\SOL.EXE"),
  44.     _T("Shortcut to SOL.EXE"),
  45.     L"C:\\Program Files\\sol.lnk")
  46.     );

One might expect that the creation of the file C:\Program Files\sol.lnk would be silently redirected by Vista using file virtualization and CreateLink() would succeed, but it doesn’t — the call to IPersistFile::Save() returns E_ACCESSDENIED.

For more information about developing on Vista, see the document Windows Vista Application Development Requirements for User Account Control Compatibility.

Apr 25

Debugging Crashes in Windows Applications Part 1: The Null Pointer Dereference

Win32 No Comments »

Windows C++ developers remain all too familiar with the standard Windows crash dialog. This post is an attempt to teach developers how to understand the data the crash dialog reports to diagnose difficult issues. A basic understanding of assembly language is assumed; for more background on these topics please read Matt Pietrek’s “Under The Hood” articles in the Microsoft Systems Journal February 1998 and June 1998 issues.

Read the rest of this entry »

Mar 12

MSXML4 Is Going To Be Kill-Bitted

Win32, XML No Comments »

In an effort to EOL MSXML 4 and encourage developers to use MSXML 6, the MSXML team is going to kill-bit MSXML4 in Q4 2007. This means that you will no longer be able to create instances of MSXML 4 from within Internet Explorer.

Be sure to update your applications accordingly. For this, the MSXML team’s post Upgrading to MSXML 6.0 may prove quite useful.

Mar 12

Delta Compression Application Programming Interface

Win32 No Comments »

Apparently Microsoft has an API for just about everything. Today I read about Microsoft’s Delta Compression Application Programming Interface, an API for creating and applying binary diffs. This API looks ideal for building an application’s incremental online update facility.

Feb 01

Win32 Shell Lightweight Utility API (shlwapi.dll)

Win32 No Comments »

The Win32 shell lightweight utility API (shlwapi.dll) is a cornucopia of useful functions. It appears to be Microsoft’s “dumping ground” for functions without a better home. (I believe Microsoft internal DLL ownership also played a part.) Had I known about shlwapi years ago, it would have saved me considerable programming effort.

Particularly useful are SHCreateStreamOnFile, the path family of functions (e.g. PathCombine), and the registry family of functions (e.g. SHRegGetPath).

However, it appears that Microsoft is slowly moving functionality out of shlwapi into other places. For example, many of shlwapi’s string handling functions have better-designed replacements in Microsoft’s safe string library strsafe. Similarly, shlwapi’s SHRegGetValue has been deprecated in favor of advapi32.dll’s RegGetValue.

Be sure to look at all the functionality shlwapi provides — you may find a hidden gem of your own!

Previous Entries Next Entries
WP Theme & Icons by N.Design Studio
Entries RSS Comments RSS Log in