able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/themes/themeldr/utils.cpp

1520 lines
42 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//---------------------------------------------------------------------------
// utils.cpp - theme code utilities (shared in "inc" directory)
//---------------------------------------------------------------------------
#include "stdafx.h"
#include <time.h>
#include "utils.h"
#include "cfile.h"
#include "stringtable.h"
//---------------------------------------------------------------------------
HINSTANCE hinstUxCtrl = NULL; // protected by _csUtils
IMAGE_DRAWPROC ImageList_DrawProc = NULL; // protected by _csUtils
IMAGE_LOADPROC ImageList_LoadProc = NULL; // protected by _csUtils
PFNDRAWSHADOWTEXT CCDrawShadowText = NULL;
IMAGE_DESTROYPROC ImageList_DestroyProc = NULL; // protected by _csUtils
int g_iScreenDpi = THEME_DPI; // only initialized
//---------------------------------------------------------------------------
CRITICAL_SECTION _csUtils = {0}; // unprotected (set during init)
//---------------------------------------------------------------------------
#define __ascii_towlower(c) ( (((c) >= L'A') && ((c) <= L'Z')) ? ((c) - L'A' + L'a') : (c) )
// A string compare that explicitely only works on english characters
// This avoids locale problems like Hungarian, without a performance hit.
// NOTE: Intended for theme schema properties. Theme file names, colors styles and size styles
// shouldn't be passed to this function, nor any display name.
int AsciiStrCmpI(const WCHAR *dst, const WCHAR *src)
{
WCHAR f,l;
if (dst == NULL)
{
return src == NULL ? 0 : -1;
}
if (src == NULL)
{
return 1;
}
do {
#ifdef DEBUG
if (*dst > 127 || *src > 127)
{
Log(LOG_ERROR, L"AsciiStrCmpI: Non-Ascii comparing %s and %s", dst, src);
}
#endif
f = (WCHAR)__ascii_towlower(*dst);
l = (WCHAR)__ascii_towlower(*src);
dst++;
src++;
} while ( (f) && (f == l) );
return (int)(f - l);
}
//---------------------------------------------------------------------------
BOOL lstrtoken(LPWSTR psz, WCHAR wch)
{
ATLASSERT(psz != NULL);
LPWSTR p = psz;
while (*p)
{
if (*p == wch)
{
*p = 0;
return TRUE;
}
p = CharNextW(p);
}
return FALSE;
}
//---------------------------------------------------------------------------
BOOL FileExists(LPCWSTR pszFileName)
{
DWORD dwMask = GetFileAttributes(pszFileName);
return (dwMask != 0xffffffff);
}
//---------------------------------------------------------------------------
BOOL UtilsStartUp()
{
InitializeCriticalSection(&_csUtils);
hinstUxCtrl = NULL;
//---- set screen dpi (per session) ----
HDC hdc = GetWindowDC(NULL);
if (hdc)
{
g_iScreenDpi = GetDeviceCaps(hdc, LOGPIXELSX);
ReleaseDC(NULL, hdc);
}
return TRUE;
}
//---------------------------------------------------------------------------
BOOL UtilsShutDown()
{
DeleteCriticalSection(&_csUtils);
if (hinstUxCtrl)
{
FreeLibrary(hinstUxCtrl);
hinstUxCtrl = NULL;
}
return FALSE;
}
//---------------------------------------------------------------------------
void ErrorBox(LPCSTR pszFormat, ...)
{
va_list args;
va_start(args, pszFormat);
char szMsgBuff[2048];
wvsprintfA(szMsgBuff, pszFormat, args);
MessageBoxA(NULL, szMsgBuff, "Error", MB_OK);
va_end(args);
}
//---------------------------------------------------------------------------
HANDLE CmdLineRun(LPCTSTR pszExeName, LPCTSTR pszParams, BOOL fHide)
{
STARTUPINFO si;
memset(&si, 0, sizeof(si));
si.cb = sizeof(STARTUPINFO);
si.dwFlags = STARTF_FORCEOFFFEEDBACK; // don't mess with our cursor
if (fHide)
{
si.dwFlags |= STARTF_USESHOWWINDOW; // hide window
si.wShowWindow = SW_HIDE;
}
PROCESS_INFORMATION pi;
TCHAR pszExeBuff[_MAX_PATH];
TCHAR pszParmsBuff[_MAX_PATH];
// Copy to buffers to avoid AVs
if (pszParams)
{
pszParmsBuff[0] = L'"';
// -1 for trailing NULL, -2 for quotation marks, -1 for space between EXE and args
HRESULT hr = hr_lstrcpy(pszParmsBuff+1, pszExeName, ARRAYSIZE(pszParmsBuff) - 4);
if (FAILED(hr))
return NULL;
int cchUsed = lstrlen(pszParmsBuff);
pszParmsBuff[cchUsed++] = L'"'; // closing quotation mark
pszParmsBuff[cchUsed++] = L' '; // We need a space before the cmd line
hr = hr_lstrcpy(pszParmsBuff + cchUsed, pszParams, ARRAYSIZE(pszParmsBuff) - cchUsed - 1);
if (FAILED(hr))
return NULL;
}
LPTSTR lpFilePart;
if (0 == SearchPath(NULL, pszExeName, NULL, ARRAYSIZE(pszExeBuff), pszExeBuff, &lpFilePart))
return NULL;
BOOL bSuccess = CreateProcess(pszExeBuff, pszParams ? pszParmsBuff : NULL, NULL, NULL,
FALSE, 0, NULL, NULL, &si, &pi);
if (! bSuccess)
return NULL;
return pi.hProcess;
}
//---------------------------------------------------------------------------
HRESULT SyncCmdLineRun(LPCTSTR pszExeName, LPCTSTR pszParams)
{
HANDLE hInst;
hInst = CmdLineRun(pszExeName, pszParams);
if (! hInst)
{
Log(LOG_ALWAYS, L"CmdLineRun failed to create hInst. Cmd=%s", pszExeName);
return MakeError32(E_FAIL); // could not run program
}
HRESULT hr = S_OK;
//---- wait for packthem to terminate ----
DWORD dwVal;
dwVal = WaitForSingleObject(hInst, INFINITE);
if (dwVal != WAIT_OBJECT_0)
{
Log(LOG_ERROR, L"CmdLineRun timed out. Cmd=%s", pszExeName);
hr = MakeError32(E_FAIL); // timed out
goto exit;
}
DWORD dwExitCode;
if (! GetExitCodeProcess(hInst, &dwExitCode))
{
Log(LOG_ALWAYS, L"CmdLineRun failed to get exit code. Cmd=%s", pszExeName);
hr = MakeError32(E_FAIL); // could not get exit code
goto exit;
}
if (dwExitCode)
{
Log(LOG_ALWAYS, L"CmdLineRun returned error. Cmd=%s, ExitCode=%d", pszExeName, dwExitCode);
hr = MakeError32(E_FAIL); // did not complete successfully
goto exit;
}
exit:
CloseHandle(hInst);
return hr;
}
//---------------------------------------------------------------------------
void ForceDesktopRepaint()
{
//---- keep for now (some non-subclassed controls don't repaint otherwise) ----
InvalidateRect(NULL, NULL, TRUE); // all windows
}
//---------------------------------------------------------------------------
// color conversion routines copied from comdlg\color2.c
//---------------------------------------------------------------------------
#define HLSMAX 240
#define RGBMAX 255
#define UNDEFINED (HLSMAX * 2 / 3)
//---------------------------------------------------------------------------
void RGBtoHLS(COLORREF rgb, WORD *pwHue, WORD *pwLum, WORD *pwSat)
{
WORD R, G, B; // input RGB values
WORD cMax,cMin; // max and min RGB values
WORD cSum,cDif;
SHORT Rdelta, Gdelta, Bdelta; // intermediate value: % of spread from max
WORD bHue, bLum, bSat;
//
// get R, G, and B out of DWORD.
//
R = GetRValue(rgb);
G = GetGValue(rgb);
B = GetBValue(rgb);
//
// Calculate lightness.
//
cMax = max(max(R, G), B);
cMin = min(min(R, G), B);
cSum = cMax + cMin;
bLum = (WORD)(((cSum * (DWORD)HLSMAX) + RGBMAX) / (2 * RGBMAX));
cDif = cMax - cMin;
if (!cDif)
{
//
// r = g = b --> Achromatic case.
//
bSat = 0; // saturation
bHue = UNDEFINED; // hue
}
else
{
//
// Chromatic case.
//
//
// Saturation.
//
// Note: Division by cSum is not a problem, as cSum can only
// be 0 if the RGB value is 0L, and that is achromatic.
//
if (bLum <= (HLSMAX / 2))
{
bSat = (WORD)(((cDif * (DWORD) HLSMAX) + (cSum / 2) ) / cSum);
}
else
{
bSat = (WORD)((DWORD)((cDif * (DWORD)HLSMAX) +
(DWORD)((2 * RGBMAX - cSum) / 2)) /
(2 * RGBMAX - cSum));
}
//
// Hue.
//
Rdelta = (SHORT)((((cMax - R) * (DWORD)(HLSMAX / 6)) + (cDif / 2) ) / cDif);
Gdelta = (SHORT)((((cMax - G) * (DWORD)(HLSMAX / 6)) + (cDif / 2) ) / cDif);
Bdelta = (SHORT)((((cMax - B) * (DWORD)(HLSMAX / 6)) + (cDif / 2) ) / cDif);
if (R == cMax)
{
bHue = Bdelta - Gdelta;
}
else if (G == cMax)
{
bHue = (WORD)((HLSMAX / 3) + Rdelta - Bdelta);
}
else // (B == cMax)
{
bHue = (WORD)(((2 * HLSMAX) / 3) + Gdelta - Rdelta);
}
if ((short)bHue < 0)
{
//
// This can occur when R == cMax and G is > B.
//
bHue += HLSMAX;
}
if (bHue >= HLSMAX)
{
bHue -= HLSMAX;
}
}
if (pwHue)
*pwHue = bHue;
if (pwLum)
*pwLum = bLum;
if (pwSat)
*pwSat = bSat;
}
//---------------------------------------------------------------------------
WORD HueToRGB(WORD n1, WORD n2, WORD hue)
{
if (hue >= HLSMAX)
{
hue -= HLSMAX;
}
//
// Return r, g, or b value from this tridrant.
//
if (hue < (HLSMAX / 6))
{
return ((WORD)(n1 + (((n2 - n1) * hue + (HLSMAX / 12)) / (HLSMAX / 6))));
}
if (hue < (HLSMAX/2))
{
return (n2);
}
if (hue < ((HLSMAX*2)/3))
{
return ((WORD)(n1 + (((n2 - n1) * (((HLSMAX * 2) / 3) - hue) +
(HLSMAX / 12)) / (HLSMAX / 6))));
}
else
{
return (n1);
}
}
//---------------------------------------------------------------------------
DWORD HLStoRGB(WORD hue, WORD lum, WORD sat)
{
WORD R, G, B; // RGB component values
WORD Magic1, Magic2; // calculated magic numbers
if (sat == 0)
{
//
// Achromatic case.
//
R = G = B = (WORD)((lum * RGBMAX) / HLSMAX);
}
else
{
//
// Chromatic case
//
//
// Set up magic numbers.
//
if (lum <= (HLSMAX / 2))
{
Magic2 = (WORD)((lum * ((DWORD)HLSMAX + sat) + (HLSMAX / 2)) / HLSMAX);
}
else
{
Magic2 = lum + sat -
(WORD)(((lum * sat) + (DWORD)(HLSMAX / 2)) / HLSMAX);
}
Magic1 = (WORD)(2 * lum - Magic2);
//
// Get RGB, change units from HLSMAX to RGBMAX.
//
R = (WORD)(((HueToRGB(Magic1, Magic2, (WORD)(hue + (HLSMAX / 3))) *
(DWORD)RGBMAX + (HLSMAX / 2))) / HLSMAX);
G = (WORD)(((HueToRGB(Magic1, Magic2, hue) *
(DWORD)RGBMAX + (HLSMAX / 2))) / HLSMAX);
B = (WORD)(((HueToRGB(Magic1, Magic2, (WORD)(hue - (HLSMAX / 3))) *
(DWORD)RGBMAX + (HLSMAX / 2))) / HLSMAX);
}
return (RGB(R, G, B));
}
//---------------------------------------------------------------------------
BOOL GetMyExePath(LPWSTR pszNameBuff)
{
//---- extract the dir that calling program is running in ----
WCHAR filename[_MAX_PATH+1];
GetModuleFileName(NULL, filename, ARRAYSIZE(filename));
WCHAR drive[_MAX_DRIVE], dir[_MAX_DIR], fname[_MAX_FNAME], ext[_MAX_EXT];
_wsplitpath(filename, drive, dir, fname, ext);
wsprintf(pszNameBuff, L"%s%psz", drive, dir);
return TRUE;
}
//---------------------------------------------------------------------------
HRESULT SetFileExt(LPCWSTR pszOrigName, LPCWSTR pszNewExt, OUT LPWSTR pszNewNameBuff)
{
WCHAR drive[_MAX_DRIVE], dir[_MAX_DIR], fname[_MAX_FNAME], ext[_MAX_EXT];
_wsplitpath(pszOrigName, drive, dir, fname, ext);
_wmakepath(pszNewNameBuff, drive, dir, fname, pszNewExt);
return S_OK;
}
//---------------------------------------------------------------------------
HRESULT GetPtrToResource(HINSTANCE hInst, LPCWSTR pszResType, LPCWSTR pszResName,
OUT void **ppBytes, OPTIONAL OUT DWORD *pdwBytes)
{
HRSRC hRsc = FindResource(hInst, pszResName, pszResType);
if (! hRsc)
return MakeErrorLast();
DWORD dwBytes = SizeofResource(hInst, hRsc);
if (! dwBytes)
return MakeErrorLast();
HGLOBAL hGlobal = LoadResource(hInst, hRsc);
if (! hGlobal)
return MakeErrorLast();
void *v = (WCHAR *)LockResource(hGlobal);
if (! v)
return MakeErrorLast();
*ppBytes = v;
if (pdwBytes)
*pdwBytes = dwBytes;
return S_OK;
}
//---------------------------------------------------------------------------
HRESULT GetResString(HINSTANCE hInst, LPCWSTR pszResType, int id, LPWSTR pszBuff,
DWORD dwMaxBuffChars)
{
WCHAR *p;
HRESULT hr = GetPtrToResource(hInst, pszResType, MAKEINTRESOURCE(1), (void **)&p);
if (SUCCEEDED(hr))
{
while ((*p) && (id))
{
p += (1 + lstrlen(p));
id--;
}
if (*p)
{
hr = hr_lstrcpy(pszBuff, p, dwMaxBuffChars);
}
else
{
hr = MakeError32(ERROR_NOT_FOUND);
}
}
return hr;
}
//---------------------------------------------------------------------------
HRESULT AllocateTextResource(HINSTANCE hInst, LPCWSTR pszResName, WCHAR **ppszText)
{
WCHAR *p, *q;
DWORD dwBytes, dwChars;
HRESULT hr;
//---- allocate so that we can add a NULL at the end of the file string ----
hr = GetPtrToResource(hInst, L"TEXTFILE", pszResName, (void **)&p, &dwBytes);
if (FAILED(hr))
goto exit;
dwChars = (dwBytes+1)/2;
if ((dwChars) && (p[0] == 0xfeff)) // remove UNICODE hdr
{
dwChars--;
p++;
}
q = new WCHAR[dwChars+1];
if (!q)
{
hr = MakeError32(E_OUTOFMEMORY);
goto exit;
}
memcpy(q, p, dwChars*sizeof(WCHAR));
q[dwChars] = 0;
*ppszText = q;
exit:
return hr;
}
//---------------------------------------------------------------------------
void ReplChar(LPWSTR pszBuff, WCHAR wOldVal, WCHAR wNewVal)
{
WCHAR *p = pszBuff;
while (*p)
{
if (*p == wOldVal)
*p = wNewVal;
p++;
}
}
//---------------------------------------------------------------------------
WCHAR *StringDup(LPCWSTR pszOrig)
{
int len = lstrlen(pszOrig);
WCHAR *str = new WCHAR[1+len];
if (str)
lstrcpy(str, pszOrig);
return str;
}
//---------------------------------------------------------------------------
void ApplyStringProp(HWND hwnd, LPCWSTR pszStringVal, ATOM atom)
{
if (hwnd)
{
//---- remove previous value ----
ATOM atomStringVal = (ATOM)GetProp(hwnd, (LPCTSTR)atom);
if (atomStringVal)
{
DeleteAtom(atomStringVal); // decrement refcnt
RemoveProp(hwnd, (LPCTSTR)atom);
}
//---- add new string as an atom ----
if (pszStringVal)
{
//---- if string is empty, change it since AddAtom() doesn't ----
//---- support empty strings (returns NULL) ----
if (! *pszStringVal)
pszStringVal = L"$"; // should never compare equal to a class name
atomStringVal = AddAtom(pszStringVal);
if (atomStringVal)
SetProp(hwnd, (LPCTSTR)atom, (void *)atomStringVal);
}
}
}
//---------------------------------------------------------------------------
HRESULT EnsureUxCtrlLoaded()
{
CAutoCS cs(&_csUtils);
if (! hinstUxCtrl)
{
TCHAR szPath[MAX_PATH];
GetModuleFileName(GetModuleHandle(TEXT("UxTheme.dll")), szPath, ARRAYSIZE(szPath));
ACTCTX act = {0};
act.cbSize = sizeof(act);
act.dwFlags = ACTCTX_FLAG_RESOURCE_NAME_VALID;
act.lpResourceName = MAKEINTRESOURCE(1);
act.lpSource = szPath;
HANDLE hActCtx = CreateActCtx(&act);
ULONG_PTR ulCookie = 0;
if (hActCtx != INVALID_HANDLE_VALUE)
ActivateActCtx(hActCtx, &ulCookie);
hinstUxCtrl = LoadLibrary(L"comctl32.dll");
if (ulCookie)
DeactivateActCtx(0, ulCookie);
if (hActCtx != INVALID_HANDLE_VALUE)
ReleaseActCtx(hActCtx);
}
if ((hinstUxCtrl) && (! ImageList_DrawProc))
{
ImageList_DrawProc = (IMAGE_DRAWPROC)GetProcAddress(hinstUxCtrl, "ImageList_DrawIndirect");
#if 1 // testing DrawThemeIcon()
ImageList_LoadProc = (IMAGE_LOADPROC)GetProcAddress(hinstUxCtrl, "ImageList_LoadImage");
ImageList_DestroyProc = (IMAGE_DESTROYPROC)GetProcAddress(hinstUxCtrl, "ImageList_Destroy");
#endif
CCDrawShadowText = (PFNDRAWSHADOWTEXT)GetProcAddress(hinstUxCtrl, "DrawShadowText");
}
if ((ImageList_DrawProc) && (CCDrawShadowText))
return S_OK;
return MakeError32(E_FAIL); // something went wrong
}
//---------------------------------------------------------------------------
BOOL IsUnicode(LPCSTR pszBuff, int *piUnicodeStartOffset)
{
int iOffset = 0;
BOOL fUnicode = FALSE;
if ((pszBuff[0] == 0xff) && (pszBuff[1] == 0xfe)) // unicode marker
{
iOffset = 2;
fUnicode = TRUE;
}
else if (! pszBuff[1])
{
// this check works well for .ini files because of the limited
// legal chars it can start with
fUnicode = TRUE;
}
if (piUnicodeStartOffset)
*piUnicodeStartOffset = iOffset;
return fUnicode;
}
//---------------------------------------------------------------------------
HRESULT AnsiToUnicode(LPSTR pszSource, LPWSTR pszDest, DWORD dwMaxDestChars)
{
int len = 1 + static_cast<int>(strlen(pszSource));
int retval = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, pszSource, len,
pszDest, dwMaxDestChars);
if (! retval)
return MakeErrorLast();
return S_OK;
}
//---------------------------------------------------------------------------
HRESULT AllocateTextFile(LPCWSTR szFileName, OUT LPWSTR *ppszFileText,
OUT OPTIONAL BOOL *pfWasAnsi)
{
HRESULT hr;
CSimpleFile infile;
hr = infile.Open(szFileName);
if (FAILED(hr))
return hr;
//---- read the file ----
DWORD len = infile.GetFileSize();
//---- assume ANSI; adjust if UNICODE ----
DWORD dw;
LPSTR pOrig = (LPSTR) LocalAlloc(0, 2+len); // space for 2-byte UNICODE NULL
if (! pOrig)
return MakeErrorLast();
if (len)
{
hr = infile.Read((LPSTR)pOrig, len, &dw);
if (FAILED(hr))
{
LocalFree(pOrig);
return hr;
}
if (dw != len)
{
LocalFree(pOrig);
return MakeError32(E_FAIL);
}
}
infile.Close();
//---- null terminate for both cases ----
pOrig[len] = 0;
pOrig[len+1] = 0;
int iOffset;
if (IsUnicode(pOrig, &iOffset))
{
if ((iOffset) && (len)) // shift away the UNICODE signature bits
memmove(pOrig, pOrig+iOffset, len-iOffset);
*ppszFileText = (LPWSTR)pOrig;
if (pfWasAnsi)
*pfWasAnsi = FALSE;
return S_OK;
}
//---- need to translate to UNICODE ----
LPWSTR pUnicode = (LPWSTR) LocalAlloc(0, sizeof(WCHAR)*(len+1));
if (! pUnicode)
{
hr = MakeErrorLast();
LocalFree(pOrig);
return hr;
}
hr = AnsiToUnicode((LPSTR)pOrig, pUnicode, len+1);
if (FAILED(hr))
{
LocalFree(pOrig);
LocalFree(pUnicode);
return hr;
}
LocalFree(pOrig);
*ppszFileText = pUnicode;
if (pfWasAnsi)
*pfWasAnsi = TRUE;
return S_OK;
}
//---------------------------------------------------------------------------
HRESULT TextToFile(LPCWSTR szFileName, LPCWSTR szText)
{
CSimpleFile outfile;
HRESULT hr = outfile.Create(szFileName);
if (FAILED(hr))
return hr;
hr = outfile.Write((void*)szText, lstrlenW(szText)*sizeof(WCHAR));
if (FAILED(hr))
return hr;
outfile.Close();
return S_OK;
}
//---------------------------------------------------------------------------
HRESULT AddPathIfNeeded(LPCWSTR pszFileName, LPCWSTR pszPath, LPWSTR pszFullName,
DWORD dwFullChars)
{
HRESULT hr;
if (! pszFileName)
return MakeError32(E_FAIL);
DWORD len = lstrlen(pszFileName);
BOOL fQualified = ((*pszFileName == L'\\') || ((len > 1) && (pszFileName[1] == ':')));
if (fQualified)
{
if (dwFullChars < len+1)
return MakeError32(E_FAIL);
hr = hr_lstrcpy(pszFullName, pszFileName, dwFullChars);
if (FAILED(hr))
return hr;
}
else
{
DWORD len2 = lstrlen(pszPath);
if (dwFullChars < len+len2+2)
return MakeError32(E_FAIL);
if ((len2) && (pszPath[len2-1] == '\\'))
wsprintf(pszFullName, L"%s%psz", pszPath, pszFileName);
else
wsprintf(pszFullName, L"%s\\%s", pszPath, pszFileName);
}
return S_OK;
}
//---------------------------------------------------------------------------
HICON _GetWindowIcon(HWND hwnd, BOOL fPerferLargeIcon)
{
const WPARAM rgGetIconParam[] = { ICON_SMALL2, ICON_SMALL, ICON_BIG };
const WPARAM rgGetIconParamLarge[] = { ICON_BIG, ICON_SMALL2, ICON_SMALL };
const int rgClassIconParam[] = { GCLP_HICONSM, GCLP_HICON };
HICON hicon = NULL;
const WPARAM * pIcons = (fPerferLargeIcon ? rgGetIconParamLarge : rgGetIconParam);
int i;
// try WM_GETICON
for( i = 0; i < ARRAYSIZE(rgGetIconParam) && NULL == hicon; i++ )
{
SendMessageTimeout(hwnd, WM_GETICON, pIcons[i], 0, SMTO_ABORTIFHUNG | SMTO_BLOCK,
500, (PULONG_PTR)&hicon);
}
// try GetClassLong
for( i = 0; i < ARRAYSIZE(rgClassIconParam) && NULL == hicon; i++ )
{
// next we try the small class icon
hicon = (HICON)GetClassLongPtr(hwnd, rgClassIconParam[i]);
}
return hicon;
}
//---------------------------------------------------------------------------
HRESULT hr_lstrcpy(LPWSTR pszDest, LPCWSTR pszSrc, DWORD dwMaxDestChars)
{
if ((! pszDest) || (! pszSrc))
return MakeError32(E_INVALIDARG);
DWORD dwSrcChars = lstrlen(pszSrc);
if (dwSrcChars + 1 > dwMaxDestChars)
return MakeError32(E_FAIL); // buffer too small for long string
lstrcpy(pszDest, pszSrc);
return S_OK;
}
//---------------------------------------------------------------------------
void lstrcpy_truncate(LPWSTR pszDest, LPCWSTR pszSrc, DWORD dwMaxDestChars)
{
if (! dwMaxDestChars) // nothing to do
return;
DWORD dwSrcChars;
if (pszSrc)
dwSrcChars = lstrlen(pszSrc);
else
dwSrcChars = 0;
if (dwSrcChars > dwMaxDestChars-1) // truncate string
dwSrcChars = dwMaxDestChars-1;
if (dwSrcChars)
memcpy(pszDest, pszSrc, dwSrcChars*sizeof(WCHAR));
pszDest[dwSrcChars] = 0;
}
//---------------------------------------------------------------------------
int string2number(LPCWSTR psz)
{
int temp = 0, base = 10;
int nNeg = 1;
if (*psz == L'-')
{
nNeg = -1;
psz++;
}
else if (*psz == L'+')
psz++;
if (*psz == '0')
{
++psz;
switch(*psz)
{
case L'X':
case L'x':
++psz;
base = 16;
break;
}
}
while (*psz)
{
switch (*psz)
{
case L'0': case L'1': case L'2': case L'3': case L'4':
case L'5': case L'6': case L'7': case L'8': case L'9':
temp = (temp * base) + (*psz++ - L'0');
break;
case L'a': case L'b': case L'c': case L'd': case L'e': case L'f':
if (base == 10)
return (nNeg*temp);
temp = (temp * base) + (*psz++ - L'a' + 10);
break;
case L'A': case L'B': case L'C': case L'D': case L'E': case L'F':
if (base == 10)
return (nNeg*temp);
temp = (temp * base) + (*psz++ - L'A' + 10);
break;
default:
return (nNeg*temp);
}
}
return (nNeg*temp);
}
//---------------------------------------------------------------------------
HRESULT GetDirBaseName(LPCWSTR pszDirName, LPWSTR pszBaseBuff, DWORD dwMaxBaseChars)
{
//---- extract last node of dir name ----
LPCWSTR p = wcsrchr(pszDirName, '\\');
if ((p) && (p > pszDirName) && (! p[1])) // last char - try next one to left
p = wcsrchr(p-1, '//');
if (p)
return hr_lstrcpy(pszBaseBuff, p, dwMaxBaseChars);
return hr_lstrcpy(pszBaseBuff, pszDirName, dwMaxBaseChars);
}
//---------------------------------------------------------------------------
BOOL AsciiScanStringList(
LPCWSTR pwszString,
LPCWSTR* rgpwszList,
int cStrings,
BOOL fIgnoreCase )
{
int (* pfnCompare)( LPCWSTR, LPCWSTR ) =
fIgnoreCase ? AsciiStrCmpI : lstrcmp;
for( int i = 0; i < cStrings; i++ )
{
if( 0 == pfnCompare( pwszString, rgpwszList[i] ) )
{
return TRUE;
}
}
return FALSE;
}
//---------------------------------------------------------------------------
BOOL UnExpandEnvironmentString(LPCWSTR pszPath, LPCWSTR pszEnvVar, LPWSTR pszResult, UINT cbResult)
{
DWORD nToCmp;
WCHAR szEnvVar[MAX_PATH];
szEnvVar[0] = 0;
ExpandEnvironmentStringsW(pszEnvVar, szEnvVar, ARRAYSIZE(szEnvVar)); // don't count the NULL
nToCmp = lstrlenW(szEnvVar);
if (CSTR_EQUAL == CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, szEnvVar, nToCmp, pszPath, nToCmp))
{
if (lstrlenW(pszPath) - (int)nToCmp + lstrlenW(pszEnvVar) < (int)cbResult)
{
lstrcpyW(pszResult, pszEnvVar);
lstrcpyW(pszResult + lstrlenW(pszResult), pszPath + nToCmp);
return TRUE;
}
}
return FALSE;
}
//---------------------------------------------------------------------------
HRESULT RegistryIntWrite(HKEY hKey, LPCWSTR pszValueName, int iValue)
{
HRESULT hr = S_OK;
WCHAR valbuff[_MAX_PATH+1];
wsprintf(valbuff, L"%d", iValue);
int len = (1 + lstrlen(valbuff)) * sizeof(WCHAR);
int code32 = RegSetValueEx(hKey, pszValueName, NULL, REG_SZ,
(BYTE *)valbuff, len);
if (code32 != ERROR_SUCCESS)
hr = MakeError32(code32);
return hr;
}
//---------------------------------------------------------------------------
HRESULT RegistryStrWrite(HKEY hKey, LPCWSTR pszValueName, LPCWSTR pszValue)
{
HRESULT hr = S_OK;
int len = (1 + lstrlen(pszValue)) * (sizeof(WCHAR));
int code32 = RegSetValueEx(hKey, pszValueName, NULL, REG_SZ,
(BYTE *)pszValue, len);
if (code32 != ERROR_SUCCESS)
hr = MakeError32(code32);
return hr;
}
//---------------------------------------------------------------------------
HRESULT RegistryStrWriteExpand(HKEY hKey, LPCWSTR pszValueName, LPCWSTR pszValue)
{
HRESULT hr = S_OK;
int len;
WCHAR szResult[_MAX_PATH + 1];
LPCWSTR pszPath = pszValue;
if (UnExpandEnvironmentString(pszValue, L"%SystemRoot%", szResult, ARRAYSIZE(szResult)))
pszPath = szResult;
len = (1 + lstrlen(pszPath)) * (sizeof(WCHAR));
int code32 = RegSetValueEx(hKey, pszValueName, NULL, REG_EXPAND_SZ,
(BYTE *)pszPath, len);
if (code32 != ERROR_SUCCESS)
hr = MakeError32(code32);
return hr;
}
//---------------------------------------------------------------------------
HRESULT RegistryIntRead(HKEY hKey, LPCWSTR pszValueName, int *piValue)
{
HRESULT hr = S_OK;
DWORD dwValType;
WCHAR valbuff[_MAX_PATH+1];
DWORD dwByteSize = sizeof(valbuff); // bytes, not chars
int code32 = RegQueryValueEx(hKey, pszValueName, NULL, &dwValType,
(BYTE *)valbuff, &dwByteSize);
if (code32 == ERROR_SUCCESS)
{
*piValue = string2number(valbuff);
}
else
hr = MakeError32(code32);
return hr;
}
//---------------------------------------------------------------------------
HRESULT RegistryStrRead(HKEY hKey, LPCWSTR pszValueName, LPWSTR pszBuff, DWORD dwMaxChars)
{
HRESULT hr = S_OK;
DWORD dwValType = 0;
DWORD dwByteSize = dwMaxChars * sizeof(WCHAR); // in bytes
int code32 = RegQueryValueEx(hKey, pszValueName, NULL, &dwValType,
(BYTE *)pszBuff, &dwByteSize);
if (code32 != ERROR_SUCCESS)
{
hr = MakeError32(code32);
goto exit;
}
if (dwValType == REG_EXPAND_SZ || wcschr(pszBuff, L'%'))
{
int len = sizeof(WCHAR) * (1 + lstrlen(pszBuff));
LPWSTR szTempBuff = (LPWSTR)alloca(len);
if (szTempBuff)
{
lstrcpy(szTempBuff, pszBuff);
DWORD dwChars = ExpandEnvironmentStrings(szTempBuff, pszBuff, dwMaxChars);
if (dwChars > dwMaxChars) // caller's buffer too small
{
hr = MakeError32(ERROR_INSUFFICIENT_BUFFER);
}
}
}
exit:
return hr;
}
//---------------------------------------------------------------------------
BOOL PreMultiplyAlpha(DWORD *pPixelBuff, UINT iWidth, UINT iHeight)
{
BOOL fTrueAlpha = FALSE;
DWORD *pdw = pPixelBuff;
for (int i = iWidth * iHeight - 1; i >= 0; i--)
{
COLORREF cr = *pdw;
int iAlpha = ALPHACHANNEL(cr);
if ((iAlpha != 255) && (iAlpha != 0))
fTrueAlpha = TRUE;
pdw++;
}
pdw = pPixelBuff;
if (fTrueAlpha)
{
for (UINT r=0; r < iHeight; r++)
{
for (UINT c=0; c < iWidth; c++)
{
COLORREF cr = *pdw;
int iAlpha = ALPHACHANNEL(cr);
int iRed = (RED(cr)*iAlpha)/255;
int iGreen = (GREEN(cr)*iAlpha)/255;
int iBlue = (BLUE(cr)*iAlpha)/255;
*pdw++ = (RGB(iRed, iGreen, iBlue) | (iAlpha << 24));
}
}
}
return fTrueAlpha;
}
//---------------------------------------------------------------------------
HRESULT MakeFlippedBitmap(HBITMAP hSrcBitmap, HBITMAP *phFlipped)
{
HRESULT hr = S_OK;
BOOL fSucceeded = FALSE;
Log(LOG_TMBITMAP, L"MakeFlippedBitmap %08X", hSrcBitmap);
//---- setup SOURCE dc/bitmap ----
HDC hdcSrc = CreateCompatibleDC(NULL);
if (hdcSrc)
{
DWORD dwSrcLayout = GetLayout(hdcSrc);
HBITMAP hOldSrcBitmap = (HBITMAP)SelectObject(hdcSrc, hSrcBitmap);
if (hOldSrcBitmap)
{
//---- setup DEST dc/bitmap ----
//---- MSDN doc for CreateCompatibleBitmap says that this works correctly ----
//---- if a DIB is selected in the dc ----
BITMAP bm;
if (GetObject(hSrcBitmap, sizeof(bm), &bm))
{
int iWidth = bm.bmWidth;
int iHeight = bm.bmHeight;
HBITMAP hDestBitmap = CreateCompatibleBitmap(hdcSrc, iWidth, iHeight);
if (hDestBitmap)
{
HDC hdcDest = CreateCompatibleDC(hdcSrc);
if (hdcDest)
{
HBITMAP hOldDestBitmap = (HBITMAP)SelectObject(hdcDest, hDestBitmap);
if (hOldDestBitmap)
{
//---- toggle layout ----
DWORD dwOldDestLayout;
if (dwSrcLayout & LAYOUT_RTL)
dwOldDestLayout = SetLayout(hdcDest, 0);
else
dwOldDestLayout = SetLayout(hdcDest, LAYOUT_RTL);
//---- mirror the bits from src to dest ----
if (BitBlt(hdcDest, 0, 0, iWidth, iHeight, hdcSrc, 0, 0, SRCCOPY))
{
*phFlipped = hDestBitmap;
fSucceeded = TRUE;
}
SelectObject(hdcDest, hOldDestBitmap);
}
DeleteDC(hdcDest);
}
if (! fSucceeded)
DeleteObject(hDestBitmap);
}
}
SelectObject(hdcSrc, hOldSrcBitmap);
}
DeleteDC(hdcSrc);
}
if (! fSucceeded)
hr = GetLastError();
return hr;
}
//---------------------------------------------------------------------------
HRESULT FlipDIB32(DWORD *pBits, UINT iWidth, UINT iHeight)
{
DWORD temp;
DWORD *pTemp1;
DWORD *pTemp2;
HRESULT hr = S_OK;
if (pBits == NULL || iWidth == 0 || iHeight == 0)
{
Log(LOG_TMBITMAP, L"FlipDIB32 failed.");
return E_INVALIDARG;
}
for (UINT iRow = 0; iRow < iHeight; iRow++)
{
for (UINT iCol = 0; iCol < iWidth / 2; iCol++)
{
pTemp1 = pBits + iRow * iWidth + iCol;
pTemp2 = pBits + (iRow + 1) * iWidth - iCol - 1;
temp = *pTemp1;
*pTemp1 = *pTemp2;
*pTemp2 = temp;
}
}
return hr;
}
//---------------------------------------------------------------------------
// IsBiDiLocalizedSystem is taken from stockthk.lib and simplified
// (it's only a wrapper for GetUserDefaultUILanguage and GetLocaleInfo)
//---------------------------------------------------------------------------
typedef struct {
LANGID LangID;
BOOL bInstalled;
} MUIINSTALLLANG, *LPMUIINSTALLLANG;
/***************************************************************************\
* ConvertHexStringToIntW
*
* Converts a hex numeric string into an integer.
*
* History:
* 14-June-1998 msadek Created
\***************************************************************************/
BOOL ConvertHexStringToIntW( WCHAR *pszHexNum , int *piNum )
{
int n=0L;
WCHAR *psz=pszHexNum;
for(n=0 ; ; psz=CharNextW(psz))
{
if( (*psz>='0') && (*psz<='9') )
n = 0x10 * n + *psz - '0';
else
{
WCHAR 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;
}
}
/*
* Update results
*/
*piNum = n;
return (psz != pszHexNum);
}
/***************************************************************************\
* Mirror_EnumUILanguagesProc
*
* Enumerates MUI installed languages on W2k
* History:
* 14-June-1999 msadek Created
\***************************************************************************/
BOOL CALLBACK Mirror_EnumUILanguagesProc(LPTSTR lpUILanguageString, LONG_PTR lParam)
{
int langID = 0;
ConvertHexStringToIntW(lpUILanguageString, &langID);
if((LANGID)langID == ((LPMUIINSTALLLANG)lParam)->LangID)
{
((LPMUIINSTALLLANG)lParam)->bInstalled = TRUE;
return FALSE;
}
return TRUE;
}
/***************************************************************************\
* Mirror_IsUILanguageInstalled
*
* Verifies that the User UI language is installed on W2k
*
* History:
* 14-June-1999 msadek Created
\***************************************************************************/
BOOL Mirror_IsUILanguageInstalled( LANGID langId )
{
MUIINSTALLLANG MUILangInstalled = {0};
MUILangInstalled.LangID = langId;
EnumUILanguagesW(Mirror_EnumUILanguagesProc, 0, (LONG_PTR)&MUILangInstalled);
return MUILangInstalled.bInstalled;
}
/***************************************************************************\
* IsBiDiLocalizedSystemEx
*
* returns TRUE if running on a lozalized BiDi (Arabic/Hebrew) NT5 or Memphis.
* Should be called whenever SetProcessDefaultLayout is to be called.
*
* History:
* 02-Feb-1998 samera Created
\***************************************************************************/
BOOL IsBiDiLocalizedSystemEx( LANGID *pLangID )
{
int iLCID=0L;
static BOOL bRet = (BOOL)(DWORD)-1;
static LANGID langID = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
if (bRet != (BOOL)(DWORD)-1)
{
if (bRet && pLangID)
{
*pLangID = langID;
}
return bRet;
}
bRet = FALSE;
/*
* Need to use NT5 detection method (Multiligual UI ID)
*/
langID = GetUserDefaultUILanguage();
if( langID )
{
WCHAR wchLCIDFontSignature[16];
iLCID = MAKELCID( langID , SORT_DEFAULT );
/*
* Let's verify this is a RTL (BiDi) locale. Since reg value is a hex string, let's
* convert to decimal value and call GetLocaleInfo afterwards.
* LOCALE_FONTSIGNATURE always gives back 16 WCHARs.
*/
if( GetLocaleInfoW( iLCID ,
LOCALE_FONTSIGNATURE ,
(WCHAR *) &wchLCIDFontSignature[0] ,
(sizeof(wchLCIDFontSignature)/sizeof(WCHAR))) )
{
/* Let's verify the bits we have a BiDi UI locale */
if(( wchLCIDFontSignature[7] & (WCHAR)0x0800) && Mirror_IsUILanguageInstalled(langID) )
{
bRet = TRUE;
}
}
}
if (bRet && pLangID)
{
*pLangID = langID;
}
return bRet;
}
//---------------------------------------------------------------------------
BOOL IsBiDiLocalizedSystem( void )
{
return IsBiDiLocalizedSystemEx(NULL);
}
//---------------------------------------------------------------------------
BOOL GetWindowDesktopName(HWND hwnd, LPWSTR pszName, DWORD dwMaxChars)
{
BOOL fGotName = FALSE;
DWORD dwThreadId = GetWindowThreadProcessId(hwnd, NULL);
HDESK hDesk = GetThreadDesktop(dwThreadId);
if (hDesk)
{
fGotName = GetUserObjectInformation(hDesk, UOI_NAME, pszName, dwMaxChars*sizeof(WCHAR), NULL);
}
return fGotName;
}
//---------------------------------------------------------------------------
void SafeSendMessage(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
DWORD dwFlags = SMTO_BLOCK | SMTO_ABORTIFHUNG;
DWORD dwTimeout = 250; // .25 secs
ULONG_PTR puRetVal;
if (! SendMessageTimeout(hwnd, uMsg, wParam, lParam, dwFlags, dwTimeout, &puRetVal))
{
Log(LOG_TMLOAD, L"SEND TIMEOUT: msg=0x%x being POSTED to hwnd=0x%x",
uMsg, hwnd);
PostMessage(hwnd, uMsg, wParam, lParam);
}
}
//---------------------------------------------------------------------------
int FontPointSize(int iFontHeight)
{
return -MulDiv(iFontHeight, 72, THEME_DPI);
}
//---------------------------------------------------------------------------
void ScaleFontForHdcDpi(HDC hdc, LOGFONT *plf)
{
if (plf->lfHeight < 0) // specified in points
{
if (! hdc)
{
ScaleFontForScreenDpi(plf);
}
else
{
int iDpi = GetDeviceCaps(hdc, LOGPIXELSX);
plf->lfHeight = MulDiv(plf->lfHeight, iDpi, THEME_DPI);
}
}
}
//---------------------------------------------------------------------------
int ScaleSizeForHdcDpi(HDC hdc, int iValue)
{
int iScaledValue;
if (! hdc)
{
iScaledValue = ScaleSizeForScreenDpi(iValue);
}
else
{
int iDpi = GetDeviceCaps(hdc, LOGPIXELSX);
iScaledValue = MulDiv(iValue, iDpi, THEME_DPI);
}
return iScaledValue;
}
//---------------------------------------------------------------------------
// --------------------------------------------------------------------------
// MinimumDisplayColorDepth
//
// Arguments: <none>
//
// Returns: DWORD
//
// Purpose: Iterates all monitors attached to the system and finds those
// that are active. Returns the lowest bit depth availabe. This
// is the lowest common denominator.
//
// History: 2001-04-11 lmouton moved from services.cpp
// 2000-11-11 vtan created (rewritten from themeldr.cpp)
// --------------------------------------------------------------------------
DWORD MinimumDisplayColorDepth (void)
{
DWORD dwMinimumDepth, dwIndex;
bool fContinue;
DISPLAY_DEVICE displayDevice;
dwMinimumDepth = 0;
ZeroMemory(&displayDevice, sizeof(displayDevice));
dwIndex = 0;
do
{
displayDevice.cb = sizeof(displayDevice);
fContinue = (EnumDisplayDevices(NULL, dwIndex++, &displayDevice, 0) != FALSE);
if (fContinue)
{
if ((displayDevice.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP) != 0)
{
DEVMODE devMode;
ZeroMemory(&devMode, sizeof(devMode));
devMode.dmSize = sizeof(devMode);
devMode.dmDriverExtra = 0;
if (EnumDisplaySettings(displayDevice.DeviceName, ENUM_CURRENT_SETTINGS, &devMode) != FALSE)
{
if ((dwMinimumDepth == 0) || (dwMinimumDepth > devMode.dmBitsPerPel))
{
dwMinimumDepth = devMode.dmBitsPerPel;
}
}
}
}
} while (fContinue);
// Note: We can fail here (return 0) because when a session is disconnected, the desktop is attached to
// a hidden display. OK to fail silently then.
return(dwMinimumDepth);
}
// --------------------------------------------------------------------------
// CheckMinColorDepth
//
// Arguments: hInst msstyle module handle
// dwCurMinDepth current minimum active screen resolution
// iIndex index to the color/size combo to test, or
// -1 to enumerate them all
//
// Returns: bool true if at least a color/size combo supports
// the current screen resolution
//
// History: 2001-04-11 lmouton created
// --------------------------------------------------------------------------
bool CheckMinColorDepth(HINSTANCE hInst, DWORD dwCurMinDepth, int iIndex)
{
BYTE *pBytes = NULL;
DWORD dwBytes = 0;
bool bMatch = true; // OK if the resource doesn't exist
if (SUCCEEDED(GetPtrToResource(hInst, L"MINDEPTH", MAKEINTRESOURCE(1), (void**) &pBytes, &dwBytes)) && dwBytes > 0)
{
bMatch = false;
if (iIndex != -1)
{
if (*((WORD*) pBytes + iIndex) <= dwCurMinDepth)
bMatch = true;
}
else
{
WORD wDepth = *((WORD*) pBytes);
while (wDepth != 0)
{
if (wDepth <= (WORD) dwCurMinDepth)
{
bMatch = true;
break;
}
pBytes += sizeof(WORD);
wDepth = *((WORD*) pBytes);
}
}
}
return bMatch;
}
Reference in a new issue Copy permalink