// // Copyright (c) Microsoft Corporation 1993-1995 // // rovcomm.c // // This files contains common utility and helper functions. // // History: // 08-06-93 ScottH Transferred from twin code // 04-26-95 ScottH Transferred and expanded from Briefcase code // 09-21-95 ScottH Ported to NT // #include "proj.h" #include "rovcomm.h" #include extern CHAR const FAR c_szNewline[]; #define DEBUG_PRINT_BUFFER_LEN 1030 #ifdef WINNT // // These are some helper functions for handling Unicode strings // /*---------------------------------------------------------- Purpose: This function converts a wide-char string to a multi-byte string. If pszBuf is non-NULL and the converted string can fit in pszBuf, then *ppszAnsi will point to the given buffer. Otherwise, this function will allocate a buffer that can hold the converted string. If pszWide is NULL, then *ppszAnsi will be freed. Note that pszBuf must be the same pointer between the call that converted the string and the call that frees the string. Returns: TRUE FALSE (if out of memory) Cond: -- */ BOOL PUBLIC AnsiFromUnicode( LPSTR * ppszAnsi, LPCWSTR pwszWide, // NULL to clean up LPSTR pszBuf, int cchBuf) { BOOL bRet; // Convert the string? if (pwszWide) { // Yes; determine the converted string length int cch; LPSTR psz; cch = WideCharToMultiByte(CP_ACP, 0, pwszWide, -1, NULL, 0, NULL, NULL); // String too big, or is there no buffer? if (cch > cchBuf || NULL == pszBuf) { // Yes; allocate space cchBuf = cch + 1; psz = (LPSTR)ALLOCATE_MEMORY( CbFromCchA(cchBuf)); } else { // No; use the provided buffer ASSERT(pszBuf); psz = pszBuf; } if (psz) { // Convert the string cch = WideCharToMultiByte(CP_ACP, 0, pwszWide, -1, psz, cchBuf, NULL, NULL); bRet = (0 < cch); } else { bRet = FALSE; } *ppszAnsi = psz; } else { // No; was this buffer allocated? if (*ppszAnsi && pszBuf != *ppszAnsi) { // Yes; clean up FREE_MEMORY(*ppszAnsi); *ppszAnsi = NULL; } bRet = TRUE; } return bRet; } /*---------------------------------------------------------- Purpose: This function converts a multi-byte string to a wide-char string. If pszBuf is non-NULL and the converted string can fit in pszBuf, then *ppszWide will point to the given buffer. Otherwise, this function will allocate a buffer that can hold the converted string. If pszAnsi is NULL, then *ppszWide will be freed. Note that pszBuf must be the same pointer between the call that converted the string and the call that frees the string. Returns: TRUE FALSE (if out of memory) Cond: -- */ BOOL PUBLIC UnicodeFromAnsi( LPWSTR * ppwszWide, LPCSTR pszAnsi, // NULL to clean up LPWSTR pwszBuf, int cchBuf) { BOOL bRet; // Convert the string? if (pszAnsi) { // Yes; determine the converted string length int cch; LPWSTR pwsz; int cchAnsi = lstrlenA(pszAnsi)+1; cch = MultiByteToWideChar(CP_ACP, 0, pszAnsi, cchAnsi, NULL, 0); // String too big, or is there no buffer? if (cch > cchBuf || NULL == pwszBuf) { // Yes; allocate space cchBuf = cch + 1; pwsz = (LPWSTR)ALLOCATE_MEMORY( CbFromCchW(cchBuf)); } else { // No; use the provided buffer ASSERT(pwszBuf); pwsz = pwszBuf; } if (pwsz) { // Convert the string cch = MultiByteToWideChar(CP_ACP, 0, pszAnsi, cchAnsi, pwsz, cchBuf); bRet = (0 < cch); } else { bRet = FALSE; } *ppwszWide = pwsz; } else { // No; was this buffer allocated? if (*ppwszWide && pwszBuf != *ppwszWide) { // Yes; clean up FREE_MEMORY(*ppwszWide); *ppwszWide = NULL; } bRet = TRUE; } return bRet; } #endif // WINNT #ifndef NOSTRING // WARNING: all of these APIs do not setup DS, so you can not access // any data in the default data seg of this DLL. // // do not create any global variables... talk to chrisg if you don't // understand this //#define STDCALL /*---------------------------------------------------------- Purpose: Case sensitive character comparison for DBCS Returns: FALSE if they match, TRUE if no match Cond: -- */ BOOL NEAR ChrCmp( WORD w1, WORD wMatch) { /* Most of the time this won't match, so test it first for speed. */ if (LOBYTE(w1) == LOBYTE(wMatch)) { if (IsDBCSLeadByte(LOBYTE(w1))) { return(w1 != wMatch); } return FALSE; } return TRUE; } /*---------------------------------------------------------- Purpose: Case insensitive character comparison for DBCS Returns: FALSE if match, TRUE if not Cond: -- */ BOOL NEAR ChrCmpI( WORD w1, WORD wMatch) { CHAR sz1[3], sz2[3]; if (IsDBCSLeadByte(sz1[0] = LOBYTE(w1))) { sz1[1] = HIBYTE(w1); sz1[2] = '\0'; } else sz1[1] = '\0'; *(WORD FAR *)sz2 = wMatch; sz2[2] = '\0'; return lstrcmpiA(sz1, sz2); } #ifndef WIN32 /*---------------------------------------------------------- Purpose: strnicmp Swiped from the C 7.0 runtime sources. Returns: Cond: */ int PUBLIC lstrnicmp( LPCSTR psz1, LPCSTR psz2, UINT count) { int ch1; int ch2; int result = 0; if (count) { do { ch1 = (int)LOWORD(AnsiLower((LPSTR)MAKELONG(*psz1, 0))); ch2 = (int)LOWORD(AnsiLower((LPSTR)MAKELONG(*psz2, 0))); psz1 = AnsiNext(psz1); psz2 = AnsiNext(psz2); } while (--count && ch1 && ch2 && !ChrCmp((WORD)ch1, (WORD)ch2)); result = ch1 - ch2; } return(result); } /*---------------------------------------------------------- Purpose: strncmp Swiped from the C 7.0 runtime sources. Returns: Cond: */ int PUBLIC lstrncmp( LPCSTR psz1, LPCSTR psz2, UINT count) { int ch1; int ch2; int result = 0; if (count) { do { ch1 = (int)*psz1; ch2 = (int)*psz2; psz1 = AnsiNext(psz1); psz2 = AnsiNext(psz2); } while (--count && ch1 && ch2 && !ChrCmp((WORD)ch1, (WORD)ch2)); result = ch1 - ch2; } return(result); } #endif // WIN32 #ifdef WINNT /*---------------------------------------------------------- Purpose: Wide-char wrapper for AnsiToIntA. Returns: see AnsiToIntA Cond: -- */ BOOL PUBLIC AnsiToIntW( LPCWSTR pwszString, int FAR * piRet) { CHAR szBuf[MAX_BUF]; LPSTR pszString; BOOL bRet; pszString = NULL; bRet = AnsiFromUnicode(&pszString, pwszString, szBuf, ARRAYSIZE(szBuf)); if (bRet) { if (pszString == NULL) { bRet = FALSE; } else { bRet = AnsiToIntA(pszString, piRet); AnsiFromUnicode(&pszString, NULL, szBuf, 0); } } return bRet; } /*---------------------------------------------------------- Purpose: Wide-char wrapper for AnsiChrA. Returns: see AnsiChrA Cond: -- */ LPWSTR PUBLIC AnsiChrW( LPCWSTR pwsz, WORD wMatch) { for ( ; *pwsz; pwsz = CharNextW(pwsz)) { if (!ChrCmp(*(WORD FAR *)pwsz, wMatch)) return (LPWSTR)pwsz; } return NULL; } #endif // WINNT /*---------------------------------------------------------- Purpose: Find last occurrence (case sensitive) of wide character in wide-char string. Returns: Pointer to the last occurrence of character in string or NULL if character is not found. Cond: -- */ LPWSTR PUBLIC AnsiRChrW( LPCWSTR pwsz, WORD wMatch) { LPWSTR pwszEnd; if (pwsz && *pwsz) { for (pwszEnd = (LPWSTR)pwsz + lstrlen(pwsz) - 1; pwsz <= pwszEnd; pwszEnd = CharPrevW(pwsz, pwszEnd)) { if (!ChrCmp(*(WORD FAR *)pwszEnd, wMatch)) return(pwszEnd); // CharPrevW() won't go to char preceding pwsz... if (pwsz == pwszEnd) break; } } return(NULL); } /*---------------------------------------------------------- Purpose: My verion of atoi. Supports hexadecimal too. If this function returns FALSE, *piRet is set to 0. Returns: TRUE if the string is a number, or contains a partial number FALSE if the string is not a number Cond: -- */ BOOL PUBLIC AnsiToIntA( LPCSTR pszString, int FAR * piRet) { #define IS_DIGIT(ch) InRange(ch, '0', '9') BOOL bRet; int n; BOOL bNeg = FALSE; LPCSTR psz; LPCSTR pszAdj; // Skip leading whitespace // for (psz = pszString; *psz == ' ' || *psz == '\n' || *psz == '\t'; psz = AnsiNext(psz)) ; // Determine possible explicit signage // if (*psz == '+' || *psz == '-') { bNeg = (*psz == '+') ? FALSE : TRUE; psz++; } // Or is this hexadecimal? // pszAdj = AnsiNext(psz); if (*psz == '0' && (*pszAdj == 'x' || *pszAdj == 'X')) { // Yes // (Never allow negative sign with hexadecimal numbers) bNeg = FALSE; psz = AnsiNext(pszAdj); pszAdj = psz; // Do the conversion // for (n = 0; ; psz = AnsiNext(psz)) { if (IS_DIGIT(*psz)) n = 0x10 * n + *psz - '0'; else { CHAR ch = *psz; int n2; if (ch >= 'a') ch -= 'a' - 'A'; n2 = ch - 'A' + 0xA; if (n2 >= 0xA && n2 <= 0xF) n = 0x10 * n + n2; else break; } } // Return TRUE if there was at least one digit bRet = (psz != pszAdj); } else { // No pszAdj = psz; // Do the conversion for (n = 0; IS_DIGIT(*psz); psz = AnsiNext(psz)) n = 10 * n + *psz - '0'; // Return TRUE if there was at least one digit bRet = (psz != pszAdj); } *piRet = bNeg ? -n : n; return bRet; } /*---------------------------------------------------------- Purpose: Find first occurrence of character in string Returns: Pointer to the first occurrence of ch in Cond: -- */ LPSTR PUBLIC AnsiChrA( LPCSTR psz, WORD wMatch) { for ( ; *psz; psz = AnsiNext(psz)) { if (!ChrCmp(*(WORD FAR *)psz, wMatch)) return (LPSTR)psz; } return NULL; } #endif // NOSTRING #ifndef NODIALOGHELPER /*---------------------------------------------------------- Purpose: Sets the rectangle with the bounding extent of the given string. Returns: Rectangle Cond: -- */ void PUBLIC SetRectFromExtentW( HDC hdc, LPRECT lprect, LPCWSTR lpcwsz) { SIZE size; GetTextExtentPointW(hdc, lpcwsz, lstrlenW(lpcwsz), &size); SetRect(lprect, 0, 0, size.cx, size.cy); } /*---------------------------------------------------------- Purpose: Sets the rectangle with the bounding extent of the given string. Returns: Rectangle Cond: -- */ void PUBLIC SetRectFromExtentA( HDC hdc, LPRECT lprect, LPCSTR lpcsz) { SIZE size; GetTextExtentPointA(hdc, lpcsz, lstrlenA(lpcsz), &size); SetRect(lprect, 0, 0, size.cx, size.cy); } #endif // NODIALOGHELPER #ifndef NODRAWTEXT #pragma data_seg(DATASEG_READONLY) CHAR const FAR c_szEllipses[] = "..."; #pragma data_seg() // Global variables int g_cxLabelMargin = 0; int g_cxBorder = 0; int g_cyBorder = 0; COLORREF g_clrHighlightText = 0; COLORREF g_clrHighlight = 0; COLORREF g_clrWindowText = 0; COLORREF g_clrWindow = 0; HBRUSH g_hbrHighlight = 0; HBRUSH g_hbrWindow = 0; /*---------------------------------------------------------- Purpose: Get the system metrics we need Returns: -- Cond: -- */ void PUBLIC GetCommonMetrics( WPARAM wParam) // wParam from WM_WININICHANGE { if ((wParam == 0) || (wParam == SPI_SETNONCLIENTMETRICS)) { g_cxBorder = GetSystemMetrics(SM_CXBORDER); g_cyBorder = GetSystemMetrics(SM_CYBORDER); g_cxLabelMargin = (g_cxBorder * 2); } } /*---------------------------------------------------------- Purpose: Sees whether the entire string will fit in *prc. If not, compute the numbder of chars that will fit (including ellipses). Returns length of string in *pcchDraw. Taken from COMMCTRL. Returns: TRUE if the string needed ellipses Cond: -- */ BOOL PRIVATE NeedsEllipses( HDC hdc, LPCSTR pszText, RECT * prc, int * pcchDraw, int cxEllipses) { int cchText; int cxRect; int ichMin, ichMax, ichMid; SIZE siz; cxRect = prc->right - prc->left; cchText = lstrlenA(pszText); if (cchText == 0) { *pcchDraw = cchText; return FALSE; } GetTextExtentPointA(hdc, pszText, cchText, &siz); if (siz.cx <= cxRect) { *pcchDraw = cchText; return FALSE; } cxRect -= cxEllipses; // If no room for ellipses, always show first character. // ichMax = 1; if (cxRect > 0) { // Binary search to find character that will fit ichMin = 0; ichMax = cchText; while (ichMin < ichMax) { // Be sure to round up, to make sure we make progress in // the loop if ichMax == ichMin + 1. // ichMid = (ichMin + ichMax + 1) / 2; GetTextExtentPointA(hdc, &pszText[ichMin], ichMid - ichMin, &siz); if (siz.cx < cxRect) { ichMin = ichMid; cxRect -= siz.cx; } else if (siz.cx > cxRect) { ichMax = ichMid - 1; } else { // Exact match up up to ichMid: just exit. // ichMax = ichMid; break; } } // Make sure we always show at least the first character... // if (ichMax < 1) ichMax = 1; } *pcchDraw = ichMax; return TRUE; } #define CCHELLIPSES 3 #define DT_LVWRAP (DT_CENTER | DT_WORDBREAK | DT_NOPREFIX | DT_EDITCONTROL) #ifdef WINNT /*---------------------------------------------------------- Purpose: Wide-char wrapper for MyDrawTextA. Returns: see MyDrawTextA Cond: -- */ void PUBLIC MyDrawTextW( HDC hdc, LPCWSTR pwszText, RECT FAR* prc, UINT flags, int cyChar, int cxEllipses, COLORREF clrText, COLORREF clrTextBk) { CHAR szBuf[MAX_BUF]; LPSTR pszText; BOOL bRet; pszText = NULL; bRet = AnsiFromUnicode(&pszText, pwszText, szBuf, ARRAYSIZE(szBuf)); if (bRet) { MyDrawTextA(hdc, pszText, prc, flags, cyChar, cxEllipses, clrText, clrTextBk); AnsiFromUnicode(&pszText, NULL, szBuf, 0); } } #endif // WINNT /*---------------------------------------------------------- Purpose: Draws text the shell's way. Taken from COMMCTRL. Returns: -- Cond: This function requires TRANSPARENT background mode and a properly selected font. */ void PUBLIC MyDrawTextA( HDC hdc, LPCSTR pszText, RECT FAR* prc, UINT flags, int cyChar, int cxEllipses, COLORREF clrText, COLORREF clrTextBk) { int cchText; COLORREF clrSave; COLORREF clrSaveBk; UINT uETOFlags = 0; RECT rc; CHAR ach[MAX_PATH + CCHELLIPSES]; // REVIEW: Performance idea: // We could cache the currently selected text color // so we don't have to set and restore it each time // when the color is the same. // if (!pszText) return; rc = *prc; // If needed, add in a little extra margin... // if (IsFlagSet(flags, MDT_EXTRAMARGIN)) { rc.left += g_cxLabelMargin * 3; rc.right -= g_cxLabelMargin * 3; } else { rc.left += g_cxLabelMargin; rc.right -= g_cxLabelMargin; } if (IsFlagSet(flags, MDT_ELLIPSES) && NeedsEllipses(hdc, pszText, &rc, &cchText, cxEllipses)) { hmemcpy(ach, pszText, cchText); lstrcpyA(ach + cchText, c_szEllipses); pszText = ach; // Left-justify, in case there's no room for all of ellipses // ClearFlag(flags, (MDT_RIGHT | MDT_CENTER)); SetFlag(flags, MDT_LEFT); cchText += CCHELLIPSES; } else { cchText = lstrlenA(pszText); } if (IsFlagSet(flags, MDT_TRANSPARENT)) { clrSave = SetTextColor(hdc, 0x000000); } else { uETOFlags |= ETO_OPAQUE; if (IsFlagSet(flags, MDT_SELECTED)) { clrSave = SetTextColor(hdc, g_clrHighlightText); clrSaveBk = SetBkColor(hdc, g_clrHighlight); if (IsFlagSet(flags, MDT_DRAWTEXT)) { FillRect(hdc, prc, g_hbrHighlight); } } else { if (clrText == CLR_DEFAULT && clrTextBk == CLR_DEFAULT) { clrSave = SetTextColor(hdc, g_clrWindowText); clrSaveBk = SetBkColor(hdc, g_clrWindow); if (IsFlagSet(flags, MDT_DRAWTEXT | MDT_DESELECTED)) { FillRect(hdc, prc, g_hbrWindow); } } else { HBRUSH hbr; if (clrText == CLR_DEFAULT) clrText = g_clrWindowText; if (clrTextBk == CLR_DEFAULT) clrTextBk = g_clrWindow; clrSave = SetTextColor(hdc, clrText); clrSaveBk = SetBkColor(hdc, clrTextBk); if (IsFlagSet(flags, MDT_DRAWTEXT | MDT_DESELECTED)) { hbr = CreateSolidBrush(GetNearestColor(hdc, clrTextBk)); if (hbr) { FillRect(hdc, prc, hbr); DeleteObject(hbr); } else FillRect(hdc, prc, GetStockObject(WHITE_BRUSH)); } } } } // If we want the item to display as if it was depressed, we will // offset the text rectangle down and to the left if (IsFlagSet(flags, MDT_DEPRESSED)) OffsetRect(&rc, g_cxBorder, g_cyBorder); if (IsFlagSet(flags, MDT_DRAWTEXT)) { UINT uDTFlags = DT_LVWRAP; if (IsFlagClear(flags, MDT_CLIPPED)) uDTFlags |= DT_NOCLIP; DrawTextA(hdc, pszText, cchText, &rc, uDTFlags); } else { if (IsFlagClear(flags, MDT_LEFT)) { SIZE siz; GetTextExtentPointA(hdc, pszText, cchText, &siz); if (IsFlagSet(flags, MDT_CENTER)) rc.left = (rc.left + rc.right - siz.cx) / 2; else { ASSERT(IsFlagSet(flags, MDT_RIGHT)); rc.left = rc.right - siz.cx; } } if (IsFlagSet(flags, MDT_VCENTER)) { // Center vertically rc.top += (rc.bottom - rc.top - cyChar) / 2; } if (IsFlagSet(flags, MDT_CLIPPED)) uETOFlags |= ETO_CLIPPED; ExtTextOutA(hdc, rc.left, rc.top, uETOFlags, prc, pszText, cchText, NULL); } if (flags & (MDT_SELECTED | MDT_DESELECTED | MDT_TRANSPARENT)) { SetTextColor(hdc, clrSave); if (IsFlagClear(flags, MDT_TRANSPARENT)) SetBkColor(hdc, clrSaveBk); } } #endif // NODRAWTEXT #ifndef NOMESSAGESTRING typedef va_list * LPVA_LIST; #ifdef WINNT #define IsPointerResouceId(_p) (((ULONG_PTR)_p) <= 0xffff) /*---------------------------------------------------------- Purpose: Wide-char version of ConstructVMessageStringA Returns: see ConstructVMessageStringA Cond: -- */ LPWSTR PUBLIC ConstructVMessageStringW( HINSTANCE hinst, LPCWSTR pwszMsg, va_list FAR * ArgList) { WCHAR wszTemp[MAX_BUF]; LPWSTR pwszRet; LPWSTR pwszRes; if (!IsPointerResouceId(pwszMsg)) { pwszRes = (LPWSTR)pwszMsg; } else { if ((((ULONG_PTR)pwszMsg) != 0) && LoadStringW(hinst, (DWORD)(ULONG_PTR)pwszMsg, wszTemp, ARRAYSIZE(wszTemp))) { pwszRes = wszTemp; } else { pwszRes = NULL; } } if (pwszRes) { if (!FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING, pwszRes, 0, 0, (LPWSTR)&pwszRet, 0, (LPVA_LIST)ArgList)) { pwszRet = NULL; } } else { // Bad parameter pwszRet = NULL; } return pwszRet; // free with LocalFree() } /*---------------------------------------------------------- Purpose: Wide-char version of ConstructMessageA. Returns: see ConstructMessageA Cond: -- */ BOOL CPUBLIC ConstructMessageW( LPWSTR FAR * ppwsz, HINSTANCE hinst, LPCWSTR pwszMsg, ...) { BOOL bRet; LPWSTR pwszRet; va_list ArgList; va_start(ArgList, pwszMsg); pwszRet = ConstructVMessageStringW(hinst, pwszMsg, &ArgList); va_end(ArgList); *ppwsz = NULL; if (pwszRet) { bRet = SetStringW(ppwsz, pwszRet); LocalFree(pwszRet); } else bRet = FALSE; return bRet; } /*---------------------------------------------------------- Purpose: Wide-char version of MsgBoxA Returns: See MsgBoxA Cond: -- */ int CPUBLIC MsgBoxW( HINSTANCE hinst, HWND hwndOwner, LPCWSTR pwszText, LPCWSTR pwszCaption, HICON hicon, // May be NULL DWORD dwStyle, ...) { int iRet = -1; int ids; WCHAR wszCaption[MAX_BUF]; LPWSTR pwszRet; va_list ArgList; va_start(ArgList, dwStyle); pwszRet = ConstructVMessageStringW(hinst, pwszText, &ArgList); va_end(ArgList); if (pwszRet) { // Is pszCaption a resource ID? if (IsPointerResouceId(pwszCaption)) { // Yes; load it ids = LOWORD(pwszCaption); SzFromIDSW(hinst, ids, wszCaption, ARRAYSIZE(wszCaption)); pwszCaption = wszCaption; } // Invoke dialog if (pwszCaption) { MSGBOXPARAMSW mbp; mbp.cbSize = sizeof(mbp); mbp.hwndOwner = hwndOwner; mbp.hInstance = hinst; mbp.lpszText = pwszRet; mbp.lpszCaption = pwszCaption; mbp.dwStyle = dwStyle | MB_SETFOREGROUND; mbp.lpszIcon = MAKEINTRESOURCEW(hicon); mbp.lpfnMsgBoxCallback = NULL; mbp.dwLanguageId = LANG_NEUTRAL; iRet = MessageBoxIndirectW(&mbp); } LocalFree(pwszRet); } return iRet; } #endif // WINNT /*---------------------------------------------------------- Purpose: Load the string (if necessary) and format the string properly. Returns: A pointer to the allocated string containing the formatted message or NULL if out of memory Cond: free pointer with FREE_MEMORY() */ LPSTR PUBLIC ConstructVMessageStringA( HINSTANCE hinst, LPCSTR pszMsg, va_list FAR * ArgList) { CHAR szTemp[MAX_BUF]; LPSTR pszRet; LPSTR pszRes; if (!IsPointerResouceId(pszMsg)) { pszRes = (LPSTR)pszMsg; } else { if ((((ULONG_PTR)pszMsg) != 0) && LoadStringA(hinst, (DWORD)(ULONG_PTR)pszMsg, szTemp, ARRAYSIZE(szTemp))) { pszRes = szTemp; } else { pszRes = NULL; } } if (pszRes) { if (!FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING, pszRes, 0, 0, (LPSTR)&pszRet, 0, (LPVA_LIST)ArgList)) { pszRet = NULL; } } else { // Bad parameter pszRet = NULL; } return pszRet; // free with FREE_MEMORY() } /*---------------------------------------------------------- Purpose: Constructs a formatted string. The returned string must be freed using GFree(). Returns: TRUE on success Cond: Free pointer with GFree() */ BOOL CPUBLIC ConstructMessageA( LPSTR FAR * ppsz, HINSTANCE hinst, LPCSTR pszMsg, ...) { BOOL bRet; LPSTR pszRet; va_list ArgList; va_start(ArgList, pszMsg); pszRet = ConstructVMessageStringA(hinst, pszMsg, &ArgList); va_end(ArgList); *ppsz = NULL; if (pszRet) { bRet = SetStringA(ppsz, pszRet); LocalFree(pszRet); } else bRet = FALSE; return bRet; } /*---------------------------------------------------------- Purpose: Invoke a message box. Returns: ID of button that terminated the dialog Cond: -- */ int CPUBLIC MsgBoxA( HINSTANCE hinst, HWND hwndOwner, LPCSTR pszText, LPCSTR pszCaption, HICON hicon, // May be NULL DWORD dwStyle, ...) { int iRet = -1; int ids; CHAR szCaption[MAX_BUF]; LPSTR pszRet; va_list ArgList; va_start(ArgList, dwStyle); pszRet = ConstructVMessageStringA(hinst, pszText, &ArgList); va_end(ArgList); if (pszRet) { // Is pszCaption a resource ID? if (IsPointerResouceId(pszCaption)) { // Yes; load it ids = LOWORD(pszCaption); SzFromIDSA(hinst, ids, szCaption, SIZECHARS(szCaption)); pszCaption = szCaption; } // Invoke dialog if (pszCaption) { #ifdef WIN32 MSGBOXPARAMSA mbp; mbp.cbSize = sizeof(mbp); mbp.hwndOwner = hwndOwner; mbp.hInstance = hinst; mbp.lpszText = pszRet; mbp.lpszCaption = pszCaption; mbp.dwStyle = dwStyle | MB_SETFOREGROUND; mbp.lpszIcon = MAKEINTRESOURCEA(hicon); mbp.lpfnMsgBoxCallback = NULL; mbp.dwLanguageId = LANG_NEUTRAL; iRet = MessageBoxIndirectA(&mbp); #else // WIN32 iRet = MessageBox(hwndOwner, pszRet, pszCaption, LOWORD(dwStyle)); #endif } LocalFree(pszRet); } return iRet; } #endif // NOMESSAGESTRING #if !defined(NODEBUGHELP) && defined(DEBUG) // Globals DWORD g_dwBreakFlags = 0; DWORD g_dwDumpFlags = 0; DWORD g_dwTraceFlags = 0; LONG g_dwIndent = 0; #pragma data_seg(DATASEG_READONLY) #ifdef WINNT extern WCHAR const FAR c_wszNewline[]; extern WCHAR const FAR c_wszTrace[]; extern WCHAR const FAR c_wszAssertFailed[]; #endif // WINNT extern CHAR const FAR c_szNewline[]; extern CHAR const FAR c_szTrace[]; extern CHAR const FAR c_szAssertFailed[]; #pragma data_seg() /*---------------------------------------------------------- Purpose: Return English reason for the debug break Returns: String Cond: -- */ LPCSTR PRIVATE GetReasonString( DWORD flag) // One of BF_ flags { LPCSTR psz; if (IsFlagSet(flag, BF_ONOPEN)) psz = "BREAK ON OPEN\r\n"; else if (IsFlagSet(flag, BF_ONCLOSE)) psz = "BREAK ON CLOSE\r\n"; else if (IsFlagSet(flag, BF_ONRUNONCE)) psz = "BREAK ON RUNONCE\r\n"; else if (IsFlagSet(flag, BF_ONVALIDATE)) psz = "BREAK ON VALIDATION FAILURE\r\n"; else if (IsFlagSet(flag, BF_ONTHREADATT)) psz = "BREAK ON THREAD ATTACH\r\n"; else if (IsFlagSet(flag, BF_ONTHREADDET)) psz = "BREAK ON THREAD DETACH\r\n"; else if (IsFlagSet(flag, BF_ONPROCESSATT)) psz = "BREAK ON PROCESS ATTACH\r\n"; else if (IsFlagSet(flag, BF_ONPROCESSDET)) psz = "BREAK ON PROCESS DETACH\r\n"; else if (IsFlagSet(flag, BF_ONAPIENTER)) psz = "BREAK ON API ENTER\r\n"; else psz = c_szNewline; return psz; } /*---------------------------------------------------------- Purpose: Perform a debug break based on the flag Returns: -- Cond: -- */ void PUBLIC CommonDebugBreak( DWORD flag) // One of BF_ flags { if (IsFlagSet(g_dwBreakFlags, flag)) { TRACE_MSG(TF_ALWAYS, GetReasonString(flag)); DebugBreak(); } } /*---------------------------------------------------------- Purpose: Assert failed Returns: -- Cond: -- */ void PUBLIC CommonAssertFailed( LPCSTR pszFile, int line) { LPCSTR psz; CHAR ach[256]; // Strip off path info from filename string, if present. // for (psz = pszFile + lstrlenA(pszFile); psz != pszFile; psz=AnsiPrev(pszFile, psz)) { if ((AnsiPrev(pszFile, psz) != (psz-2)) && *(psz - 1) == '\\') break; } wsprintfA(ach, c_szAssertFailed, psz, line); OutputDebugStringA(ach); if (IsFlagSet(g_dwBreakFlags, BF_ONVALIDATE)) DebugBreak(); } #ifdef WINNT /*---------------------------------------------------------- Purpose: Determine id debug should be displayed Returns: -- Cond: -- */ BOOL WINAPI DisplayDebug( DWORD flag ) { return (IsFlagSet(g_dwTraceFlags, flag)); } /*---------------------------------------------------------- Purpose: Wide-char version of CommonAssertMsgA Returns: -- Cond: -- */ void CPUBLIC CommonAssertMsgW( BOOL f, LPCWSTR pwszMsg, ...) { WCHAR ach[DEBUG_PRINT_BUFFER_LEN]; // Largest path plus extra va_list vArgs; if (!f) { int cch; lstrcpyW(ach, c_wszTrace); cch = lstrlenW(ach); va_start(vArgs, pwszMsg); wvsprintfW(&ach[cch], pwszMsg, vArgs); va_end(vArgs); OutputDebugStringW(ach); OutputDebugStringW(c_wszNewline); } } /*---------------------------------------------------------- Purpose: Wide-char version of CommonDebugMsgA Returns: -- Cond: -- */ void CPUBLIC CommonDebugMsgW( DWORD flag, LPCSTR pszMsg, ...) { WCHAR ach[DEBUG_PRINT_BUFFER_LEN]; // Largest path plus extra va_list vArgs; DWORD dwLastError = GetLastError (); // Save the last error if (IsFlagSet(g_dwTraceFlags, flag)) { int cch; WCHAR wszBuf[MAX_BUF]; LPWSTR pwsz; WCHAR wszBlank[] = L" "; wszBlank[g_dwIndent < 0 ? 0 : g_dwIndent] = L'\0'; #ifdef PROFILE_TRACES const static WCHAR szTemplate[]=TEXT("[%lu] "); static DWORD dwTickLast; static DWORD dwTickNow = 0; if (!dwTickNow) { lstrcpy(szTemplate, TEXT("[%lu] ")); dwTickLast = GetTickCount(); } dwTickNow = GetTickCount(); wsprintf(ach, szTemplate, dwTickNow - dwTickLast); dwTickLast = dwTickNow; lstrcatW(ach, c_wszTrace); #else lstrcpyW(ach, c_wszTrace); #endif lstrcat(ach,wszBlank); cch = lstrlenW(ach); va_start(vArgs, pszMsg); // (We convert the string, rather than simply input an // LPCWSTR parameter, so the caller doesn't have to wrap // all the string constants with the TEXT() macro.) if (UnicodeFromAnsi(&pwsz, pszMsg, wszBuf, ARRAYSIZE(wszBuf))) { wvsprintfW(&ach[cch], pwsz, vArgs); UnicodeFromAnsi(&pwsz, NULL, wszBuf, 0); } va_end(vArgs); OutputDebugStringW(ach); OutputDebugStringW(c_wszNewline); } SetLastError (dwLastError); // Restore the last error } /*---------------------------------------------------------- Purpose: Wide-char version of Dbg_SafeStrA Returns: String ptr Cond: -- */ LPCWSTR PUBLIC Dbg_SafeStrW( LPCWSTR pwsz) { if (pwsz) return pwsz; else return L"NULL"; } #endif // WINNT /*---------------------------------------------------------- Purpose: Assert failed message only Returns: -- Cond: -- */ void CPUBLIC CommonAssertMsgA( BOOL f, LPCSTR pszMsg, ...) { CHAR ach[DEBUG_PRINT_BUFFER_LEN]; // Largest path plus extra va_list vArgs; if (!f) { int cch; lstrcpyA(ach, c_szTrace); cch = lstrlenA(ach); va_start(vArgs, pszMsg); wvsprintfA(&ach[cch], pszMsg, vArgs); va_end(vArgs); OutputDebugStringA(ach); OutputDebugStringA(c_szNewline); } } /*---------------------------------------------------------- Purpose: Debug spew Returns: -- Cond: -- */ void CPUBLIC CommonDebugMsgA( DWORD flag, LPCSTR pszMsg, ...) { CHAR ach[DEBUG_PRINT_BUFFER_LEN]; // Largest path plus extra va_list vArgs; DWORD dwLastError = GetLastError (); if (IsFlagSet(g_dwTraceFlags, flag)) { int cch; char szBlank[] = " "; ASSERT( g_dwIndent >= 0); szBlank[g_dwIndent < 0 ? 0 : g_dwIndent] = 0; lstrcpyA(ach, c_szTrace); lstrcatA(ach, szBlank); cch = lstrlenA(ach); va_start(vArgs, pszMsg); wvsprintfA(&ach[cch], pszMsg, vArgs); va_end(vArgs); OutputDebugStringA(ach); OutputDebugStringA(c_szNewline); } SetLastError (dwLastError); } #ifdef WANT_OLE_SUPPORT /*---------------------------------------------------------- Purpose: Returns the string form of an known interface ID. Returns: String ptr Cond: -- */ LPCSTR PUBLIC Dbg_GetRiidName( REFIID riid) { int i; for (i = 0; i < ARRAYSIZE(c_rgriidmap); i++) { if (IsEqualIID(riid, c_rgriidmap[i].riid)) return c_rgriidmap[i].psz; } return "Unknown riid"; } #endif #ifdef __SCODE_H__ /*---------------------------------------------------------- Purpose: Returns the string form of an scode given an hresult. Returns: String ptr Cond: -- */ LPCSTR PUBLIC Dbg_GetScode( HRESULT hres) { int i; SCODE sc; sc = GetScode(hres); for (i = 0; i < ARRAYSIZE(c_rgscodemap); i++) { if (sc == c_rgscodemap[i].sc) return c_rgscodemap[i].psz; } return "Unknown scode"; } #endif // __SCODE_H__ /*---------------------------------------------------------- Purpose: Returns a string safe enough to print...and I don't mean swear words. Returns: String ptr Cond: -- */ LPCSTR PUBLIC Dbg_SafeStrA( LPCSTR psz) { if (psz) return psz; else return "NULL"; } #endif // !defined(NODEBUGHELP) && defined(DEBUG) /*---------------------------------------------------------- Purpose: Entry-point to handle any necessary initialization of the common data structures and functions. Returns: TRUE on success Cond: -- */ BOOL PUBLIC RovComm_Init( HINSTANCE hinst) { BOOL bRet = TRUE; #ifndef NODRAWTEXT GetCommonMetrics(0); #endif bRet = RovComm_ProcessIniFile(); return bRet; } /*---------------------------------------------------------- Purpose: Entry-point to handle termination. Returns: TRUE on success Cond: -- */ BOOL PUBLIC RovComm_Terminate( HINSTANCE hinst) { return TRUE; } /*---------------------------------------------------------- Purpose: Returns TRUE iff user has admin priveleges Returns: -- Cond: -- */ BOOL PUBLIC IsAdminUser(void) { HKEY hkey; if(RegOpenKeyEx(HKEY_USERS, TEXT(".DEFAULT"), 0, KEY_WRITE, &hkey) == 0) { RegCloseKey(hkey); return TRUE; } return FALSE; }