945 lines
22 KiB
C++
945 lines
22 KiB
C++
//
|
|
// Util.cpp
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "Util.h"
|
|
#include "theapp.h"
|
|
#include <stdarg.h>
|
|
#include <shlobj.h>
|
|
|
|
|
|
LPTSTR lstrchr(LPCTSTR pszString, TCHAR ch)
|
|
{
|
|
while (*pszString != _T('\0'))
|
|
{
|
|
if (*pszString == ch)
|
|
return (LPTSTR)pszString;
|
|
pszString = CharNext(pszString);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
LPTSTR lstrdup(LPCTSTR psz)
|
|
{
|
|
LPTSTR pszResult = (LPTSTR)malloc((lstrlen(psz)+1) * sizeof(TCHAR));
|
|
if (pszResult != NULL)
|
|
lstrcpy(pszResult, psz);
|
|
return pszResult;
|
|
}
|
|
|
|
void ReplaceString(LPTSTR& pszTarget, LPCTSTR pszSource)
|
|
{
|
|
free(pszTarget);
|
|
pszTarget = lstrdup(pszSource);
|
|
}
|
|
|
|
BOOL MyIsDigit(TCHAR ch)
|
|
{
|
|
return ((UINT)ch - (UINT)_T('0')) <= 9;
|
|
}
|
|
|
|
// A version of atoi that doesn't use the CRT
|
|
int MyAtoi(LPCTSTR psz)
|
|
{
|
|
int result = 0;
|
|
UINT digit;
|
|
|
|
TCHAR chSign = *psz;
|
|
if (*psz == _T('-') || *psz == _T('+'))
|
|
psz += 1;
|
|
|
|
while ((digit = (UINT)((int)*psz - (int)_T('0'))) <= 9)
|
|
{
|
|
result = (result * 10) + (int)digit;
|
|
psz += 1;
|
|
}
|
|
|
|
if (chSign == _T('-'))
|
|
result = -result;
|
|
|
|
return result;
|
|
}
|
|
|
|
// CountChars
|
|
//
|
|
// Returns the number of times the given character appears in the
|
|
// string.
|
|
//
|
|
// 2/03/1999 KenSh Created
|
|
//
|
|
int CountChars(LPCTSTR psz, TCHAR ch)
|
|
{
|
|
int count = 0;
|
|
|
|
while (*psz != _T('\0'))
|
|
{
|
|
if (*psz == ch)
|
|
count++;
|
|
psz = CharNext(psz);
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
|
|
// GetFirstToken
|
|
//
|
|
// Copies the characters up to but not including the separator char, and
|
|
// advances the source pointer to the character after the separator char.
|
|
// Returns TRUE if a token was found, FALSE if not.
|
|
//
|
|
BOOL GetFirstToken(LPCTSTR& pszList, TCHAR chSeparator, LPTSTR pszBuf, int cchBuf)
|
|
{
|
|
if (pszList == NULL || *pszList == '\0')
|
|
{
|
|
*pszBuf = '\0';
|
|
return FALSE;
|
|
}
|
|
|
|
LPTSTR pchComma = lstrchr(pszList, chSeparator);
|
|
int cchCopy;
|
|
int cchSkip;
|
|
if (pchComma == NULL)
|
|
{
|
|
cchCopy = lstrlen(pszList);
|
|
cchSkip = cchCopy;
|
|
}
|
|
else
|
|
{
|
|
cchCopy = (int)(pchComma - pszList);
|
|
cchSkip = cchCopy + 1;
|
|
}
|
|
|
|
cchCopy += 1;
|
|
if (cchCopy > cchBuf)
|
|
cchCopy = cchBuf;
|
|
lstrcpyn(pszBuf, pszList, cchCopy);
|
|
|
|
pszList += cchSkip;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Use this function for initializing multiple DLL procs
|
|
// pszFunction names is a series of null-separated proc names, followed by an extra null
|
|
BOOL LoadDllFunctions(LPCTSTR pszDll, LPCSTR pszFunctionNames, FARPROC* prgFunctions)
|
|
{
|
|
UINT uPrevMode = SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
|
|
HINSTANCE hInst = LoadLibrary(pszDll);
|
|
SetErrorMode(uPrevMode);
|
|
|
|
if (hInst == NULL)
|
|
{
|
|
ASSERT(FALSE);
|
|
return FALSE;
|
|
}
|
|
|
|
while (*pszFunctionNames != '\0')
|
|
{
|
|
*prgFunctions = GetProcAddress(hInst, pszFunctionNames);
|
|
if (*prgFunctions == NULL)
|
|
{
|
|
ASSERT(FALSE);
|
|
return FALSE;
|
|
}
|
|
|
|
pszFunctionNames += (lstrlenA(pszFunctionNames) + 1);
|
|
prgFunctions += 1;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
int MakePath(LPTSTR pszBuf, LPCTSTR pszFolder, LPCTSTR pszFileTitle)
|
|
{
|
|
lstrcpy(pszBuf, pszFolder);
|
|
int cch = lstrlen(pszBuf);
|
|
if (pszBuf[cch-1] != _T('\\'))
|
|
pszBuf[cch++] = _T('\\');
|
|
lstrcpy(pszBuf + cch, pszFileTitle);
|
|
return lstrlen(pszBuf);
|
|
}
|
|
|
|
// pszLinkTarget - where the link will point
|
|
// pszDescription - link's description
|
|
// pszFolderPath - path to folder to create file in or fully qualified file path to create
|
|
// pszFileName - name of file to create in pszFolderPath or NULL to indicate pszFolderPath is already a file path
|
|
//
|
|
|
|
#ifndef NO_MAKELNKFILE
|
|
|
|
HRESULT MakeLnkFile(CLSID clsid, LPCTSTR pszLinkTarget, LPCTSTR pszDescription, LPCTSTR pszFolderPath, LPCTSTR pszFileName)
|
|
{
|
|
HRESULT hresCoInit = CoInitialize(NULL); // we will create a COM object
|
|
|
|
IUnknown *punk;
|
|
HRESULT hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IUnknown, &punk));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IShellLinkW * pslW;
|
|
hr = punk->QueryInterface(IID_PPV_ARG(IShellLinkW, &pslW));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//WCHAR szBuffer[MAX_PATH];
|
|
//SHTCharToUnicode(pszLinkTarget, szBuffer, ARRAYSIZE(szBuffer));
|
|
pslW->SetPath(pszLinkTarget);
|
|
if (pszDescription)
|
|
{
|
|
//SHTCharToUnicode(pszDescription, szBuffer, ARRAYSIZE(szBuffer));
|
|
pslW->SetDescription(pszDescription);
|
|
}
|
|
pslW->Release();
|
|
}
|
|
else
|
|
{
|
|
IShellLinkA * pslA;
|
|
hr = punk->QueryInterface(IID_PPV_ARG(IShellLinkA, &pslA));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
char szBuffer[MAX_PATH];
|
|
SHTCharToAnsi(pszLinkTarget, szBuffer, ARRAYSIZE(szBuffer));
|
|
pslA->SetPath(szBuffer);
|
|
|
|
if (pszDescription)
|
|
{
|
|
SHTCharToAnsi(pszDescription, szBuffer, ARRAYSIZE(szBuffer));
|
|
pslA->SetDescription(szBuffer);
|
|
}
|
|
|
|
pslA->Release();
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IPersistFile *ppf;
|
|
hr = punk->QueryInterface(IID_PPV_ARG(IPersistFile, &ppf));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
if (!pszFileName)
|
|
{
|
|
MakePath(szPath, pszFolderPath, pszFileName);
|
|
pszFolderPath = szPath;
|
|
}
|
|
|
|
//WCHAR szFolderPath[MAX_PATH];
|
|
//SHTCharToUnicode(pszFolderPath, szFolderPath, ARRAYSIZE(szFolderPath));
|
|
hr = ppf->Save(pszFolderPath, TRUE);
|
|
ppf->Release();
|
|
}
|
|
}
|
|
|
|
punk->Release();
|
|
}
|
|
|
|
if (SUCCEEDED(hresCoInit))
|
|
CoUninitialize();
|
|
|
|
return hr;
|
|
}
|
|
|
|
#endif
|
|
|
|
// FindPartialPath
|
|
//
|
|
// Returns a pointer to the file title preceded by nDepth levels of
|
|
// directory names (zero == file title only). If the path has less than
|
|
// nDepth levels, a pointer to the beginning of the string is returned.
|
|
// NULL is never returned.
|
|
//
|
|
// 10/18/1996 KenSh Created
|
|
//
|
|
LPTSTR FindPartialPath(LPCTSTR pszFullPath, int nDepth)
|
|
{
|
|
#define MAX_SLASHES (MAX_PATH / 2) // No more slashes than this in the path
|
|
|
|
LPTSTR pch;
|
|
LPTSTR rgpchSlashes[MAX_SLASHES];
|
|
int cSlashes = 0;
|
|
|
|
for (pch = (LPTSTR)pszFullPath; *pch; pch = CharNext(pch))
|
|
{
|
|
if (*pch == _T('\\') || *pch == _T('/'))
|
|
{
|
|
rgpchSlashes[cSlashes++] = pch;
|
|
}
|
|
}
|
|
|
|
if (cSlashes > nDepth)
|
|
{
|
|
return rgpchSlashes[cSlashes-nDepth-1] + 1;
|
|
}
|
|
else
|
|
{
|
|
// Not enough slashes - return the full path
|
|
return (LPTSTR)pszFullPath;
|
|
}
|
|
}
|
|
|
|
// FindFileTitle
|
|
//
|
|
// Given a full pathname or URL, returns a pointer to the file title. If
|
|
// the given does not contain path information, a pointer to the beginning
|
|
// of the string is returned. NULL is never returned.
|
|
//
|
|
// 4/19/1996 KenSh Created
|
|
//
|
|
LPTSTR FindFileTitle(LPCTSTR pszFullPath)
|
|
{
|
|
LPTSTR pch;
|
|
LPTSTR pchSlash = NULL;
|
|
|
|
for (pch = (LPTSTR)pszFullPath; *pch; pch = CharNext(pch))
|
|
{
|
|
if (*pch == _T('\\') || *pch == _T('/'))
|
|
pchSlash = pch;
|
|
}
|
|
|
|
if (pchSlash)
|
|
return pchSlash+1;
|
|
else
|
|
return (LPTSTR)pszFullPath;
|
|
}
|
|
|
|
// FindExtension
|
|
//
|
|
// Given a path, returns a pointer to its file extension (the character
|
|
// following the "."). If there is no extension, the return value is
|
|
// a pointer to the end of the string ('\0' character).
|
|
//
|
|
// 3/04/1996 KenSh Created
|
|
// 11/17/1997 KenSh Fixed case where path has "." but the filename doesn't
|
|
//
|
|
LPTSTR FindExtension(LPCTSTR pszFileName)
|
|
{
|
|
// Start with the file title
|
|
LPTSTR pch = FindFileTitle(pszFileName);
|
|
LPTSTR pchDot = NULL;
|
|
|
|
// Find the last "." in the filename
|
|
while (*pch)
|
|
{
|
|
if (*pch == _T('.'))
|
|
pchDot = pch;
|
|
pch = CharNext(pch);
|
|
}
|
|
|
|
if (pchDot)
|
|
return pchDot+1;
|
|
else
|
|
return pch; // empty string
|
|
}
|
|
|
|
|
|
// IsFullPath
|
|
//
|
|
// Returns nonzero if the given path is a fully qualified path starting
|
|
// with "X:\" or "\\"
|
|
//
|
|
// 5/19/1999 KenSh Created
|
|
//
|
|
BOOL IsFullPath(LPCTSTR pszPath)
|
|
{
|
|
if ((*pszPath == '\\' && *(pszPath+1) == '\\') ||
|
|
(*pszPath != '\0' && *(pszPath+1) == ':' && *(pszPath+2) == '\\'))
|
|
{
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
void ShowDlgItem(HWND hwndDlg, int nCtrlID, int nCmdShow)
|
|
{
|
|
ShowWindow(GetDlgItem(hwndDlg, nCtrlID), nCmdShow);
|
|
}
|
|
|
|
|
|
// GetDlgItemRect
|
|
//
|
|
// Retrieves the bounding rect of the dialog item relative to the top left
|
|
// corner of the dialog's client area.
|
|
//
|
|
// 10/13/1997 KenSh Created
|
|
//
|
|
HWND GetDlgItemRect(HWND hwndDlg, int nCtrlID, RECT* pRect)
|
|
{
|
|
ASSERT(IsWindow(hwndDlg));
|
|
ASSERT(pRect);
|
|
|
|
HWND hwndCtrl = GetDlgItem(hwndDlg, nCtrlID);
|
|
if (hwndCtrl != NULL)
|
|
{
|
|
POINT ptTopLeft;
|
|
ptTopLeft.x = ptTopLeft.y = 0;
|
|
ClientToScreen(hwndDlg, &ptTopLeft);
|
|
GetWindowRect(hwndCtrl, pRect);
|
|
OffsetRect(pRect, -ptTopLeft.x, -ptTopLeft.y);
|
|
}
|
|
return hwndCtrl;
|
|
}
|
|
|
|
|
|
// GetRelativeRect
|
|
//
|
|
// Retrieves the bounding rect of the window relative to the top left
|
|
// corner of its parent client area.
|
|
//
|
|
// 1/04/2000 KenSh Created
|
|
//
|
|
void GetRelativeRect(HWND hwndCtrl, RECT* pRect)
|
|
{
|
|
ASSERT(IsWindow(hwndCtrl));
|
|
ASSERT(pRect != NULL);
|
|
|
|
HWND hwndParent = GetParent(hwndCtrl);
|
|
POINT ptTopLeft = { 0, 0 };
|
|
ClientToScreen(hwndParent, &ptTopLeft);
|
|
GetWindowRect(hwndCtrl, pRect);
|
|
OffsetRect(pRect, -ptTopLeft.x, -ptTopLeft.y);
|
|
}
|
|
|
|
|
|
// SetDlgItemRect
|
|
//
|
|
// Updates the position and size of a dialog item to the given rectangle,
|
|
// in coordinates relative to the top left corner of the dialog's client area.
|
|
//
|
|
// 3/17/1999 KenSh Created
|
|
//
|
|
void SetDlgItemRect(HWND hwndDlg, int nCtrlID, CONST RECT* pRect)
|
|
{
|
|
ASSERT(IsWindow(hwndDlg));
|
|
ASSERT(GetDlgItem(hwndDlg, nCtrlID));
|
|
ASSERT(pRect);
|
|
|
|
SetWindowPos(GetDlgItem(hwndDlg, nCtrlID), NULL, pRect->left, pRect->top,
|
|
pRect->right - pRect->left, pRect->bottom - pRect->top,
|
|
SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
|
|
|
|
// FormatDlgItemText
|
|
//
|
|
// Works like wsprintf to change the text of an existing dialog control.
|
|
// If pszFormat is non-NULL, it contains the formatting string.
|
|
// If pszFormat is NULL, then the existing control text is used as the
|
|
// format string.
|
|
//
|
|
// 9/22/1999 KenSh Created
|
|
//
|
|
BOOL __cdecl FormatDlgItemText(HWND hwnd, int nCtrlID, LPCTSTR pszFormat, ...)
|
|
{
|
|
HWND hwndCtrl = GetDlgItem(hwnd, nCtrlID);
|
|
if (NULL == hwndCtrl)
|
|
return FALSE;
|
|
|
|
va_list argList;
|
|
va_start(argList, pszFormat);
|
|
|
|
FormatWindowTextV(hwndCtrl, pszFormat, argList);
|
|
return TRUE;
|
|
}
|
|
|
|
// FormatWindowTextV
|
|
//
|
|
// Combines the functionality of wvsprintf with SetWindowText, automatically
|
|
// allocating a buffer large enough to hold the expanded string, and freeing
|
|
// the buffer after setting the window text.
|
|
//
|
|
// 9/22/1999 KenSh Created
|
|
//
|
|
void FormatWindowTextV(HWND hwnd, LPCTSTR pszFormat, va_list argList)
|
|
{
|
|
LPTSTR pszWindowText = NULL;
|
|
|
|
if (pszFormat == NULL)
|
|
{
|
|
int cchWindowText = GetWindowTextLength(hwnd) + 1;
|
|
pszWindowText = (LPTSTR)malloc(cchWindowText * sizeof(TCHAR));
|
|
if (pszWindowText)
|
|
{
|
|
GetWindowText(hwnd, pszWindowText, cchWindowText);
|
|
pszFormat = pszWindowText;
|
|
}
|
|
}
|
|
|
|
if (pszFormat)
|
|
{
|
|
int cchNeeded = EstimateFormatLength(pszFormat, argList);
|
|
LPTSTR pszBuf = (LPTSTR)malloc(cchNeeded * sizeof(TCHAR));
|
|
if (pszBuf)
|
|
{
|
|
#ifdef UNICODE
|
|
wvnsprintf(pszBuf, cchNeeded, pszFormat, argList);
|
|
#else
|
|
wvsprintf(pszBuf, pszFormat, argList);
|
|
#endif
|
|
SetWindowText(hwnd, pszBuf);
|
|
free(pszBuf);
|
|
}
|
|
}
|
|
|
|
if (pszWindowText != NULL)
|
|
{
|
|
free(pszWindowText);
|
|
}
|
|
}
|
|
|
|
LPTSTR __cdecl LoadStringFormat(HINSTANCE hInstance, UINT nStringID, ...)
|
|
{
|
|
LPTSTR pszBuf = NULL;
|
|
LPTSTR pszFormat = LoadStringAlloc(hInstance, nStringID);
|
|
if (pszFormat)
|
|
{
|
|
va_list argList;
|
|
va_start(argList, nStringID);
|
|
|
|
int cchNeeded = EstimateFormatLength(pszFormat, argList);
|
|
LPTSTR pszBuf = (LPTSTR)malloc(cchNeeded * sizeof(TCHAR));
|
|
if (pszBuf)
|
|
{
|
|
#ifdef UNICODE
|
|
wvnsprintf(pszBuf, cchNeeded, pszFormat, argList);
|
|
#else
|
|
wvsprintf(pszBuf, pszFormat, argList);
|
|
#endif
|
|
}
|
|
|
|
free(pszFormat);
|
|
}
|
|
return pszBuf;
|
|
}
|
|
|
|
// EstimateFormatLength
|
|
//
|
|
// Estimates the number of characters needed to format the string,
|
|
// including the terminating NULL.
|
|
//
|
|
// 9/22/1999 KenSh Created
|
|
//
|
|
int EstimateFormatLength(LPCTSTR pszFormat, va_list argList)
|
|
{
|
|
ASSERT(pszFormat != NULL);
|
|
|
|
int cch = lstrlen(pszFormat) + 1;
|
|
for (LPCTSTR pch = pszFormat; *pch; pch = CharNext(pch))
|
|
{
|
|
if (*pch == _T('%'))
|
|
{
|
|
pch++;
|
|
if (*pch == _T('-')) // we don't care about left vs. right justification
|
|
pch++;
|
|
|
|
if (*pch == _T('#')) // prefix hex numbers with 0x
|
|
{
|
|
pch++;
|
|
cch += 2;
|
|
}
|
|
|
|
if (*pch == _T('0')) // pads with zeroes instead of spaces
|
|
pch++;
|
|
|
|
if (MyIsDigit(*pch))
|
|
{
|
|
cch += MyAtoi(pch); // this overshoots but that's ok
|
|
do
|
|
{
|
|
pch++;
|
|
} while (MyIsDigit(*pch));
|
|
}
|
|
|
|
switch (*pch)
|
|
{
|
|
case _T('s'):
|
|
cch += lstrlen(va_arg(argList, LPCTSTR)) - 2;
|
|
break;
|
|
|
|
case _T('c'):
|
|
case _T('C'):
|
|
va_arg(argList, TCHAR);
|
|
cch -= 1;
|
|
break;
|
|
|
|
case _T('d'):
|
|
va_arg(argList, int);
|
|
cch += INT_CCH_MAX - 2;
|
|
break;
|
|
|
|
case _T('h'):
|
|
pch++;
|
|
ASSERT(*pch == _T('d') || *pch == _T('u')); // other forms of 'h' not implemented!
|
|
cch += SHORT_CCH_MAX - 2;
|
|
break;
|
|
|
|
case _T('l'):
|
|
pch++;
|
|
if (*pch == _T('d') || *pch == _T('i'))
|
|
cch += LONG_CCH_MAX - 2;
|
|
else if (*pch == _T('x') || *pch == _T('X'))
|
|
cch += LONGX_CCH_MAX - 2;
|
|
else
|
|
ASSERT(FALSE); // other forms of 'l' not implemented!
|
|
break;
|
|
|
|
default:
|
|
ASSERT(FALSE); // other
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return cch;
|
|
}
|
|
|
|
// CenterWindow
|
|
//
|
|
// Centers the given window relative to its parent window. If the parent
|
|
// is NULL, the window is centered over the desktop excluding the taskbar.
|
|
//
|
|
// 9/24/1999 KenSh Created
|
|
//
|
|
void CenterWindow(HWND hwnd)
|
|
{
|
|
RECT rcWindow;
|
|
RECT rcDesktop;
|
|
GetWindowRect(hwnd, &rcWindow);
|
|
|
|
HWND hwndParent = GetParent(hwnd);
|
|
if (hwndParent == NULL)
|
|
{
|
|
SystemParametersInfo(SPI_GETWORKAREA, sizeof(RECT), &rcDesktop, FALSE);
|
|
}
|
|
else
|
|
{
|
|
GetWindowRect(hwndParent, &rcDesktop);
|
|
}
|
|
|
|
int cxWindow = rcWindow.right - rcWindow.left;
|
|
int cyWindow = rcWindow.bottom - rcWindow.top;
|
|
int x = (rcDesktop.left + rcDesktop.right - cxWindow) / 2;
|
|
int y = (rcDesktop.top + rcDesktop.bottom - cyWindow) / 2;
|
|
SetWindowPos(hwnd, NULL, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
|
|
|
|
// FindResourceString
|
|
//
|
|
// Returns a pointer to the given string resource in memory, or NULL
|
|
// if the string does not exist. Note that the string is in Unicode,
|
|
// and is not NULL-terminated.
|
|
//
|
|
// 3/17/1999 KenSh Created
|
|
//
|
|
LPCWSTR FindResourceString(HINSTANCE hInstance, UINT nStringID, int* pcchString, WORD wLangID)
|
|
{
|
|
ASSERT(pcchString != NULL);
|
|
*pcchString = 0;
|
|
|
|
HRSRC hRsrc = FindResourceEx(hInstance, RT_STRING, MAKEINTRESOURCE((nStringID/16)+1), wLangID);
|
|
if (hRsrc == NULL)
|
|
return NULL;
|
|
|
|
DWORD cbStringTable = SizeofResource(hInstance, hRsrc);
|
|
HGLOBAL hGlb = LoadResource(hInstance, hRsrc);
|
|
LPBYTE pbData = (LPBYTE)LockResource(hGlb);
|
|
LPBYTE pbEnd = pbData + cbStringTable;
|
|
|
|
// Skip strings preceding desired one
|
|
int iString = (int)nStringID % 16;
|
|
for (int i = 0; i < iString; i++)
|
|
{
|
|
int cch = (int)*((LPWORD)pbData);
|
|
pbData += sizeof(WORD) + (sizeof(WCHAR) * cch);
|
|
if (pbData >= pbEnd)
|
|
return NULL;
|
|
}
|
|
|
|
if (pbData + sizeof(WORD) >= pbEnd)
|
|
return NULL;
|
|
|
|
*pcchString = (int)*((LPWORD)pbData);
|
|
pbData += sizeof(WORD);
|
|
|
|
return (LPCWSTR)pbData;
|
|
}
|
|
|
|
|
|
// GetResourceStringLength
|
|
//
|
|
// Finds the given string in the string table, and returns its length
|
|
// in characters, not including room for the terminating NULL.
|
|
//
|
|
// History:
|
|
//
|
|
// 3/17/1999 KenSh Created
|
|
//
|
|
int GetResourceStringLength(HINSTANCE hInstance, UINT nStringID, WORD wLangID)
|
|
{
|
|
int cch;
|
|
FindResourceString(hInstance, nStringID, &cch, wLangID);
|
|
return cch;
|
|
}
|
|
|
|
|
|
// LoadStringHelper
|
|
//
|
|
// Helper function for LoadStringAllocEx.
|
|
//
|
|
// 2/23/1998 KenSh Created
|
|
// 9/27/1999 KenSh changed alloc method from new[] to malloc
|
|
// 12/21/1999 KenSh fixed unicode and DBCS bugs
|
|
//
|
|
int LoadStringHelper(HINSTANCE hInstance, UINT nID, LPTSTR* ppszBuf, int cchBuf, WORD wLangID)
|
|
{
|
|
int cch, cchCopy;
|
|
LPCWSTR pwszString = FindResourceString(hInstance, nID, &cch, wLangID);
|
|
if (pwszString == NULL)
|
|
return 0;
|
|
|
|
if (!(*ppszBuf))
|
|
{
|
|
#ifdef UNICODE
|
|
cchBuf = 1 + cch;
|
|
#else
|
|
cchBuf = 1 + WideCharToMultiByte(CP_ACP, 0, pwszString, cch, NULL, 0, NULL, NULL);
|
|
#endif
|
|
|
|
*ppszBuf = (LPTSTR)malloc(cchBuf * sizeof(TCHAR));
|
|
cchCopy = cch;
|
|
}
|
|
else
|
|
{
|
|
cchCopy = min(cchBuf-1, cch);
|
|
}
|
|
|
|
if (*ppszBuf)
|
|
{
|
|
#ifdef UNICODE
|
|
CopyMemory(*ppszBuf, pwszString, cchCopy * sizeof(WCHAR));
|
|
(*ppszBuf)[cchCopy] = _T('\0');
|
|
#else
|
|
cchCopy = WideCharToMultiByte(CP_ACP, 0, pwszString, cchCopy, *ppszBuf, cchBuf, NULL, NULL);
|
|
(*ppszBuf)[cchCopy] = _T('\0');
|
|
#endif
|
|
|
|
return cchCopy;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// LoadStringAllocEx
|
|
//
|
|
// Finds the string resource with the given ID and language, allocates a
|
|
// buffer using malloc, and copies the string to the buffer. If the
|
|
// string is not found, NULL is returned.
|
|
//
|
|
// 2/24/1998 KenSh Created
|
|
//
|
|
LPTSTR LoadStringAllocEx(HINSTANCE hInstance, UINT nID, WORD wLangID)
|
|
{
|
|
LPTSTR psz = NULL;
|
|
LoadStringHelper(hInstance, nID, &psz, 0, wLangID);
|
|
return psz;
|
|
}
|
|
|
|
void TrimLeft(LPTSTR pszText)
|
|
{
|
|
LPTSTR pch2 = pszText; // will point to first non-space
|
|
while (*pch2 == _T(' '))
|
|
pch2++;
|
|
|
|
// If there's leading space, slide the string down
|
|
if (pch2 != pszText)
|
|
{
|
|
// Note: it's safe to skip CharNext here, since '\0' is immune to DBCS
|
|
while (_T('\0') != (*pszText++ = *pch2++))
|
|
NULL;
|
|
}
|
|
}
|
|
|
|
void TrimRight(LPTSTR pszText)
|
|
{
|
|
LPTSTR pch2 = NULL; // will point to beginning of trailing space
|
|
while (*pszText != _T('\0'))
|
|
{
|
|
if (*pszText == _T(' '))
|
|
{
|
|
if (pch2 == NULL)
|
|
pch2 = pszText;
|
|
}
|
|
else
|
|
{
|
|
// found more non-space, reset the trailing-space pointer
|
|
pch2 = NULL;
|
|
}
|
|
pszText = CharNext(pszText);
|
|
}
|
|
|
|
// Truncate the trailing spaces, if any
|
|
if (pch2 != NULL)
|
|
*pch2 = _T('\0');
|
|
}
|
|
|
|
// RegDeleteKeyAndSubKeys
|
|
//
|
|
// Does what RegDeleteKey should do. (Actually a single call to RegDeleteKey
|
|
// will do this in Win95, but not in NT, according to the docs. Should see
|
|
// if this gets fixed in NT5.)
|
|
//
|
|
// 2/24/1998 KenSh Created
|
|
//
|
|
DWORD RegDeleteKeyAndSubKeys(HKEY hkey, LPCTSTR pszSubKey)
|
|
{
|
|
#if 0 // This might be faster in Win95 than doing it manually, but bigger.
|
|
OSVERSIONINFO osvi;
|
|
osvi.dwOSVersionInfoSize = sizeof(osvi);
|
|
GetVersionEx(&osvi);
|
|
if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT)
|
|
#endif
|
|
{
|
|
HKEY hSubKey;
|
|
LONG err = RegOpenKeyEx(hkey, pszSubKey, 0, KEY_ALL_ACCESS, &hSubKey);
|
|
if (ERROR_SUCCESS == err)
|
|
{
|
|
DWORD dwNumSubKeys;
|
|
RegQueryInfoKey(hSubKey, NULL, NULL, NULL, &dwNumSubKeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
|
|
for (DWORD iSubKey = dwNumSubKeys; iSubKey > 0; iSubKey--)
|
|
{
|
|
TCHAR szSubKey[260];
|
|
DWORD cchSubKey = _countof(szSubKey);
|
|
if (ERROR_SUCCESS == RegEnumKeyEx(hSubKey, iSubKey-1, szSubKey, &cchSubKey, NULL, NULL, NULL, NULL))
|
|
{
|
|
RegDeleteKeyAndSubKeys(hSubKey, szSubKey);
|
|
}
|
|
}
|
|
RegCloseKey(hSubKey);
|
|
}
|
|
}
|
|
|
|
return RegDeleteKey(hkey, pszSubKey);
|
|
}
|
|
|
|
// LoadFile
|
|
//
|
|
// Loads the file and null-terminates the copy in memory. The memory
|
|
// is allocated via malloc().
|
|
//
|
|
// 4/05/1996 KenSh Created
|
|
// 8/27/1996 KenSh Improved error checking
|
|
// 4/21/1997 KenSh Tightened up a bit
|
|
// 2/01/1998 KenSh Append a null-terminating byte
|
|
// 9/29/1999 KenSh use malloc instead of new []
|
|
//
|
|
LPBYTE LoadFile(LPCTSTR pszFileName, DWORD* pdwFileSize /*=NULL*/)
|
|
{
|
|
HANDLE hFile;
|
|
LPBYTE pData = NULL;
|
|
DWORD dwFileSize = 0;
|
|
|
|
hFile = CreateFile( pszFileName, GENERIC_READ, FILE_SHARE_READ, NULL,
|
|
OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL );
|
|
if (hFile == INVALID_HANDLE_VALUE)
|
|
goto done;
|
|
|
|
dwFileSize = GetFileSize(hFile, NULL);
|
|
ASSERT(dwFileSize != 0xFFFFFFFF); // this shouldn't ever happen for valid hFile
|
|
|
|
pData = (LPBYTE)malloc(dwFileSize + 1);
|
|
if (!pData)
|
|
goto done;
|
|
|
|
DWORD cbRead;
|
|
if (!ReadFile(hFile, pData, dwFileSize, &cbRead, NULL))
|
|
{
|
|
free(pData);
|
|
pData = NULL;
|
|
goto done;
|
|
}
|
|
|
|
pData[dwFileSize] = 0;
|
|
|
|
done:
|
|
if (pdwFileSize)
|
|
*pdwFileSize = dwFileSize;
|
|
|
|
if (hFile != INVALID_HANDLE_VALUE)
|
|
CloseHandle(hFile);
|
|
|
|
return pData;
|
|
}
|
|
|
|
// DrawHollowRect
|
|
//
|
|
// Draws a hollow rectangle in the current background color.
|
|
//
|
|
// 2/06/1998 KenSh Created
|
|
//
|
|
void DrawHollowRect(HDC hdc, const RECT* pRect, int cxLeft, int cyTop, int cxRight, int cyBottom)
|
|
{
|
|
RECT rcCopy;
|
|
RECT rcNewCoords;
|
|
int i;
|
|
|
|
CopyRect(&rcCopy, pRect);
|
|
SetRect(&rcNewCoords,
|
|
pRect->right - cxRight,
|
|
pRect->bottom - cyBottom,
|
|
pRect->left + cxLeft,
|
|
pRect->top + cyTop);
|
|
|
|
// Do each side in turn : right, bottom, left, top
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
LONG coordSave = ((LONG*)&rcCopy)[i];
|
|
((LONG*)&rcCopy)[i] = ((LONG*)&rcNewCoords)[i];
|
|
DrawFastRect(hdc, &rcCopy);
|
|
((LONG*)&rcCopy)[i] = coordSave;
|
|
}
|
|
}
|
|
|
|
void DrawFastRect(HDC hdc, const RECT* pRect)
|
|
{
|
|
COLORREF crTextSave = SetTextColor(hdc, GetBkColor(hdc));
|
|
ExtTextOut(hdc, 0, 0, ETO_OPAQUE | ETO_CLIPPED, pRect, TEXT(" "), 1, NULL);
|
|
SetTextColor(hdc, crTextSave);
|
|
}
|
|
|
|
int GetFontHeight(HFONT hFont)
|
|
{
|
|
HDC hdcT = GetDC(NULL);
|
|
HFONT hFontSave = (HFONT)SelectObject(hdcT, hFont);
|
|
TEXTMETRIC tm;
|
|
GetTextMetrics(hdcT, &tm);
|
|
SelectObject(hdcT, hFontSave);
|
|
ReleaseDC(NULL, hdcT);
|
|
return tm.tmHeight;
|
|
}
|
|
|
|
HRESULT MyGetSpecialFolderPath(int nFolder, LPTSTR pszPath)
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
HRESULT hr;
|
|
if (SUCCEEDED(hr = SHGetSpecialFolderLocation(NULL, nFolder, &pidl)))
|
|
{
|
|
hr = SHGetPathFromIDList(pidl, pszPath) ? S_OK : E_FAIL;
|
|
|
|
LPMALLOC pMalloc;
|
|
if (SUCCEEDED(SHGetMalloc(&pMalloc)))
|
|
{
|
|
pMalloc->Free(pidl);
|
|
pMalloc->Release();
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|