Microsoft/Windows2000
Microsoft/Windows2000
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Windows2000/private/ntos/w32/ntuser/client/clres.c
Microsoft 45f4a58588 First commit
2020-09-30 17:12:32 +02:00

4806 lines
124 KiB
C
Raw Blame History

/**** Module Header ****\
* Module Name: clres.c
* Copyright (c) 1985 - 1999, Microsoft Corporation
* Resource Loading/Creation Routines
* History:
* 24-Sep-1990 MikeKe From win30
* 19-Sep-1995 ChrisWil Win95/NT merge.
*/
#include "precomp.h"
#pragma hdrstop
/*
* Constants.
*/
#define BPP01_MAXCOLORS 2
#define BPP04_MAXCOLORS 16
#define BPP08_MAXCOLORS 256
#define RESCLR_BLACK 0x00000000
#define RESCLR_WHITE 0x00FFFFFF
typedef struct {
ACCEL accel;
WORD padding;
} RESOURCE_ACCEL, *PRESOURCE_ACCEL;
/*
* Bitmap resource IDs
*/
#define BMR_ICON 1
#define BMR_BITMAP 2
#define BMR_CURSOR 3
typedef struct _OLDCURSOR {
BYTE bType;
BYTE bFormat;
WORD xHotSpot; // 0 for icons
WORD yHotSpot; // 0 for icons
WORD cx;
WORD cy;
WORD cxBytes;
WORD wReserved2;
BYTE abBitmap[1];
} OLDCURSOR, *POLDCURSOR;
typedef OLDCURSOR UNALIGNED *UPOLDCURSOR;
/*
* Local Macros.
*/
#define GETINITDC() \
(gfSystemInitialized ? NtUserGetDC(NULL) : CreateDCW(L"DISPLAY", L"", NULL, NULL))
#define RELEASEINITDC(hdc) \
(gfSystemInitialized ? ReleaseDC(NULL, hdc) : DeleteDC(hdc))
#define ISRIFFFORMAT(p) \
(((UNALIGNED RTAG *)(p))->ckID == FOURCC_RIFF)
#define MR_FAILFOR40 0x01
#define MR_MONOCHROME 0x02
typedef struct tagMAPRES {
WORD idDisp; // display driver ID
WORD idUser; // USER ID
BYTE bFlags; // Flags
BYTE bReserved; // unused
} MAPRES, *LPMAPRES, *PMAPRES;
HBITMAP CopyBmp(HBITMAP hbmpOrg, int cxNew, int cyNew, UINT LR_flags);
/*
* SplFindResource
* Check whether the hInstance passed is that of the present display driver;
* if so, it will call the GetDriverResourceId() in the display to allow
* it to map the given id/name to a new id/name. Then it will call
* FindResource9) in KERNEL.
* 13-Nov-1995 SanfordS Added mapping for DEFAULT constants.
*/
HANDLE SplFindResource(
HINSTANCE hmod,
LPCWSTR lpName,
LPCWSTR lpType)
{
return FINDRESOURCEW(hmod, lpName, lpType);
}
/*
* SplFreeResource
* Really frees a resource that is shared (won't be touched again unless
* LR_COPYFROMRESOURCE is used) or system.
* 13-Nov-1995 SanfordS Added mapping for DEFAULT constants.
*/
VOID SplFreeResource(
HANDLE hRes,
HINSTANCE hmod,
UINT lrFlags)
{
if (!FREERESOURCE(hRes, hmod) &&
((hmod == hmodUser) || (lrFlags & LR_SHARED))) {
FREERESOURCE(hRes, hmod);
}
}
/*
* WowGetModuleFileName
* This converts a WOW or non-WOW module handle to a string form that
* can be restored even for WOW handles.
* Returns: fSuccess
* 29-Nov-1995 SanfordS Created.
*/
BOOL WowGetModuleFileName(
HMODULE hModule,
LPWSTR pwsz,
DWORD cchMax)
{
if (!GetModuleFileName(hModule, pwsz, cchMax)) {
if (cchMax < 10) {
RIPMSG0(RIP_WARNING, "WowGetModuleFileName: exceeded Char-Max");
return FALSE;
}
wsprintf(pwsz, TEXT("\001%08lx"), hModule);
}
return TRUE;
}
/*
* WowGetModuleHandle
* This restores the string form of a module handle created by
* WowGetModuleFileName to the original handle.
* Returns: fSuccess
* 29-Nov-1995 Created SanfordS
*/
HMODULE WowGetModuleHandle(
LPCWSTR pwsz)
{
HMODULE hMod = NULL;
DWORD digit;
if (pwsz[0] == TEXT('\001')) {
/*
* Cant seem to link to swscanf without CRT0 problems so just
* do it by hand.
*/
while (*(++pwsz)) {
if (*pwsz == TEXT(' '))
continue;
digit = *pwsz - TEXT('0');
if (digit > 9)
digit += (DWORD)(TEXT('0') - TEXT('a') + 10);
(ULONG_PTR)hMod <<= 4;
(ULONG_PTR)hMod += digit;
}
} else {
hMod = GetModuleHandle(pwsz);
}
return hMod;
}
/*
* CreateAcceleratorTableA (API)
* Creates an accel table, returns handle to accel table.
* 02-May-1991 ScottLu Created.
*/
HACCEL WINAPI CreateAcceleratorTableA(
LPACCEL paccel,
int cAccel)
{
int nAccel = cAccel;
LPACCEL pAccelT = paccel;
/*
* Convert any character keys from ANSI to Unicode.
*/
while (nAccel--) {
if ((pAccelT->fVirt & FVIRTKEY) == 0) {
if (!NT_SUCCESS(RtlMultiByteToUnicodeN((LPWSTR)&(pAccelT->key),
sizeof(WCHAR),
NULL,
(LPSTR)&(pAccelT->key),
sizeof(CHAR)))) {
pAccelT->key = 0xFFFF;
}
}
pAccelT++;
}
return NtUserCreateAcceleratorTable(paccel, cAccel);
}
/*
* CopyAcceleratorTableA (API)
* Copies an accel table
* 02-May-1991 ScottLu Created.
*/
int CopyAcceleratorTableA(
HACCEL hacc,
LPACCEL paccel,
int length)
{
int retval;
retval = NtUserCopyAcceleratorTable(hacc, paccel, length);
/*
* If we are doing a copy and we succeeded then convert the accelerator
*/
if ((paccel != NULL) && (retval > 0)) {
/*
* Translate UNICODE character keys to ANSI
*/
int nAccel = retval;
LPACCEL pAccelT = paccel;
while (nAccel--) {
if ((pAccelT->fVirt & FVIRTKEY) == 0) {
if (!NT_SUCCESS(RtlUnicodeToMultiByteN((PCHAR)&(pAccelT->key),
sizeof(WCHAR),
NULL,
(PWSTR)&(pAccelT->key),
sizeof(pAccelT->key)))) {
pAccelT->key = 0;
}
}
pAccelT++;
}
}
return retval;
}
/*
* FindAccResource
* Resource accelerator tables are to be loaded only once to be compatible
* with Win95. So we keep track of the addresses we've loaded tables from
* and the corresponding handle.
* This function finds an entry in the table. It returns the address
* of the pacNext pointer that contains the requested entry.
* 01/31/97 GerardoB Created.
*/
PACCELCACHE * FindAccResource (HACCEL hAccel, PVOID pRes)
{
/*
* The caller must own gcsAccelCache *
*/
PACCELCACHE * ppacNext = &gpac;
PACCELCACHE pac;
/*
* This is meant to search by handle or by pointer, not both
* So at least one of the parameters must be NULL.
*/
UserAssert(!(hAccel && pRes));
/*
* Walk the table
*/
while (*ppacNext != NULL) {
pac = *ppacNext;
if ((pac->pRes == pRes) || (pac->hAccel == hAccel)) {
/*
* Found it. Validate this entry before returning.
*/
UserAssert(pac->dwLockCount != 0);
UserAssert(HMValidateHandleNoDesktop(pac->hAccel, TYPE_ACCELTABLE));
break;
}
ppacNext = &(pac->pacNext);
}
return ppacNext;
}
/*
* AddAccResource
* This is called everytime LoadAcc loads a new table. It adds an
* entry (handle and resource address) to the global list and
* sets the lock count to 1
* 01/31/97 GerardoB Created.
*/
void AddAccResource (HACCEL hAccel, PVOID pRes)
{
PACCELCACHE pac;
UserAssert(HMValidateHandleNoDesktop(hAccel, TYPE_ACCELTABLE));
UserAssert(pRes != NULL);
/*
* Allocate and initialize a new entry.
*/
pac = (PACCELCACHE)LocalAlloc(LPTR, sizeof(ACCELCACHE));
if (pac != NULL) {
pac->dwLockCount = 1;
pac->hAccel = hAccel;
pac->pRes = pRes;
/*
* Make it the new head of the list
*/
RtlEnterCriticalSection(&gcsAccelCache);
pac->pacNext = gpac;
gpac = pac;
RtlLeaveCriticalSection(&gcsAccelCache);
}
}
/*
* DestroyAcceleratorTable
* 01/31/97 GerardoB Created.
*/
BOOL DestroyAcceleratorTable (HACCEL hAccel)
{
BOOL fUnlocked = TRUE;
PACCELCACHE *ppacNext, pac;
/*
* If we added this table to our list, decrement the lock count
*/
RtlEnterCriticalSection(&gcsAccelCache);
ppacNext = FindAccResource(hAccel, NULL);
if (*ppacNext != NULL) {
pac = *ppacNext;
/*
* Found it. Decrement lock count.
*/
UserAssert(pac->dwLockCount != 0);
fUnlocked = (--pac->dwLockCount == 0);
/*
* If noboby else wants this around, unlink it and nuke it.
*/
if (fUnlocked) {
*ppacNext = pac->pacNext;
LocalFree(pac);
}
}
RtlLeaveCriticalSection(&gcsAccelCache);
/*
* If not totally deref'ed, return FALSE (win95 compat).
*/
if (fUnlocked) {
return NtUserDestroyAcceleratorTable(hAccel);
} else {
return FALSE;
}
}
/*
* LoadAcc (Worker)
* This is the worker-routine for loading accelerator tables.
*/
#define FACCEL_VALID (FALT | FCONTROL | FNOINVERT | FSHIFT | FVIRTKEY | FLASTKEY)
HANDLE LoadAcc(
HINSTANCE hmod,
HANDLE hrl)
{
PACCELCACHE * ppacNext;
HANDLE handle = NULL;
if (hrl != NULL) {
if (hrl = LOADRESOURCE(hmod, hrl)) {
PRESOURCE_ACCEL paccel;
if ((paccel = (PRESOURCE_ACCEL)LOCKRESOURCE(hrl, hmod)) != NULL) {
int nAccel = 0;
int i;
LPACCEL paccelT;
/*
* Check if we've already loaded accelerators from this
* same address
*/
RtlEnterCriticalSection(&gcsAccelCache);
ppacNext = FindAccResource(NULL, paccel);
if (*ppacNext != NULL) {
(*ppacNext)->dwLockCount++;
handle = (*ppacNext)->hAccel;
}
RtlLeaveCriticalSection(&gcsAccelCache);
/*
* If we found this table on the global list,
* return the same handle (Win95 compat)
*/
if (handle != NULL) {
goto UnlockAndFree;
}
while (!((paccel[nAccel].accel.fVirt) & FLASTKEY)) {
if (paccel[nAccel].accel.fVirt & ~FACCEL_VALID) {
RIPMSG0(RIP_WARNING, "LoadAcc: Invalid Parameter");
goto UnlockAndFree;
}
nAccel++;
}
if (paccel[nAccel].accel.fVirt & ~FACCEL_VALID) {
RIPMSG0(RIP_WARNING, "LoadAcc: Invalid Parameter");
goto UnlockAndFree;
}
/*
* Since the accelerator table is coming from a resource, each
* element has an extra WORD of padding which we strip here
* to conform with the public (and internal) ACCEL structure.
*/
paccelT = UserLocalAlloc(0, sizeof(ACCEL) * (nAccel + 1));
if (paccelT == NULL) {
goto UnlockAndFree;
}
for (i = 0; i < nAccel + 1; i++) {
paccelT[i] = paccel[i].accel;
}
handle = NtUserCreateAcceleratorTable(paccelT,
nAccel + 1);
UserLocalFree(paccelT);
/*
* Add this handle/address to the global table so
* we won't load it twice.
*/
if (handle != NULL) {
AddAccResource(handle, paccel);
}
UnlockAndFree:
UNLOCKRESOURCE(hrl, hmod);
}
FREERESOURCE(hrl, hmod);
}
}
return handle;
}
/*
* LoadAcceleratorsA (API)
* LoadAcceleratorsW (API)
* 24-Sep-1990 MikeKe From Win30
*/
HACCEL WINAPI LoadAcceleratorsA(
HINSTANCE hmod,
LPCSTR lpAccName)
{
HANDLE hRes;
hRes = FINDRESOURCEA((HANDLE)hmod, lpAccName, (LPSTR)RT_ACCELERATOR);
return (HACCEL)LoadAcc(hmod, hRes);
}
HACCEL WINAPI LoadAcceleratorsW(
HINSTANCE hmod,
LPCWSTR lpAccName)
{
HANDLE hRes;
hRes = FINDRESOURCEW((HANDLE)hmod, lpAccName, RT_ACCELERATOR);
return (HACCEL)LoadAcc(hmod, hRes);
}
/*
* LoadStringA (API)
* LoadStringW (API)
* 05-Apr-1991 ScottLu Fixed to work with client/server.
*/
int WINAPI LoadStringA(
HINSTANCE hmod,
UINT wID,
LPSTR lpAnsiBuffer,
int cchBufferMax)
{
LPWSTR lpUniBuffer;
INT cchUnicode;
INT cbAnsi = 0;
/*
* LoadStringOrError appends a NULL but does not include it in the
* return count-of-bytes
*/
cchUnicode = LoadStringOrError((HANDLE)hmod,
wID,
(LPWSTR)&lpUniBuffer,
0,
0);
if (cchUnicode) {
cbAnsi = WCSToMB(lpUniBuffer,
cchUnicode,
&lpAnsiBuffer,
cchBufferMax - 1,
FALSE);
cbAnsi = min(cbAnsi, cchBufferMax - 1);
}
/*
* Append a NULL but do not include it in the count returned
*/
lpAnsiBuffer[cbAnsi] = 0;
return cbAnsi;
}
int WINAPI LoadStringW(
HINSTANCE hmod,
UINT wID,
LPWSTR lpBuffer,
int cchBufferMax)
{
return LoadStringOrError((HANDLE)hmod,
wID,
lpBuffer,
cchBufferMax,
0);
}
/*
* SkipIDorString
* Skips string (or ID) and returns the next aligned WORD.
*/
PBYTE SkipIDorString(
LPBYTE pb)
{
if (*((LPWORD)pb) == 0xFFFF)
return (pb + 4);
while (*((PWCHAR)pb)++ != 0);
return pb;
}
/*
* GetSizeDialogTemplate
* This gets called by thank produced stubs. It returns the size of a
* dialog template.
* 07-Apr-1991 ScottLu Created.
*/
DWORD GetSizeDialogTemplate(
HINSTANCE hmod,
LPCDLGTEMPLATE pdt)
{
UINT cdit;
LPBYTE pb;
BOOL fChicago;
LPDLGTEMPLATE2 pdt2;
if (HIWORD(pdt->style) == 0xFFFF) {
pdt2 = (LPDLGTEMPLATE2)pdt;
fChicago = TRUE;
/*
* Fail if the app is passing invalid style bits.
*/
if (pdt2->style & ~(DS_VALID40 | 0xffff0000)) {
RIPMSG0(RIP_WARNING, "Bad dialog style bits - please remove");
return 0;
}
pb = (LPBYTE)(((LPDLGTEMPLATE2)pdt) + 1);
} else {
fChicago = FALSE;
/*
* Check if invalid style bits are being passed. Fail if the app
* is a new app ( >= VER40).
* This is to ensure that we are compatible with Chicago.
*/
if ((pdt->style & ~(DS_VALID40 | 0xffff0000)) &&
(GETEXPWINVER(hmod) >= VER40)) {
/*
* It's a new app with invalid style bits - fail.
*/
RIPMSG0(RIP_WARNING, "Bad dialog style bits - please remove");
return 0;
}
pb = (LPBYTE)(pdt + 1);
}
/*
* If there is a menu ordinal, add 4 bytes skip it. Otherwise it is a
* string or just a 0.
*/
pb = SkipIDorString(pb);
/*
* Skip window class and window text, adjust to next word boundary.
*/
pb = SkipIDorString(pb);
pb = SkipIDorString(pb);
/*
* Skip font type, size and name, adjust to next dword boundary.
*/
if ((fChicago ? pdt2->style : pdt->style) & DS_SETFONT) {
pb += fChicago ? sizeof(DWORD) + sizeof(WORD): sizeof(WORD);
pb = SkipIDorString(pb);
}
pb = (LPBYTE)(((ULONG_PTR)pb + 3) & ~3);
/*
* Loop through dialog items now...
*/
cdit = fChicago ? pdt2->cDlgItems : pdt->cdit;
while (cdit-- != 0) {
UINT cbCreateParams;
pb += fChicago ? sizeof(DLGITEMTEMPLATE2) : sizeof(DLGITEMTEMPLATE);
/*
* Skip the dialog control class name.
*/
pb = SkipIDorString(pb);
/*
* Look at window text now.
*/
pb = SkipIDorString(pb);
cbCreateParams = *((LPWORD)pb);
/*
* skip any CreateParams which include the generated size WORD.
*/
if (cbCreateParams)
pb += cbCreateParams;
pb += sizeof(WORD);
/*
* Point at the next dialog item. (DWORD aligned)
*/
pb = (LPBYTE)(((ULONG_PTR)pb + 3) & ~3);
}
/*
* Return template size.
*/
return (DWORD)(pb - (LPBYTE)pdt);
}
/*
* DialogBoxIndirectParamA (API)
* DialogBoxIndirectParamW (API)
* Creates the dialog and goes into a modal loop processing input for it.
* 05-Apr-1991 ScottLu Created.
*/
INT_PTR WINAPI DialogBoxIndirectParamA(
HINSTANCE hmod,
LPCDLGTEMPLATEA lpDlgTemplate,
HWND hwndOwner,
DLGPROC lpDialogFunc,
LPARAM dwInitParam)
{
return DialogBoxIndirectParamAorW(hmod,
(LPCDLGTEMPLATEW)lpDlgTemplate,
hwndOwner,
lpDialogFunc,
dwInitParam,
SCDLG_ANSI);
}
INT_PTR WINAPI DialogBoxIndirectParamW(
HINSTANCE hmod,
LPCDLGTEMPLATEW lpDlgTemplate,
HWND hwndOwner,
DLGPROC lpDialogFunc,
LPARAM dwInitParam)
{
return DialogBoxIndirectParamAorW(hmod,
lpDlgTemplate,
hwndOwner,
lpDialogFunc,
dwInitParam,
0);
}
INT_PTR WINAPI DialogBoxIndirectParamAorW(
HINSTANCE hmod,
LPCDLGTEMPLATEW lpDlgTemplate,
HWND hwndOwner,
DLGPROC lpDialogFunc,
LPARAM dwInitParam,
UINT fAnsiFlags)
{
DWORD cb;
/*
* The server routine destroys the menu if it fails.
*/
cb = GetSizeDialogTemplate(hmod, lpDlgTemplate);
if (!cb) {
RIPMSG0(RIP_WARNING, "DialogBoxIndirectParam: Invalid Paramter");
return -1;
}
return InternalDialogBox(hmod,
(LPDLGTEMPLATE)lpDlgTemplate,
hwndOwner,
lpDialogFunc,
dwInitParam,
SCDLG_CLIENT | (fAnsiFlags & (SCDLG_ANSI | SCDLG_16BIT)));
}
/*
* CreateDialogIndirectParamA (API)
* CreateDialogIndirectParamW (API)
* Creates a dialog given a template and return s the window handle.
* fAnsi determines if the dialog has an ANSI or UNICODE lpDialogFunc
* 05-Apr-1991 ScottLu Created.
*/
HWND WINAPI CreateDialogIndirectParamA(
HINSTANCE hmod,
LPCDLGTEMPLATEA lpDlgTemplate,
HWND hwndOwner,
DLGPROC lpDialogFunc,
LPARAM dwInitParam)
{
return CreateDialogIndirectParamAorW(hmod,
(LPCDLGTEMPLATE)lpDlgTemplate,
hwndOwner,
lpDialogFunc,
dwInitParam,
SCDLG_ANSI);
}
HWND WINAPI CreateDialogIndirectParamW(
HINSTANCE hmod,
LPCDLGTEMPLATEW lpDlgTemplate,
HWND hwndOwner,
DLGPROC lpDialogFunc,
LPARAM dwInitParam)
{
return CreateDialogIndirectParamAorW(hmod,
(LPCDLGTEMPLATE)lpDlgTemplate,
hwndOwner,
lpDialogFunc,
dwInitParam,
0);
}
HWND WINAPI CreateDialogIndirectParamAorW(
HANDLE hmod,
LPCDLGTEMPLATE lpDlgTemplate,
HWND hwndOwner,
DLGPROC lpDialogFunc,
LPARAM dwInitParam,
UINT fAnsi)
{
DWORD cb;
HWND hwndRet;
/*
* The server routine destroys the menu if it fails.
*/
cb = GetSizeDialogTemplate(hmod, lpDlgTemplate);
if (!cb) {
RIPMSG0(RIP_WARNING, "CreateDialogIndirect: Invalid Parameter");
return NULL;
}
hwndRet = InternalCreateDialog(hmod,
(LPDLGTEMPLATE)lpDlgTemplate,
cb,
hwndOwner,
lpDialogFunc,
dwInitParam,
SCDLG_CLIENT | (fAnsi & (SCDLG_ANSI|SCDLG_16BIT)));
return hwndRet;
}
/*
* DialogBoxParamA (API)
* DialogBoxParamW (API)
* Loads the resource, creates the dialog and goes into a modal loop processing
* input for it.
* 05-Apr-1991 ScottLu Created.
*/
INT_PTR WINAPI DialogBoxParamA(
HINSTANCE hmod,
LPCSTR lpName,
HWND hwndOwner,
DLGPROC lpDialogFunc,
LPARAM dwInitParam)
{
HANDLE h;
PVOID p;
INT_PTR i = -1;
if (h = FINDRESOURCEA(hmod, (LPSTR)lpName, (LPSTR)RT_DIALOG)) {
if (h = LOADRESOURCE(hmod, h)) {
if (p = LOCKRESOURCE(h, hmod)) {
i = DialogBoxIndirectParamAorW(hmod,
p,
hwndOwner,
lpDialogFunc,
dwInitParam,
SCDLG_ANSI);
UNLOCKRESOURCE(h, hmod);
}
FREERESOURCE(h, hmod);
}
}
return i;
}
INT_PTR WINAPI DialogBoxParamW(
HINSTANCE hmod,
LPCWSTR lpName,
HWND hwndOwner,
DLGPROC lpDialogFunc,
LPARAM dwInitParam)
{
HANDLE h;
PVOID p;
INT_PTR i = -1;
UserAssert(LOWORD(hmod) == 0); // This should never be a WOW module
if (h = FINDRESOURCEW(hmod, lpName, RT_DIALOG)) {
if (p = LoadResource(hmod, h)) {
i = DialogBoxIndirectParamAorW(hmod,
p,
hwndOwner,
lpDialogFunc,
dwInitParam,
0);
}
}
return i;
}
/*
* CreateDialogParamA (API)
* CreateDialogParamW (API)
* Loads the resource, creates a dialog from that template, return s the
* window handle.
* 05-Apr-1991 ScottLu Created.
*/
HWND WINAPI CreateDialogParamA(
HINSTANCE hmod,
LPCSTR lpName,
HWND hwndOwner,
DLGPROC lpDialogFunc,
LPARAM dwInitParam)
{
HANDLE h;
LPDLGTEMPLATEA p;
HWND hwnd = NULL;
if (h = FINDRESOURCEA(hmod, lpName, (LPSTR)RT_DIALOG)) {
if (h = LOADRESOURCE(hmod, h)) {
if (p = (LPDLGTEMPLATEA)LOCKRESOURCE(h, hmod)) {
hwnd = CreateDialogIndirectParamAorW(hmod,
(LPCDLGTEMPLATE)p,
hwndOwner,
lpDialogFunc,
dwInitParam,
SCDLG_ANSI);
UNLOCKRESOURCE(h, hmod);
}
FREERESOURCE(h, hmod);
}
}
return hwnd;
}
HWND WINAPI CreateDialogParamW(
HINSTANCE hmod,
LPCWSTR lpName,
HWND hwndOwner,
DLGPROC lpDialogFunc,
LPARAM dwInitParam)
{
HANDLE h;
PVOID p;
HWND hwnd = NULL;
if (h = FINDRESOURCEW(hmod, lpName, RT_DIALOG)) {
if (h = LOADRESOURCE(hmod, h)) {
if (p = LOCKRESOURCE(h, hmod)) {
hwnd = CreateDialogIndirectParamAorW(hmod,
p,
hwndOwner,
lpDialogFunc,
dwInitParam,
0);
UNLOCKRESOURCE(h, hmod);
}
FREERESOURCE(h, hmod);
}
}
return hwnd;
}
/*
* DestroyCursor (API)
* Client wrapper for NtUserDestroyCursor.
* 28-Nov-1994 JimA Created.
*/
BOOL WINAPI DestroyCursor(
HCURSOR hcur)
{
return NtUserDestroyCursor(hcur, CURSOR_CALLFROMCLIENT);
}
/*
* CreateIcoCur
*/
HICON CreateIcoCur(
PCURSORDATA lpi)
{
HCURSOR hcur;
UserAssert(lpi->hbmColor || lpi->hbmMask);
hcur = (HCURSOR)NtUserCallOneParam((lpi->CURSORF_flags & CURSORF_GLOBAL),
SFI__CREATEEMPTYCURSOROBJECT);
if (hcur == NULL)
return NULL;
#if DBG
{
BITMAP bmMask;
BITMAP bmColor;
UserAssert(GetObject(lpi->hbmMask, sizeof(BITMAP), &bmMask));
/* Bug 252902 - joejo
* Since the width and height of the mask bitmap is set below
* we really don't need to assert on the width/height check. Throwing
* a warning should be good enough.
*/
if (bmMask.bmWidth != (LONG)lpi->cx) {
RIPMSG1(RIP_WARNING, "Mask width not equal to requested width: lpi %#p", lpi);
}
if (bmMask.bmHeight != (LONG)lpi->cy) {
RIPMSG1(RIP_WARNING, "Mask height not equal to requested height: lpi %#p", lpi);
}
if (lpi->hbmColor) {
UserAssert(GetObject(lpi->hbmColor, sizeof(BITMAP), &bmColor));
UserAssert(bmMask.bmHeight == bmColor.bmHeight * 2);
UserAssert(bmMask.bmWidth == bmColor.bmWidth);
}
}
#endif
if (_SetCursorIconData(hcur, lpi))
return hcur;
NtUserDestroyCursor(hcur, CURSOR_ALWAYSDESTROY);
return NULL;
}
/*
* CreateIcoCurIndirect
*/
HCURSOR CreateIcoCurIndirect(
PCURSORDATA pcurCreate,
UINT cPlanes,
UINT cBitsPixel,
CONST BYTE *lpANDbits,
CONST BYTE *lpXORbits)
{
int cbBits;
HCURSOR hcurNew;
BOOL bColor;
UINT cx;
UINT cy;
LPBYTE pBits = NULL;
/*
* Allocate CURSOR structure.
*/
hcurNew = (HCURSOR)NtUserCallOneParam(0, SFI__CREATEEMPTYCURSOROBJECT);
if (hcurNew == NULL)
return NULL;
/*
* If there is no Color bitmap, create a single buffer that contains both
* the AND and XOR bits. The AND bitmap is always MonoChrome
*/
bColor = (cPlanes | cBitsPixel) > 1;
if (!bColor) {
cbBits = (((pcurCreate->cx + 0x0F) & ~0x0F) >> 3) * pcurCreate->cy;
pBits = (LPBYTE)UserLocalAlloc(HEAP_ZERO_MEMORY, (cbBits * 2));
if (pBits == NULL) {
NtUserDestroyCursor(hcurNew, CURSOR_ALWAYSDESTROY);
return NULL;
}
RtlCopyMemory(pBits, lpANDbits, cbBits);
RtlCopyMemory(pBits + cbBits, lpXORbits, cbBits);
lpANDbits = pBits;
}
/*
* Create hbmMask (its always MonoChrome)
*/
cx = pcurCreate->cx;
cy = pcurCreate->cy * 2;
pcurCreate->hbmMask = CreateBitmap(cx, cy, 1, 1, lpANDbits);
if (pcurCreate->hbmMask == NULL) {
/*
* If this is a COLOR icon/cursor, lpANDBits doesn't need to be
* pcurCreate->cy * 2; indeed, we don't use this double height at all.
* This is a bug that will be fixed post 4.0.
* For now, let's try to handle the case where the CreateBitmap call
* failed because the caller didn't pass in a double height AND mask
* (Win95 doesn't have this bug)
*/
if (bColor) {
RIPMSG0(RIP_WARNING, "CreateIcoCurIndirect: Retrying hbmMask creation.");
cbBits = (((pcurCreate->cx + 0x0F) & ~0x0F) >> 3) * pcurCreate->cy;
pBits = (LPBYTE)UserLocalAlloc(HEAP_ZERO_MEMORY, cbBits*2);
if (pBits == NULL) {
NtUserDestroyCursor(hcurNew, CURSOR_ALWAYSDESTROY);
return NULL;
}
RtlCopyMemory(pBits, lpANDbits, cbBits);
pcurCreate->hbmMask = CreateBitmap(cx, cy, 1, 1, pBits);
UserLocalFree(pBits);
pBits = NULL;
}
if (pcurCreate->hbmMask == NULL) {
/*
* CreateBitmap() failed. Clean-up and get out of here.
*/
NtUserDestroyCursor(hcurNew, CURSOR_ALWAYSDESTROY);
if (pBits != NULL)
UserLocalFree(pBits);
return NULL;
}
}
/*
* Create hbmColor or NULL it so that CallOEMCursor doesn't think we are
* color.
*/
if (bColor) {
pcurCreate->hbmColor = CreateBitmap(cx,
cy / 2,
cPlanes,
cBitsPixel,
lpXORbits);
if (pcurCreate->hbmColor == NULL) {
/*
* CreateBitmap() failed. Clean-up and get out of here.
*/
DeleteObject(pcurCreate->hbmMask);
NtUserDestroyCursor(hcurNew, CURSOR_ALWAYSDESTROY);
return NULL;
}
pcurCreate->bpp = (cPlanes * cBitsPixel);
} else {
pcurCreate->hbmColor = NULL;
pcurCreate->bpp = 1;
}
/*
* Load contents into the cursor/icon object
*/
pcurCreate->cy = cy;
pcurCreate->lpModName = NULL;
pcurCreate->lpName = NULL;
pcurCreate->rt = 0;
pcurCreate->CURSORF_flags = 0;
if (_SetCursorIconData(hcurNew, pcurCreate)) {
if (pBits != NULL)
UserLocalFree(pBits);
return hcurNew;
}
/*
* Could not set up cursor/icon, so free resources.
*/
NtUserDestroyCursor(hcurNew, CURSOR_ALWAYSDESTROY);
DeleteObject(pcurCreate->hbmMask);
if (pcurCreate->hbmColor)
DeleteObject(pcurCreate->hbmColor);
if (pBits != NULL)
UserLocalFree(pBits);
return NULL;
}
/*
* CreateCursor (API)
* History:
* 26-Feb-1991 MikeKe Created.
* 01-Aug-1991 IanJa Init cur.pszModname or DestroyCursor will work
*/
HCURSOR WINAPI CreateCursor(
HINSTANCE hModule,
int iXhotspot,
int iYhotspot,
int iWidth,
int iHeight,
LPBYTE lpANDplane,
LPBYTE lpXORplane)
{
CURSORDATA cur;
UNREFERENCED_PARAMETER(hModule);
if ((iXhotspot < 0) || (iXhotspot > iWidth) ||
(iYhotspot < 0) || (iYhotspot > iHeight)) {
return 0;
}
RtlZeroMemory(&cur, sizeof(cur));
cur.xHotspot = (SHORT)iXhotspot;
cur.yHotspot = (SHORT)iYhotspot;
cur.cx = (DWORD)iWidth;
cur.cy = (DWORD)iHeight;
return CreateIcoCurIndirect(&cur, 1, 1, lpANDplane, lpXORplane);
}
/*
* CreateIcon (API)
* History:
* 26-Feb-1991 MikeKe Created.
* 01-Aug-1991 IanJa Init cur.pszModname so DestroyIcon will work
*/
HICON WINAPI CreateIcon(
HINSTANCE hModule,
int iWidth,
int iHeight,
BYTE planes,
BYTE bpp,
CONST BYTE *lpANDplane,
CONST BYTE *lpXORplane)
{
CURSORDATA cur;
UNREFERENCED_PARAMETER(hModule);
RtlZeroMemory(&cur, sizeof(cur));
cur.xHotspot = (SHORT)(iWidth / 2);
cur.yHotspot = (SHORT)(iHeight / 2);
cur.cx = (DWORD)iWidth;
cur.cy = (DWORD)iHeight;
return CreateIcoCurIndirect(&cur, planes, bpp, lpANDplane, lpXORplane);
}
/*
* CreateIconIndirect (API)
* Creates an icon or cursor from an ICONINFO structure. Does not destroy
* cursor/icon bitmaps.
* 24-Jul-1991 ScottLu Created.
*/
HICON WINAPI CreateIconIndirect(
PICONINFO piconinfo)
{
HCURSOR hcur;
CURSORDATA cur;
BITMAP bmMask;
BITMAP bmColor;
HBITMAP hbmpBits2, hbmpMem;
HDC hdcMem;
/*
* Make sure the bitmaps are real, and get their dimensions.
*/
if (!GetObjectW(piconinfo->hbmMask, sizeof(BITMAP), &bmMask))
return NULL;
if (piconinfo->hbmColor != NULL) {
if (!GetObjectW(piconinfo->hbmColor, sizeof(BITMAP), &bmColor))
return NULL;
}
/*
* Allocate CURSOR structure.
*/
hcur = (HCURSOR)NtUserCallOneParam(0, SFI__CREATEEMPTYCURSOROBJECT);
if (hcur == NULL)
return NULL;
/*
* Internally, USER stores the height as 2 icons high - because when
* loading bits from a resource, in both b/w and color icons, the
* bits are stored on top of one another (AND/XOR mask, AND/COLOR bitmap).
* When bitmaps are passed in to CreateIconIndirect(), they are passed
* as two bitmaps in the color case, and one bitmap (with the stacked
* masks) in the black and white case. Adjust cur.cy so it is 2 icons
* high in both cases.
*/
RtlZeroMemory(&cur, sizeof(cur));
cur.cx = bmMask.bmWidth;
if (piconinfo->hbmColor == NULL) {
cur.cy = bmMask.bmHeight;
cur.bpp = 1;
} else {
cur.cy = bmMask.bmHeight * 2;
cur.bpp = (DWORD)(bmColor.bmBitsPixel * bmColor.bmPlanes);
cur.hbmColor = CopyBmp(piconinfo->hbmColor, 0, 0, LR_DEFAULTCOLOR);
if (cur.hbmColor == NULL) {
RIPMSG0(RIP_WARNING, "CreateIconIndirect: Failed to copy piconinfo->hbmColor");
goto CleanUp;
}
}
/*
* hbmMask must always be double height, even for color icons.
* So cy might be equal to bmMask.bmHeight * 2 at this point.
* If this is the case, the second half of hbmMask won't be initilized;
* nobody is supposed to use it but GDI expects it there when checking the
* bitmap dimensions (for cursors)
*/
cur.hbmMask = CreateBitmap(cur.cx, cur.cy, 1, 1, NULL);
if (cur.hbmMask == NULL) {
RIPMSG0(RIP_WARNING, "CreateIconIndirect: Failed to create cur.hbmMask");
goto CleanUp;
}
RtlEnterCriticalSection(&gcsHdc);
if (hdcMem = CreateCompatibleDC (ghdcBits2)) {
hbmpMem = SelectObject(hdcMem, cur.hbmMask);
hbmpBits2 = SelectObject(ghdcBits2, piconinfo->hbmMask);
BitBlt(hdcMem,
0,
0,
bmMask.bmWidth,
bmMask.bmHeight,
ghdcBits2,
0,
0,
SRCCOPY);
SelectObject(hdcMem, hbmpMem);
SelectObject(ghdcBits2, hbmpBits2);
DeleteDC (hdcMem);
} else {
RtlLeaveCriticalSection(&gcsHdc);
RIPMSG0(RIP_WARNING, "CreateIconIndirect: CreateCompatibleDC failed");
goto CleanUp;
}
RtlLeaveCriticalSection(&gcsHdc);
/*
* rt and Hotspot
*/
if (piconinfo->fIcon) {
cur.rt = PTR_TO_ID(RT_ICON);
cur.xHotspot = (SHORT)(cur.cx / 2);
cur.yHotspot = (SHORT)(cur.cy / 4);
} else {
cur.rt = PTR_TO_ID(RT_CURSOR);
cur.xHotspot = ((SHORT)piconinfo->xHotspot);
cur.yHotspot = ((SHORT)piconinfo->yHotspot);
}
if (_SetCursorIconData(hcur, &cur)) {
return hcur;
}
CleanUp:
/*
* Note that if this fails, the bitmaps have NOT been made public.
*/
if (cur.hbmMask != NULL) {
DeleteObject(cur.hbmMask);
}
if (cur.hbmColor != NULL) {
DeleteObject(cur.hbmColor);
}
NtUserDestroyCursor(hcur, CURSOR_ALWAYSDESTROY);
return NULL;
}
/*
* GetIconInfo (API)
* Returns icon information, including bitmaps.
* 24-Jul-1991 ScottLu Created.
*/
BOOL WINAPI GetIconInfo(
HICON hicon,
PICONINFO piconinfo)
{
return NtUserGetIconInfo(hicon, piconinfo, NULL, NULL, NULL, FALSE);
}
/*
* GetCursorFrameInfo (API)
* Returns cursor information.
* 24-Jul-1991 ScottLu Created.
*/
HCURSOR WINAPI GetCursorFrameInfo(
HCURSOR hcur,
LPWSTR lpName,
int iFrame,
LPDWORD pjifRate,
LPINT pccur)
{
/*
* Caller wants us to return the version of this cursor that is stored
* in the display driver.
*/
if (hcur == NULL) {
return LoadIcoCur(NULL,
lpName,
RT_CURSOR,
0,
0,
LR_DEFAULTSIZE);
}
return NtUserGetCursorFrameInfo(hcur, iFrame, pjifRate, pccur);
}
/*
* _FreeResource (API)
* _LockResource (API)
* _UnlockResource (API)
* These are dummy routines that need to exist for the apfnResCallNative
* array, which is used when calling the run-time libraries.
*/
BOOL WINAPI _FreeResource(
HANDLE hResData,
HINSTANCE hModule)
{
UNREFERENCED_PARAMETER(hResData);
UNREFERENCED_PARAMETER(hModule);
return FALSE;
}
LPSTR WINAPI _LockResource(
HANDLE hResData,
HINSTANCE hModule)
{
UNREFERENCED_PARAMETER(hModule);
return (LPSTR)(hResData);
}
BOOL WINAPI _UnlockResource(
HANDLE hResData,
HINSTANCE hModule)
{
UNREFERENCED_PARAMETER(hResData);
UNREFERENCED_PARAMETER(hModule);
return TRUE;
}
/*
* LookupIconIdFromDirectory (API)
* This searches through an icon directory for the icon that best fits the
* current display device.
* 24-07-1991 ScottLu Created.
*/
int WINAPI LookupIconIdFromDirectory(
PBYTE presbits,
BOOL fIcon)
{
return LookupIconIdFromDirectoryEx(presbits, fIcon, 0, 0, 0);
}
/*
* LookupIconIdFromDirectoryEx (API)
*/
int WINAPI LookupIconIdFromDirectoryEx(
PBYTE presbits,
BOOL fIcon,
int cxDesired,
int cyDesired,
UINT LR_flags)
{
ConnectIfNecessary();
return RtlGetIdFromDirectory(presbits,
fIcon,
cxDesired,
cyDesired,
LR_flags,
NULL);
}
/*
* LoadCursorIconFromResource (API)
* Loads animated icon/cursor from a pointer to a resource
* 02-20-1996 GerardoB Created.
*/
HANDLE LoadCursorIconFromResource(
PBYTE presbits,
LPCWSTR lpName,
int cxDesired,
int cyDesired,
UINT LR_flags)
{
BOOL fAni;
FILEINFO fi;
LPWSTR lpwszRT;
fi.pFileMap = presbits;
fi.pFilePtr = fi.pFileMap;
fi.pFileEnd = fi.pFileMap + sizeof (RTAG) + ((RTAG *)presbits)->ckSize;
fi.pszName = lpName;
return LoadCursorIconFromFileMap(&fi,
&lpwszRT,
cxDesired,
cyDesired,
LR_flags,
&fAni);
}
/*
* CreateIconFromResource (API)
* Takes resource bits and creates either an icon or cursor.
* 24-07-1991 ScottLu Created.
*/
HICON WINAPI CreateIconFromResource(
PBYTE presbits,
DWORD dwResSize,
BOOL fIcon,
DWORD dwVer)
{
return CreateIconFromResourceEx(presbits,
dwResSize,
fIcon,
dwVer,
0,
0,
LR_DEFAULTSIZE | LR_SHARED);
}
/*
* CreateIconFromResourceEx (API)
* Takes resource bits and creates either an icon or cursor.
* 30-Aug-1994 FritzS Created
*/
HICON WINAPI CreateIconFromResourceEx(
PBYTE presbits,
DWORD dwResSize,
BOOL fIcon,
DWORD dwVer,
int cxDesired,
int cyDesired,
UINT LR_flags)
{
UNREFERENCED_PARAMETER(dwResSize);
/*
* NT Specific code to validate the version.
*/
if ((dwVer < 0x00020000) || (dwVer > 0x00030000)) {
RIPMSG0(RIP_WARNING, "CreateIconFromResourceEx: Invalid Paramter");
return NULL;
}
/*
* Set desired size of resource based on flags and/or true
* dimensions passed in.
*/
cxDesired = GetIcoCurWidth(cxDesired , fIcon, LR_flags, 0);
cyDesired = GetIcoCurHeight(cyDesired, fIcon, LR_flags, 0);
if (ISRIFFFORMAT(presbits)) {
return LoadCursorIconFromResource (presbits, NULL, cxDesired, cyDesired, LR_flags);
} else {
return ConvertDIBIcon((LPBITMAPINFOHEADER)presbits,
NULL,
NULL,
fIcon,
cxDesired,
cyDesired,
LR_flags);
}
}
/*
* Convert1BppToMonoBitmap
* This routine converts a 1bpp bitmap to a true monochrome surface. This
* is done for bitmaps which need to do foreground/background color matching
* at output time. Otherwise, a 1bpp will just match to its palette.
* NOTE: This routine deletes the original bitmap if successful. If failure
* we'll return the original bitmap.
* History:
* 17-Apr-1996 ChrisWil Created
*/
HBITMAP Convert1BppToMonoBitmap(
HDC hdcSrc,
HBITMAP hbm1Bpp)
{
HBITMAP hbmMono = hbm1Bpp;
HBITMAP hbmDst;
HBITMAP hbmS;
HBITMAP hbmD;
HDC hdcDst;
BITMAP bm;
if (hdcDst = CreateCompatibleDC(hdcSrc)) {
GetObject(hbm1Bpp, sizeof(BITMAP), &bm);
if (hbmDst = CreateBitmap(bm.bmWidth, bm.bmHeight, 1, 1, NULL)) {
hbmS = SelectBitmap(hdcSrc, hbm1Bpp);
hbmD = SelectBitmap(hdcDst, hbmDst);
BitBlt(hdcDst,
0,
0,
bm.bmWidth,
bm.bmHeight,
hdcSrc,
0,
0,
SRCCOPY);
SelectBitmap(hdcSrc, hbmS);
SelectBitmap(hdcDst, hbmD);
hbmMono = hbmDst;
DeleteObject(hbm1Bpp);
}
DeleteDC(hdcDst);
}
return hbmMono;
}
/*
* CreateScreenBitmap
* This routine creates a screen bitmap. We use the CreateDIBitmap call
* to do compatible color-matching with Win95. Also, note that this
* routine takes in WORD aligned bits.
*/
HBITMAP CreateScreenBitmap(
int cx,
int cy,
UINT planes,
UINT bpp,
LPSTR lpBits,
LPBOOL pf1Bpp)
{
HDC hdcScreen;
HBITMAP hbm = NULL;
DWORD dwCount;
static struct {
BITMAPINFOHEADER bi;
DWORD ct[16];
} dib4Vga = {{sizeof(BITMAPINFOHEADER),
0,
0,
1,
4,
BI_RGB,
0,
0,
0,
16,
0
},
{0x00000000,
0x00800000,
0x00008000,
0x00808000,
0x00000080,
0x00800080,
0x00008080,
0x00C0C0C0,
0x00808080,
0x00FF0000,
0x0000FF00,
0x00FFFF00,
0x000000FF,
0x00FF00FF,
0x0000FFFF,
0x00FFFFFF
}
};
static struct {
BITMAPINFOHEADER bi;
DWORD ct[2];
} dib1Vga = {{sizeof(BITMAPINFOHEADER),
0,
0,
1,
1,
BI_RGB,
0,
0,
0,
2,
0
},
{0x00000000,
0x00FFFFFF
}
};
/*
* Create the surface.
*/
if (hdcScreen = GETINITDC()) {
/*
* This appears to mess up color to mono conversion by losing all
* the data and forcing all non-forground colors to black.
* (try copyimage with IDC_WARNING_DEFAULT)
* This is what win95 does but their system works. The scary thing
* (according to marke) is that win95 may have changed GDI to make
* this work.
* In order to get nearest-color-matching compatible with Win95,
* we're going to need to use the CreateDIBitmap() for mono-surfaces.
* This code-path will do nearest-color, rather than color-matching.
*/
if ((bpp == 1) && (planes == 1)) {
dib1Vga.bi.biWidth = cx;
dib1Vga.bi.biHeight = cy;
hbm = CreateDIBitmap(hdcScreen,
(LPBITMAPINFOHEADER)&dib1Vga,
CBM_CREATEDIB,
NULL,
(LPBITMAPINFO)&dib1Vga,
DIB_RGB_COLORS);
*pf1Bpp = TRUE;
} else {
if (((planes == 0) || (planes == gpsi->Planes)) &&
((bpp == 0) || (bpp == gpsi->BitsPixel))) {
hbm = CreateCompatibleBitmap(hdcScreen, cx, cy);
} else {
dib4Vga.bi.biBitCount = planes * bpp ? planes * bpp : gpsi->BitCount;
#if 0 // We use to do the dib-section create, but this breaks icons
// when they are made public (can't make a dibsection public). So
// we now wil create this as a real-dib.
{
DWORD dwDummy;
dib4Vga.bi.biWidth = cx;
dib4Vga.bi.biHeight = -cy; // top-down DIB (like a DDB)
hbm = CreateDIBSection(hdcScreen,
(LPBITMAPINFO)&dib4Vga,
DIB_RGB_COLORS,
(LPVOID)&dwDummy,
0,
0);
}
#else
dib4Vga.bi.biWidth = cx;
dib4Vga.bi.biHeight = cy;
hbm = CreateDIBitmap(hdcScreen,
(LPBITMAPINFOHEADER)&dib4Vga,
CBM_CREATEDIB,
NULL,
(LPBITMAPINFO)&dib4Vga,
DIB_RGB_COLORS);
#endif
}
}
RELEASEINITDC(hdcScreen);
}
if (hbm && lpBits) {
BITMAP bm;
GetObject(hbm, sizeof(BITMAP), &bm);
dwCount = (DWORD)(UINT)(bm.bmWidthBytes * bm.bmPlanes) * (DWORD)(UINT)cy;
SetBitmapBits(hbm, dwCount, lpBits);
}
return hbm;
}
/*
* LoadBmp (Worker)
* This routine decides whether the bitmap to be loaded is in old or new (DIB)
* format and calls appropriate handlers.
* History:
* 24-Sep-1990 MikeKe From Win30.
* 18-Jun-1991 ChuckWh Added local bitmap handle support.
* 05-Sep-1995 ChrisWil Port/Change for Chicago functionality.
*/
HBITMAP LoadBmp(
HINSTANCE hmod,
LPCWSTR lpName,
int cxDesired,
int cyDesired,
UINT flags)
{
HBITMAP hbmp = NULL;
BOOL fFree = FALSE;
BOOL f1Bpp = FALSE;
/*
* Bitmap Resource Table
* As of WIN4.0, most system bitmaps are rendered instead of grabbed from the
* display driver. However, a lot of apps, especially those that fake their
* own MDI, do LoadBitmap(NULL, OBM_...) to grab a system bitmap. So we
* hook those requests here and copy our rendered bitmaps into a newly-
* created bitmap. Note that this is actually faster than loading from a
* resource table!
* BOGUS -- give 'em old close buttons, not new cool X's
*/
#define MAX_BMPMAP 32
CONST static MAPRES MapOemBmp[MAX_BMPMAP] = {
{OBM_BTNCORNERS , OBI_RADIOMASK , },
{OBM_BTSIZE , OBI_NCGRIP , },
{OBM_CHECK , OBI_MENUCHECK , MR_MONOCHROME },
{OBM_CHECKBOXES , OBI_CHECK , },
{OBM_COMBO , OBI_DNARROW , },
{OBM_DNARROW , OBI_DNARROW , },
{OBM_DNARROWD , OBI_DNARROW_D , },
{OBM_DNARROWI , OBI_DNARROW_I , },
{OBM_LFARROW , OBI_LFARROW , },
{OBM_LFARROWD , OBI_LFARROW_D , },
{OBM_LFARROWI , OBI_LFARROW_I , },
/*
* Use MONO bitmaps in future once flat/mono controls are worked out.
*/
{OBM_OLD_DNARROW, OBI_DNARROW , MR_FAILFOR40 },
{OBM_OLD_LFARROW, OBI_LFARROW , MR_FAILFOR40 },
{OBM_OLD_REDUCE , OBI_REDUCE_MBAR , MR_FAILFOR40 },
{OBM_OLD_RESTORE, OBI_RESTORE_MBAR , MR_FAILFOR40 },
{OBM_OLD_RGARROW, OBI_RGARROW , MR_FAILFOR40 },
{OBM_OLD_UPARROW, OBI_UPARROW , MR_FAILFOR40 },
{OBM_OLD_ZOOM , OBI_ZOOM , MR_FAILFOR40 },
{OBM_MNARROW , OBI_MENUARROW , MR_MONOCHROME },
{OBM_REDUCE , OBI_REDUCE_MBAR , },
{OBM_REDUCED , OBI_REDUCE_MBAR_D , },
{OBM_RESTORE , OBI_RESTORE_MBAR , },
{OBM_RESTORED , OBI_RESTORE_MBAR_D , },
{OBM_RGARROW , OBI_RGARROW , },
{OBM_RGARROWD , OBI_RGARROW_D , },
{OBM_RGARROWI , OBI_RGARROW_I , },
{OBM_SIZE , OBI_NCGRIP , },
{OBM_UPARROW , OBI_UPARROW , },
{OBM_UPARROWD , OBI_UPARROW_D , },
{OBM_UPARROWI , OBI_UPARROW_I , },
{OBM_ZOOM , OBI_ZOOM , },
{OBM_ZOOMD , OBI_ZOOM_D , }
};
/*
* If hmod is valid, load the client-side bits.
*/
if (hmod == NULL) {
HBITMAP hOldBmp;
WORD bm;
WORD wID;
BOOL fCombo;
BOOL fCheckBoxes;
int i;
RECT rc;
BOOL fSysMenu = FALSE;
BOOL fMenu = FALSE;
BOOL fMono = FALSE;
hmod = hmodUser;
/*
* Since the resource is coming from USER32, we only
* deal with ID types.
*/
wID = PTR_TO_ID(lpName);
switch(wID) {
case OBM_OLD_CLOSE:
if (GETAPPVER() >= VER40)
goto FailOldLoad;
/*
* fall through to the Close case.
*/
case OBM_CLOSE:
/* the new look for the system menu is to use the window's
* class icon -- but since here we don't know which window
* they'll be using this for, fall back on the good ole'
* windows logo icon
*/
cxDesired = (SYSMET(CXMENUSIZE) + SYSMET(CXEDGE)) * 2;
cyDesired = SYSMET(CYMENUSIZE) + (2 * SYSMET(CYEDGE));
fSysMenu = TRUE;
break;
case OBM_TRUETYPE: {
PVOID p;
HANDLE h;
int nOffset;
/*
* Offset into resource.
*/
if (gpsi->dmLogPixels == 120) {
nOffset = OFFSET_120_DPI;
} else {
nOffset = OFFSET_96_DPI;
}
lpName = (LPWSTR)(MAX_RESOURCE_INDEX -
((ULONG_PTR)lpName) + nOffset);
if (h = FINDRESOURCEW(hmod, (LPWSTR)lpName, RT_BITMAP)) {
if (h = LOADRESOURCE(hmod, h)) {
if (p = LOCKRESOURCE(h, hmod)) {
hbmp = (HBITMAP)ObjectFromDIBResource(hmod,
lpName,
RT_BITMAP,
cxDesired,
cyDesired,
flags);
UNLOCKRESOURCE(h, hmod);
}
FREERESOURCE(h, hmod);
}
}
goto LoadBmpDone;
}
break;
default:
fCombo = (wID == OBM_COMBO);
fCheckBoxes = (wID == OBM_CHECKBOXES);
/*
* hard loop to check for mapping.
*/
for (i=0; (i < MAX_BMPMAP) && (MapOemBmp[i].idDisp != wID); i++);
if (i == MAX_BMPMAP)
goto LoadForReal;
if ((MapOemBmp[i].bFlags & MR_FAILFOR40) &&
(GETAPPVER() >= VER40)) {
FailOldLoad:
RIPMSG0(RIP_WARNING, "LoadBitmap: old IDs not allowed for 4.0 apps");
return NULL;
}
if (MapOemBmp[i].bFlags & MR_MONOCHROME)
fMono = TRUE;
bm = MapOemBmp[i].idUser;
if ((bm == OBI_REDUCE_MBAR) || (bm == OBI_RESTORE_MBAR))
fMenu = TRUE;
cxDesired = gpsi->oembmi[bm].cx;
cyDesired = gpsi->oembmi[bm].cy;
if (fMenu)
cyDesired += (2 * SYSMET(CYEDGE));
if (fCheckBoxes) {
cxDesired *= NUM_BUTTON_STATES;
cyDesired *= NUM_BUTTON_TYPES;
} else if (fCombo) {
cxDesired -= (2 * SYSMET(CXEDGE));
cyDesired -= (2 * SYSMET(CYEDGE));
}
break;
}
/*
* Creates DIB section or color compatible.
*/
if (fMono) {
/*
* Create mono-bitmaps as DIBs on NT. On Win95 this is
* called as:
* hbmp = CreateBitmap(cxDesired, cyDesired, 1, 1, NULL);
* However, due to color-matching differences, we need to
* use dibs to get the nearest-color-matching. At the
* end of this routine we will convert to a true-mono so that
* foreground/background matching can be performed normally.
*/
hbmp = CreateScreenBitmap(cxDesired, cyDesired, 1, 1, NULL, &f1Bpp);
} else {
hbmp = CreateScreenBitmap(cxDesired, cyDesired, 0, 0, NULL, &f1Bpp);
}
if (hbmp == NULL)
goto LoadBmpDone;
RtlEnterCriticalSection(&gcsHdc);
hOldBmp = SelectBitmap(ghdcBits2, hbmp);
UserAssert(GetBkColor(ghdcBits2) == RGB(255,255,255));
UserAssert(GetTextColor(ghdcBits2) == RGB(0, 0, 0));
rc.top = 0;
rc.left = 0;
rc.bottom = cyDesired;
rc.right = cxDesired;
if (fMono) {
PatBlt(ghdcBits2, 0, 0, cxDesired, cyDesired, WHITENESS);
} else {
FillRect(ghdcBits2,
&rc,
((fMenu | fSysMenu) ? SYSHBR(MENU) : SYSHBR(WINDOW)));
}
if (fSysMenu) {
int x = SYSMET(CXEDGE);
int i;
cxDesired /= 2;
for (i=0; i < 2; i++) {
DrawIconEx(ghdcBits2,
x,
SYSMET(CYEDGE),
gpsi->hIconSmWindows,
cxDesired - 2 * SYSMET(CXEDGE),
SYSMET(CYMENUSIZE) - SYSMET(CYEDGE),
0,
NULL,
DI_NORMAL);
x += cxDesired;
}
} else if (fCombo) {
/*
* Revisit when we start using TTF -- that'll take care of
* this hack.
*/
rc.top = -SYSMET(CYEDGE);
rc.bottom += SYSMET(CYEDGE);
rc.left = -SYSMET(CXEDGE);
rc.right += SYSMET(CXEDGE);
DrawFrameControl(ghdcBits2,
&rc,
DFC_SCROLL,
DFCS_SCROLLDOWN);
} else if (fCheckBoxes) {
int wType;
int wState;
int x;
DWORD clrTextSave;
DWORD clrBkSave;
int y = 0;
for (wType=0; wType < NUM_BUTTON_TYPES; wType++) {
x = 0;
cxDesired = gpsi->oembmi[bm].cx;
cyDesired = gpsi->oembmi[bm].cy;
if (wType == 1) {
/*
* BOGUS UGLINESS -- will be fixed once the Graphics dudes
* get me the icon TTF -- I'll revisit this then and make
* REAL
*/
clrTextSave = SetTextColor(ghdcBits2, RESCLR_BLACK);
clrBkSave = SetBkColor (ghdcBits2, RESCLR_WHITE);
for (wState = 0; wState < NUM_BUTTON_STATES; wState++) {
NtUserBitBltSysBmp(ghdcBits2,
x,
y,
cxDesired,
cyDesired,
gpsi->oembmi[OBI_RADIOMASK].x,
gpsi->oembmi[OBI_RADIOMASK].y,
SRCAND);
NtUserBitBltSysBmp(ghdcBits2,
x,
y,
cxDesired,
cyDesired,
gpsi->oembmi[bm].x,
gpsi->oembmi[bm].y,
SRCINVERT);
x += cxDesired;
bm++;
}
SetTextColor(ghdcBits2, clrTextSave);
SetBkColor(ghdcBits2, clrBkSave);
} else {
for (wState=0; wState < NUM_BUTTON_STATES; wState++) {
BitBltSysBmp(ghdcBits2, x, y, bm);
x += cxDesired;
bm++;
}
/*
* Skip OBI_*_CDI.
*/
bm++;
}
y += cyDesired;
}
} else {
BitBltSysBmp(ghdcBits2, 0, fMenu ? SYSMET(CYEDGE) : 0, bm);
}
SelectBitmap(ghdcBits2, hOldBmp);
/*
* If the bitmap was created as a 1bpp, we need to convert to a
* true mono-bitmap. GDI performs different color-matching depending
* upon this case.
*/
if (f1Bpp && hbmp)
hbmp = Convert1BppToMonoBitmap(ghdcBits2, hbmp);
RtlLeaveCriticalSection(&gcsHdc);
} else {
LoadForReal:
hbmp = (HBITMAP)ObjectFromDIBResource(hmod,
lpName,
RT_BITMAP,
cxDesired,
cyDesired,
flags);
}
LoadBmpDone:
return hbmp;
}
/*
* LoadBitmapA (API)
* LoadBitmapW (API)
* Loads a bitmap from client. If hmod == NULL, loads a bitmap from the
* system.
*/
HBITMAP WINAPI LoadBitmapA(
HINSTANCE hmod,
LPCSTR lpName)
{
LPWSTR lpUniName;
HBITMAP hRet;
if (ID(lpName))
return LoadBmp(hmod, (LPCWSTR)lpName, 0, 0, 0);
if (!MBToWCS(lpName, -1, &lpUniName, -1, TRUE))
return NULL;
hRet = LoadBmp(hmod, lpUniName, 0, 0, 0);
UserLocalFree(lpUniName);
return hRet;
}
HBITMAP WINAPI LoadBitmapW(
HINSTANCE hmod,
LPCWSTR lpName)
{
return LoadBmp(hmod, lpName, 0, 0, 0);
}
/*
* LoadCursorA (API)
* LoadCursorW (API)
* Loads a cursor from client. If hmod == NULL, loads a cursor from the
* system.
* 05-Apr-1991 ScottLu Rewrote to work with client server.
*/
HCURSOR WINAPI LoadCursorA(
HINSTANCE hmod,
LPCSTR lpName)
{
HCURSOR hRet;
LPWSTR lpUniName;
if (ID(lpName))
return LoadCursorW(hmod, (LPWSTR)lpName);
if (!MBToWCS(lpName, -1, &lpUniName, -1, TRUE))
return NULL;
hRet = LoadCursorW(hmod, lpUniName);
UserLocalFree(lpUniName);
return hRet;
}
HCURSOR WINAPI LoadCursorW(
HINSTANCE hmod,
LPCWSTR lpName)
{
return LoadIcoCur(hmod,
lpName,
RT_CURSOR,
0,
0,
LR_DEFAULTSIZE | LR_SHARED);
}
/*
* LoadIconA (API)
* LoadIconW (API)
* Loads an icon from client. If hmod == NULL, loads an icon from the
* system.
* 05-Apr-1991 ScottLu Rewrote to work with client server.
*/
HICON WINAPI LoadIconA(
HINSTANCE hmod,
LPCSTR lpName)
{
HICON hRet;
LPWSTR lpUniName;
if (ID(lpName))
return LoadIconW(hmod, (LPWSTR)lpName);
if (!MBToWCS(lpName, -1, &lpUniName, -1, TRUE))
return NULL;
hRet = LoadIconW(hmod, lpUniName);
UserLocalFree(lpUniName);
return hRet;
}
HICON WINAPI LoadIconW(
HINSTANCE hmod,
LPCWSTR lpName)
{
return LoadIcoCur(hmod,
lpName,
RT_ICON,
0,
0,
LR_DEFAULTSIZE | LR_SHARED);
}
/*
* LoadImageA (API)
* LoadImageW (API)
* Loads a bitmap, icon or cursor resource from client. If hmod == NULL,
* then it will load from system-resources.
*/
HANDLE WINAPI LoadImageA(
HINSTANCE hmod,
LPCSTR lpName,
UINT type,
int cxDesired,
int cyDesired,
UINT flags)
{
LPWSTR lpUniName;
HANDLE hRet;
if (ID(lpName))
return LoadImageW(hmod,
(LPCWSTR)lpName,
type,
cxDesired,
cyDesired,
flags);
if (!MBToWCS(lpName, -1, &lpUniName, -1, TRUE))
return NULL;
hRet = LoadImageW(hmod, lpUniName, type, cxDesired, cyDesired, flags);
UserLocalFree(lpUniName);
return hRet;
}
HANDLE WINAPI LoadImageW(
HINSTANCE hmod,
LPCWSTR lpName,
UINT IMAGE_code,
int cxDesired,
int cyDesired,
UINT flags)
{
/*
* If we specified LR_LOADFROMFILE, then we can tweak the
* flags to turn off LR_SHARED.
*/
if (flags & LR_LOADFROMFILE)
flags &= ~LR_SHARED;
switch (IMAGE_code) {
case IMAGE_BITMAP:
return (HANDLE)LoadBmp(hmod, lpName, cxDesired, cyDesired, flags);
case IMAGE_CURSOR:
#if 0 //CHRISWIL : oemInfo.fColorCursors doesn't exist on NT.
if (!oemInfo.fColorCursors)
flags |= LR_MONOCHROME;
#endif
case IMAGE_ICON:
/*
* On WinNT 3.51, an app can successfully load a
* USER icon without specifying LR_SHARED. We enable
* these apps to succeed, but make 4.0 apps conform to
* Windows95 behavior.
*/
if (!hmod && GETEXPWINVER(NULL) < VER40) {
flags |= LR_SHARED;
}
return (HANDLE)LoadIcoCur(hmod,
lpName,
((IMAGE_code == IMAGE_ICON) ? RT_ICON : RT_CURSOR),
cxDesired,
cyDesired,
flags);
default:
RIPMSG0(RIP_WARNING, "LoadImage: invalid IMAGE_code");
return NULL;
}
}
/*
* GetIconIdEx
* This one accepts width, height, and other flags. Just not exported right
* now.
*/
UINT GetIconIdEx(
HINSTANCE hmod,
HANDLE hrsd,
LPCWSTR lpszType,
DWORD cxDesired,
DWORD cyDesired,
UINT LR_flags)
{
int idIcon = 0;
LPNEWHEADER lpnh;
if (lpnh = (LPNEWHEADER)LOCKRESOURCE(hrsd, hmod)) {
/*
* Do a sanity check on this data structure. Otherwise we'll GP FAULT
* when extracting an icon from a corrupted area. Fix for B#9290.
* SANKAR, 08/13/91
*/
if ((lpnh->Reserved == 0) &&
((lpnh->ResType == IMAGE_ICON) || (lpnh->ResType == IMAGE_CURSOR))) {
idIcon = LookupIconIdFromDirectoryEx((PBYTE)lpnh,
(lpszType == RT_ICON),
cxDesired,
cyDesired,
LR_flags);
}
UNLOCKRESOURCE(hrsd, hmod);
}
return idIcon;
}
/*
* LoadDib (Worker)
* This is the worker-routine for loading a resource and returning a handle
* to the object as a dib.
*/
HANDLE LoadDIB(
HINSTANCE hmod,
LPCWSTR lpName,
LPWSTR type,
DWORD cxDesired,
DWORD cyDesired,
UINT LR_flags)
{
HANDLE hDir;
UINT idIcon;
LPWSTR lpszGroupType;
HANDLE hRes = NULL;
switch (PTR_TO_ID(type)) {
case PTR_TO_ID(RT_ICON):
case PTR_TO_ID(RT_CURSOR):
lpszGroupType = RT_GROUP_CURSOR + (type - RT_CURSOR);
/*
* For WOW support, OIC_ICON and OIC_SIZE need to be supported.
* Since these resources match other existing resources, we map
* them here so we produce results that emulates
* behavor as if we had the actual resources in USER.
* Note that obsolete mapping of lpName in LoadIcoCur prevents
* win4.0 apps from getting here.
*/
if (hmod == hmodUser) {
switch ((ULONG_PTR)lpName) {
case OCR_SIZE:
lpName = (LPCWSTR)OCR_SIZEALL_DEFAULT;
break;
case OCR_ICON:
lpName = (LPCWSTR)OCR_ICON_DEFAULT;
break;
}
}
/*
* The resource is actually a directory which contains multiple
* individual image resources we must choose from.
* Locate the directory
*/
if (hDir = SplFindResource(hmod, lpName, (LPCWSTR)lpszGroupType)) {
/*
* Load the directory.
*/
if (hDir = LOADRESOURCE(hmod, hDir)) {
/*
* Get the name of the best individual image.
*/
if (idIcon = GetIconIdEx(hmod,
hDir,
type,
cxDesired,
cyDesired,
LR_flags)) {
/*
* NOTE: Don't free the directory resource!!! - ChipA.
* We can't call SplFindResource here, because idIcon
* is internal to us and GetDriverResourceId()
* doesn't know how to map it.
*/
hRes = FINDRESOURCEW(hmod, MAKEINTRESOURCE(idIcon), type);
}
/*
* BOGUS:
* It would be very cool if we could loop through all the
* items in the directory and free 'em too. Free the ones
* except for the one we're about to load, that is.
* Free directory resources TWICE so they get really freed.
*/
SplFreeResource(hDir, hmod, LR_flags);
}
} else {
/*
* Failed to load a regular icon\cursor.
* Try to load an animated icon/cursor with the same name
*/
hRes = SplFindResource(hmod, lpName,
PTR_TO_ID(type) == PTR_TO_ID(RT_CURSOR) ? RT_ANICURSOR : RT_ANIICON);
}
break;
case PTR_TO_ID(RT_BITMAP):
hRes = SplFindResource(hmod, lpName, RT_BITMAP);
break;
default:
RIPMSG0(RIP_WARNING, "LoadDIB: Invalid resource type");
break;
}
if (hRes)
hRes = LOADRESOURCE(hmod, hRes);
return hRes;
}
/*
* LoadIcoCur (Worker)
*/
HICON LoadIcoCur(
HINSTANCE hmod,
LPCWSTR pszResName,
LPWSTR type,
DWORD cxDesired,
DWORD cyDesired,
UINT LR_flags)
{
HICON hico;
LPWSTR pszModName;
WCHAR achModName[MAX_PATH];
ConnectIfNecessary();
/*
* Setup module name and handles for lookup.
*/
if (hmod == NULL) {
hmod = hmodUser;
pszModName = szUSER32;
} else {
WowGetModuleFileName(hmod,
achModName,
sizeof(achModName) / sizeof(WCHAR));
pszModName = achModName;
}
if (LR_flags & LR_CREATEDIBSECTION)
LR_flags = (LR_flags & ~LR_CREATEDIBSECTION) | LR_CREATEREALDIB;
/*
* Setup defaults.
*/
if ((hmod == hmodUser) && !IS_PTR(pszResName)) {
int imapMax;
LPMAPRES lpMapRes;
/*
* Map some old OEM IDs for people.
*/
if (type == RT_ICON) {
static MAPRES MapOemOic[] = {
{OCR_ICOCUR, OIC_WINLOGO, MR_FAILFOR40}
};
lpMapRes = MapOemOic;
imapMax = 1;
} else {
static MAPRES MapOemOcr[] = {
{OCR_ICON, OCR_ICON, MR_FAILFOR40},
{OCR_SIZE, OCR_SIZE, MR_FAILFOR40}
};
lpMapRes = MapOemOcr;
imapMax = 2;
}
while (--imapMax >= 0) {
if (lpMapRes->idDisp == PTR_TO_ID(pszResName)) {
if ((lpMapRes->bFlags & MR_FAILFOR40) &&
GETAPPVER() >= VER40) {
RIPMSG1(RIP_WARNING,
"LoadIcoCur: Old ID 0x%x not allowed for 4.0 apps",
PTR_TO_ID(pszResName));
return NULL;
}
pszResName = MAKEINTRESOURCE(lpMapRes->idUser);
break;
}
++lpMapRes;
}
}
/*
* Determine size of requested object.
*/
cxDesired = GetIcoCurWidth(cxDesired , (type == RT_ICON), LR_flags, 0);
cyDesired = GetIcoCurHeight(cyDesired, (type == RT_ICON), LR_flags, 0);
/*
* See if this is a cached icon/cursor, and grab it if we have one
* already.
*/
if (LR_flags & LR_SHARED) {
CURSORFIND cfSearch;
/*
* Note that win95 fails to load any USER resources unless
* LR_SHARED is specified - so we do too. Also, win95 will
* ignore your cx, cy and LR_flag parameters and just give
* you whats in the cache so we do too.
* A shame but thats life...
* Setup search criteria. Since this is a load, we will have
* no source-cursor to lookup. Find something respectable.
*/
cfSearch.hcur = (HCURSOR)NULL;
cfSearch.rt = PtrToUlong(type);
if (hmod == hmodUser) {
cfSearch.cx = 0;
cfSearch.cy = 0;
cfSearch.bpp = 0;
} else {
cfSearch.cx = cxDesired;
cfSearch.cy = cyDesired;
/*
* On NT we have a more strict cache-lookup. By passing in (zero), we
* will tell the cache-lookup to ignore the bpp. This fixes a problem
* in Crayola Art Studio where the coloring-book cursor was being created
* as an invisible cursor. This lookup is compatible with Win95.
*/
#if 0
cfSearch.bpp = GetIcoCurBpp(LR_flags);
#else
cfSearch.bpp = 0;
#endif
}
hico = FindExistingCursorIcon(pszModName, pszResName, &cfSearch);
if (hico != NULL)
goto IcoCurFound;
}
#ifdef LATER // SanfordS
/*
* We need to handle the case where a configurable icon has been
* loaded from some arbitrary module or file and someone now wants
* to load the same thing in a different size or color content.
* A cheezier alternative is to just call CopyImage on what we
* found.
*/
if (hmod == hmodUser) {
hico = FindExistingCursorIcon(NULL,
szUSER,
type,
pszResName,
0,
0,
0);
if (hico != NULL) {
/*
* Find out where the original came from and load it.
* This may require some redesign to remember the
* filename that LR_LOADFROMFILE images came from.
*/
_GetIconInfo(....);
return LoadIcoCur(....);
}
}
#endif
hico = (HICON)ObjectFromDIBResource(hmod,
pszResName,
type,
cxDesired,
cyDesired,
LR_flags);
IcoCurFound:
return hico;
}
/*
* ObjectFromDIBResource
*/
HANDLE ObjectFromDIBResource(
HINSTANCE hmod,
LPCWSTR lpName,
LPWSTR type,
DWORD cxDesired,
DWORD cyDesired,
UINT LR_flags)
{
HANDLE hObj = NULL;
if (LR_flags & LR_LOADFROMFILE) {
hObj = RtlLoadObjectFromDIBFile(lpName,
type,
cxDesired,
cyDesired,
LR_flags);
} else {
HANDLE hdib;
hdib = LoadDIB(hmod, lpName, type, cxDesired, cyDesired, LR_flags);
if (hdib != NULL) {
LPBITMAPINFOHEADER lpbih;
/*
* We cast the resource-bits to a BITMAPINFOHEADER. If the
* resource is a CURSOR type, then there are actually two
* WORDs preceeding the BITMAPINFOHDEADER indicating the
* hot-spot. Be careful in assuming you have a real
* dib in this case.
*/
if(lpbih = (LPBITMAPINFOHEADER)LOCKRESOURCE(hdib, hmod)) {
switch (PTR_TO_ID(type)) {
case PTR_TO_ID(RT_BITMAP):
/*
* Create a physical bitmap from the DIB.
*/
hObj = ConvertDIBBitmap(lpbih,
cxDesired,
cyDesired,
LR_flags,
NULL,
NULL);
break;
case PTR_TO_ID(RT_ICON):
case PTR_TO_ID(RT_CURSOR):
case PTR_TO_ID(RT_ANICURSOR):
case PTR_TO_ID(RT_ANIICON):
/*
* Animated icon\cursors resources use the RIFF format
*/
if (ISRIFFFORMAT(lpbih)) {
hObj = LoadCursorIconFromResource ((PBYTE)lpbih, lpName, cxDesired, cyDesired, LR_flags);
} else {
/*
* Create the object from the DIB.
*/
hObj = ConvertDIBIcon(lpbih,
hmod,
lpName,
(type == RT_ICON),
cxDesired,
cyDesired,
LR_flags);
}
break;
}
UNLOCKRESOURCE(hdib, hmod);
}
/*
* DO THIS TWICE! The resource compiler always makes icon images
* (RT_ICON) in a group icon discardable, whether the group dude
* is or not! So the first free won't really free the thing;
* it'll just set the ref count to 0 and let the discard logic
* go on its merry way.
* We take care of shared guys, so we don't need this dib no more.
* Don't need this DIB no more no more, no more no more no more
* don't need this DIB no more.
*/
SplFreeResource(hdib, hmod, LR_flags);
}
}
return hObj;
}
/*
* BitmapFromDIB
* Creates a bitmap-handle from a DIB-Spec. This function supports the
* LR_CREATEDIBSECTION flag, sets proper color depth, and stretches the
* DIBs as requested.
*/
HBITMAP BitmapFromDIB(
int cxNew,
int cyNew,
WORD bPlanesNew,
WORD bBitsPixelNew,
UINT LR_flags,
int cxOld,
int cyOld,
LPSTR lpBits,
LPBITMAPINFO lpbi,
HPALETTE hpal)
{
HBITMAP hbmpNew = NULL;
BOOL fStretch;
BOOL f1Bpp = FALSE;
RtlEnterCriticalSection(&gcsHdc);
if (cxNew == 0)
cxNew = cxOld;
if (cyNew == 0)
cyNew = cyOld;
fStretch = ((cxNew != cxOld) || (cyNew != cyOld));
/*
* If LR_flags indicate DIB-Section, then return that as the
* bitmap handle.
*/
if (LR_flags & (LR_CREATEDIBSECTION | LR_CREATEREALDIB)) {
int cxTemp;
int cyTemp;
BOOL fOldFormat;
LPVOID dwDummy;
DWORD dwTemp;
#define lpbch ((LPBITMAPCOREHEADER)lpbi)
fOldFormat = ((WORD)lpbi->bmiHeader.biSize == sizeof(BITMAPCOREHEADER));
if (fOldFormat) {
cxTemp = lpbch->bcWidth;
cyTemp = lpbch->bcHeight;
lpbch->bcWidth = (WORD)cxNew;
lpbch->bcHeight = (WORD)cyNew;
} else {
cxTemp = lpbi->bmiHeader.biWidth;
cyTemp = lpbi->bmiHeader.biHeight;
dwTemp = lpbi->bmiHeader.biCompression;
lpbi->bmiHeader.biWidth = cxNew;
lpbi->bmiHeader.biHeight = cyNew;
if (dwTemp != BI_BITFIELDS)
lpbi->bmiHeader.biCompression = BI_RGB;
}
if (LR_flags & LR_CREATEREALDIB) {
hbmpNew = CreateDIBitmap(ghdcBits2,
(LPBITMAPINFOHEADER)lpbi,
CBM_CREATEDIB,
NULL,
lpbi,
DIB_RGB_COLORS);
} else {
hbmpNew = CreateDIBSection(ghdcBits2,
lpbi,
DIB_RGB_COLORS,
&dwDummy,
0,
0);
}
if (fOldFormat) {
lpbch->bcWidth = (WORD)cxTemp;
lpbch->bcHeight = (WORD)cyTemp;
} else {
lpbi->bmiHeader.biWidth = cxTemp;
lpbi->bmiHeader.biHeight = cyTemp;
lpbi->bmiHeader.biCompression = dwTemp;
}
#undef lpbch
}
if (hbmpNew == NULL) {
hbmpNew = CreateScreenBitmap(cxNew,
cyNew,
bPlanesNew,
bBitsPixelNew,
NULL,
&f1Bpp);
}
if (hbmpNew) {
int nStretchMode;
DWORD rgbBk;
DWORD rgbText;
HBITMAP hbmpT;
BOOL fFail;
/*
* We need to select in appropriate bitmap immediately! That way,
* if we need to handle palette realization, the color matching
* will work properly.
*/
hbmpT = SelectBitmap(ghdcBits2, hbmpNew);
/*
* Setup for stretching
*/
if (fStretch) {
nStretchMode = SetBestStretchMode(ghdcBits2,
bPlanesNew,
bBitsPixelNew);
}
rgbBk = SetBkColor(ghdcBits2, RESCLR_WHITE);
rgbText = SetTextColor(ghdcBits2, RESCLR_BLACK);
/*
* Realize the palette.
*/
if (hpal) {
#if DBG
UserAssert(TEST_PUSIF(PUSIF_PALETTEDISPLAY));
#endif // DBG
hpal = SelectPalette(ghdcBits2, hpal, FALSE);
RealizePalette(ghdcBits2);
}
if (fStretch) {
fFail = SmartStretchDIBits(ghdcBits2,
0,
0,
cxNew,
cyNew,
0,
0,
cxOld,
cyOld,
lpBits,
lpbi,
DIB_RGB_COLORS,
SRCCOPY) <= 0;
} else {
fFail = SetDIBits(ghdcBits2,
hbmpNew,
0,
cyNew,
lpBits,
lpbi,
DIB_RGB_COLORS) <= 0;
}
/*
* Unrealize the palette
*/
if (hpal) {
SelectPalette(ghdcBits2, hpal, TRUE);
RealizePalette(ghdcBits2);
}
/*
* Cleanup after stretching
*/
SetTextColor(ghdcBits2, rgbText);
SetBkColor(ghdcBits2, rgbBk);
if (fStretch)
SetStretchBltMode(ghdcBits2, nStretchMode);
SelectBitmap(ghdcBits2, hbmpT);
/*
* If the SetDIBits() of StretchDIBits() failed, it is probably because
* GDI or the driver did not like the DIB format. This may happen if
* the file is truncated and we are using a memory mapped file to read
* the DIB in. In this case, an exception gets thrown in GDI, that it
* traps and will return failure from the GDI call.
*/
if (fFail) {
DeleteObject(hbmpNew);
hbmpNew = NULL;
}
}
/*
* If the bitmap was created as a 1bpp, we need to convert to a
* true mono-bitmap. GDI performs different color-matching depending
* upon this case.
*/
if (f1Bpp && hbmpNew)
hbmpNew = Convert1BppToMonoBitmap(ghdcBits2, hbmpNew);
RtlLeaveCriticalSection(&gcsHdc);
return hbmpNew;
}
/*
* HowManyColors
*/
DWORD HowManyColors(
IN UPBITMAPINFOHEADER upbih,
IN BOOL fOldFormat,
OUT OPTIONAL LPBYTE *ppColorTable)
{
#define upbch ((UPBITMAPCOREHEADER)upbih)
if (fOldFormat) {
if (ppColorTable != NULL) {
*ppColorTable = (LPBYTE)(upbch + 1);
}
if (upbch->bcBitCount <= 8)
return (1 << upbch->bcBitCount);
} else {
if (ppColorTable != NULL) {
*ppColorTable = (LPBYTE)(upbih + 1);
}
if (upbih->biClrUsed)
return (DWORD)upbih->biClrUsed;
else if (upbih->biBitCount <= 8)
return (1 << upbih->biBitCount);
else if ((upbih->biBitCount == 16) || (upbih->biBitCount == 32))
return 3;
}
return 0;
#undef upbch
}
/*
* ChangeDibColors
* Given a DIB, processes LR_MONOCHROME, LR_LOADTRANSPARENT and
* LR_LOADMAP3DCOLORS flags on the given header and colortable.
*/
VOID ChangeDibColors(
IN LPBITMAPINFOHEADER lpbih,
IN UINT LR_flags)
{
LPDWORD lpColorTable;
DWORD rgb;
UINT iColor;
UINT cColors;
cColors = HowManyColors(lpbih, FALSE, &(LPBYTE)lpColorTable);
/*
* NT Bug 366661: Don't check the color count here b/c we will do different
* things depending on what type of change we are performing. For example,
* when loading hi-color/true-color icons, we always need to do the
* monochrome conversion in order to properly get an icon-mask.
*/
/*
* LR_MONOCHROME is the only option that handles PM dibs.
*/
if (LR_flags & LR_MONOCHROME) {
/*
* LR_MONOCHROME is the only option that handles PM dibs.
* DO THIS NO MATTER WHETHER WE HAVE A COLOR TABLE! We need
* to do this for mono conversion and for > 8 BPP
* icons/cursors. In CopyDibHdr, we already made a copy of
* the header big enough to hold 2 colors even on 16 and 24
* BPP images.
*/
lpbih->biBitCount = lpbih->biPlanes = 1;
lpColorTable[0] = RESCLR_BLACK;
lpColorTable[1] = RESCLR_WHITE;
} else if (LR_flags & LR_LOADTRANSPARENT) {
LPBYTE pb;
/*
* No color table! Do nothing.
*/
if (cColors == 0) {
RIPMSG0(RIP_WARNING, "ChangeDibColors: DIB doesn't have a color table");
return;
}
pb = (LPBYTE)(lpColorTable + cColors);
/*
* Change the first pixel's color table entry to RGB_WINDOW
* Gosh, I love small-endian
*/
if (lpbih->biCompression == 0)
iColor = (UINT)pb[0];
else
/*
* RLE bitmap, will start with cnt,clr or 0,cnt,clr
*/
iColor = (UINT)(pb[0] == 0 ? pb[2] : pb[1]);
switch (cColors) {
case BPP01_MAXCOLORS:
iColor &= 0x01;
break;
case BPP04_MAXCOLORS:
iColor &= 0x0F;
break;
case BPP08_MAXCOLORS:
iColor &= 0xFF;
break;
}
rgb = (LR_flags & LR_LOADMAP3DCOLORS ? SYSRGB(3DFACE) : SYSRGB(WINDOW));
lpColorTable[iColor] = RGBX(rgb);
} else if (LR_flags & LR_LOADMAP3DCOLORS) {
/*
* Fix up the color table, mapping shades of grey to the current
* 3D colors.
*/
for (iColor = 0; iColor < cColors; iColor++) {
switch (*lpColorTable & 0x00FFFFFF) {
case RGBX(RGB(223, 223, 223)):
rgb = SYSRGB(3DLIGHT);
goto ChangeColor;
case RGBX(RGB(192, 192, 192)):
rgb = SYSRGB(3DFACE);
goto ChangeColor;
case RGBX(RGB(128, 128, 128)):
rgb = SYSRGB(3DSHADOW);
/*
* NOTE: byte-order is different in DIBs than in RGBs
*/
ChangeColor:
*lpColorTable = RGBX(rgb);
break;
}
lpColorTable++;
}
}
}
/*
* ConvertDIBIcon
* Called when a cursor/icon in DIB format is loaded. This converts the
* cursor/icon into the old format and returns the resource handle. IE,
* grabs the DIB bits and transforms them into physical bitmap bits.
* DIB Formats for icons/cursors 101
* Old Win 3.0 format icons/cursors start with an OLDICON/OLDCURSOR header
* followed by a double high monochrome DIB. The height refered to in the
* header is the icon/cursor height, not the DIB height which is twice as
* high. The XOR mask is in the first-half of the DIB bits.
* Old PM format icons/cursors start with a BITMAPCOREHEADER and
* are identical to the current win 3.1/NT format thereafter.
* Current NT/Chicago/Win 3.1 format icons/cursors start with
* a BITAMPINFOHEADER. The height of this header refers to the height
* of the first bitmap which may either be color or truely monochrome.
* If its color, it is followed by the monochrome AND mask bits imediately
* after the color bits. If it is truely monochrome, the AND and XOR
* masks are totally contained in the first DIB bits and no more bits
* follow.
* 5-Oct-1994 SanfordS Recreated
*/
HICON ConvertDIBIcon(
LPBITMAPINFOHEADER lpbih,
HINSTANCE hmod,
LPCWSTR lpName,
BOOL fIcon,
DWORD cxNew,
DWORD cyNew,
UINT LR_flags)
{
LPBITMAPINFOHEADER lpbihNew = NULL;
LPSTR lpBitsNextMask = NULL;
HICON hicoNew = NULL;
BOOL fOldFormat = FALSE;
CURSORDATA cur;
WCHAR achModName[MAX_PATH];
/*
* Because Icons/Cursors always get public bitmaps, we cannot use
* LR_CREATEDIBSECTION on them.
*/
if (LR_flags & LR_CREATEDIBSECTION)
LR_flags = (LR_flags & ~LR_CREATEDIBSECTION) | LR_CREATEREALDIB;
RtlZeroMemory(&cur, sizeof(cur));
if (!fIcon) {
/*
* Cursors have an extra two words preceeding the BITMAPINFOHEADER
* indicating the hot-spot. After doing the increments, the
* pointer should be at the dib-header.
*/
cur.xHotspot = (short)(int)*(((LPWORD)lpbih)++);
cur.yHotspot = (short)(int)*(((LPWORD)lpbih)++);
}
/*
* Get the XOR/Color mask.
* The XOR bits are first in the DIB because the header info
* pertains to them.
* The AND mask is always monochrome.
*/
lpBitsNextMask = NULL; // not passing lpBits in.
cur.hbmColor = ConvertDIBBitmap(lpbih,
cxNew,
cyNew,
LR_flags,
&lpbihNew,
&lpBitsNextMask);
if (cur.hbmColor == NULL)
return NULL;
if (hmod == NULL) {
cur.lpModName = NULL;
} else {
cur.CURSORF_flags = CURSORF_FROMRESOURCE;
if (hmod == hmodUser) {
cur.lpModName = szUSER32;
} else {
WowGetModuleFileName(hmod,
achModName,
sizeof(achModName) / sizeof(WCHAR));
cur.lpModName = achModName;
}
}
cur.rt = (fIcon ? PTR_TO_ID(RT_ICON) : PTR_TO_ID(RT_CURSOR));
cur.lpName = (LPWSTR)lpName;
cur.bpp = lpbihNew->biBitCount * lpbihNew->biPlanes;
if (cxNew == 0)
cxNew = lpbihNew->biWidth;
if (cyNew == 0)
cyNew = lpbihNew->biHeight / 2;
if (!fIcon) {
cur.xHotspot = MultDiv(cur.xHotspot,
cxNew,
lpbihNew->biWidth);
cur.yHotspot = MultDiv(cur.yHotspot,
cyNew,
lpbihNew->biHeight / 2);
} else {
/*
* For an icon the hot spot is the center of the icon
*/
cur.xHotspot = (INT)(cxNew) / 2;
cur.yHotspot = (INT)(cyNew) / 2;
}
/*
* Setup header for monochrome DIB. Note that we use the COPY.
*/
ChangeDibColors(lpbihNew, LR_MONOCHROME);
if (lpBitsNextMask != NULL) {
cur.hbmMask = BitmapFromDIB(cxNew,
cyNew * 2,
1,
1,
0,
lpbihNew->biWidth,
lpbihNew->biHeight,
lpBitsNextMask,
(LPBITMAPINFO)lpbihNew,
NULL);
if (cur.hbmMask == NULL) {
DeleteObject(cur.hbmColor);
UserLocalFree(lpbihNew);
return NULL;
}
} else {
cur.hbmMask = cur.hbmColor;
cur.hbmColor = NULL;
}
cur.cx = cxNew;
cur.cy = cyNew * 2;
/*
* Free our dib header copy allocated by ConvertDIBBitmap
*/
UserLocalFree(lpbihNew);
if (LR_flags & LR_SHARED)
cur.CURSORF_flags |= CURSORF_LRSHARED;
if (LR_flags & LR_GLOBAL)
cur.CURSORF_flags |= CURSORF_GLOBAL;
if (LR_flags & LR_ACONFRAME)
cur.CURSORF_flags |= CURSORF_ACONFRAME;
return CreateIcoCur(&cur);
}
/*
* TrulyMonochrome
* Checks to see if a DIB colro table is truly monochrome. ie: the color
* table has black & white entries only.
*/
BOOL TrulyMonochrome(
LPVOID lpColorTable,
BOOL fOldFormat)
{
#define lpRGB ((UNALIGNED LONG *)lpColorTable)
#define lpRGBw ((UNALIGNED WORD *)lpColorTable)
if (fOldFormat) {
/*
* Honey - its triplets.
*/
if (lpRGBw[0] == 0x0000)
return (lpRGBw[1] == 0xFF00) && (lpRGBw[2] == 0xFFFF);
else if (lpRGBw[0] == 0xFFFF)
return (lpRGBw[1] == 0x00FF) && (lpRGBw[2] == 0x0000);
} else {
/*
* Honey - its quadruplets!
*/
if (lpRGB[0] == RESCLR_BLACK)
return (lpRGB[1] == RESCLR_WHITE);
else if (lpRGB[0] == RESCLR_WHITE)
return (lpRGB[1] == RESCLR_BLACK);
}
#undef lpRGB
#undef lpRGBw
return FALSE;
}
/*
* CopyDibHdr
* Copies and converts a DIB resource header
* Handles conversion of OLDICON, OLDCURSOR and BITMAPCOREHEADER
* structures to BITMAPINFOHEADER headers.
* Note: fSingleHeightMasks is set for OLDICON and OLDCURSOR formats.
* This identifies that a monochrome AND/Color mask
* is NOT double height as it is in the newer formats.
* NOTE: On the off chance that LR_LOADTRANSPARENT is used, we want to
* copy a DWORD of the bits. Since DIB bits are DWORD aligned, we know
* at least a DWORD is there, even if the thing is a 1x1 mono bmp.
* The returned buffer is allocated in this function and needs to be
* freed by the caller.
* 22-Oct-1995 SanfordS Revised
*/
LPBITMAPINFOHEADER CopyDibHdr(
IN UPBITMAPINFOHEADER upbih,
OUT LPSTR *lplpBits,
OUT LPBOOL lpfMono)
{
#define upbch ((UPBITMAPCOREHEADER)upbih)
DWORD cColors;
DWORD i;
LPBITMAPINFOHEADER lpbihNew;
DWORD cbAlloc;
LPBYTE lpColorTable;
struct {
BITMAPINFOHEADER bih;
DWORD rgb[256];
DWORD dwBuffer;
} Fake;
switch (upbih->biSize) {
case sizeof(BITMAPINFOHEADER):
/*
* Cool. No conversion needed.
*/
cColors = HowManyColors(upbih, FALSE, &lpColorTable);
*lplpBits = (LPSTR)(((LPDWORD)lpColorTable) + cColors);
break;
case sizeof(BITMAPCOREHEADER):
/*
* Convert the BITMAPCOREHEADER to a BITMAPINFOHEADER
*/
Fake.bih.biSize = sizeof(BITMAPINFOHEADER);
Fake.bih.biWidth = upbch->bcWidth;
Fake.bih.biHeight = upbch->bcHeight;
Fake.bih.biPlanes = upbch->bcPlanes;
Fake.bih.biBitCount = upbch->bcBitCount;
Fake.bih.biCompression =
Fake.bih.biXPelsPerMeter =
Fake.bih.biYPelsPerMeter =
Fake.bih.biClrImportant = 0;
Fake.bih.biClrUsed = cColors =
HowManyColors(upbih, TRUE, &lpColorTable);
Fake.bih.biSizeImage =
BitmapWidth(Fake.bih.biWidth, Fake.bih.biBitCount) *
Fake.bih.biHeight;
/*
* Copy and convert tripplet color table to rgbQuad color table.
*/
for (i = 0; i < cColors; i++, lpColorTable += 3) {
Fake.rgb[i] = lpColorTable[0] +
(lpColorTable[1] << 8) +
(lpColorTable[2] << 16);
}
Fake.rgb[i] = *(DWORD UNALIGNED *)lpColorTable; // For LR_LOADTRANSPARENT
upbih = (UPBITMAPINFOHEADER)&Fake;
*lplpBits = lpColorTable;
break;
default:
#define upOldIcoCur ((UPOLDCURSOR)upbih)
if (upOldIcoCur->bType == BMR_ICON ||
upOldIcoCur->bType == BMR_CURSOR) {
/*
* Convert OLDICON/OLDCURSOR header to BITMAPINFHEADER
*/
RIPMSG0(RIP_WARNING, "USER32:Converting a OLD header. - email sanfords if you see this");
Fake.bih.biSize = sizeof(BITMAPINFOHEADER);
Fake.bih.biWidth = upOldIcoCur->cx;
Fake.bih.biHeight = upOldIcoCur->cy * 2;
Fake.bih.biPlanes =
Fake.bih.biBitCount = 1;
Fake.bih.biCompression =
Fake.bih.biXPelsPerMeter =
Fake.bih.biYPelsPerMeter =
Fake.bih.biClrImportant = 0;
Fake.bih.biClrUsed = cColors = BPP01_MAXCOLORS;
Fake.bih.biSizeImage =
BitmapWidth(upOldIcoCur->cx, 1) * upOldIcoCur->cy;
Fake.rgb[0] = RESCLR_BLACK;
Fake.rgb[1] = RESCLR_WHITE;
upbih = (LPBITMAPINFOHEADER)&Fake;
*lplpBits = upOldIcoCur->abBitmap;
Fake.rgb[2] = *((LPDWORD)*lplpBits); // For LR_LOADTRANSPARENT
} else {
RIPMSG0(RIP_WARNING, "ConvertDIBBitmap: not a valid format");
return NULL;
}
#undef pOldIcoCur
break;
}
*lpfMono = (cColors == BPP01_MAXCOLORS) &&
TrulyMonochrome((LPBYTE)upbih + sizeof(BITMAPINFOHEADER), FALSE);
cbAlloc = sizeof(BITMAPINFOHEADER) + (cColors * sizeof(RGBQUAD)) + 4;
if (lpbihNew = UserLocalAlloc(0, cbAlloc))
RtlCopyMemory(lpbihNew, upbih, cbAlloc);
return lpbihNew;
#undef upbch
}
/*
* ConvertDIBBitmap
* This takes a BITMAPCOREHEADER, OLDICON, OLDCURSOR or BITMAPINFOHEADER DIB
* specification and creates a physical object from it.
* Handles Color fixups, DIB sections, color depth, and stretching options.
* Passes back: (if lplpbih is not NULL)
* lplpbih = copy of given header converted to BITMAPINFOHEADER form.
* lplpBits = pointer to next mask bits, or NULL if no second mask.
* Caller must free lplpbih returned.
* If lplpBits is not NULL and points to a non-NULL value, it supplies
* the location of the DIB bits allowing the header to be from a different
* location.
* 04-Oct-1995 SanfordS Recreated.
*/
HBITMAP ConvertDIBBitmap(
IN UPBITMAPINFOHEADER upbih,
IN DWORD cxDesired,
IN DWORD cyDesired,
IN UINT LR_flags,
OUT OPTIONAL LPBITMAPINFOHEADER *lplpbih,
IN OUT OPTIONAL LPSTR *lplpBits)
{
LPBITMAPINFOHEADER lpbihNew;
BOOL fMono, fMonoGiven;
BYTE bPlanesDesired;
BYTE bppDesired;
LPSTR lpBits;
HBITMAP hBmpRet;
/*
* Make a copy of the DIB-Header. This returns a pointer
* which was allocated, so it must be freed later.
* The also converts the header to BITMAPINFOHEADER format.
*/
if ((lpbihNew = CopyDibHdr(upbih, &lpBits, &fMono)) == NULL)
return NULL;
/*
* When loading a DIB file, we may need to use a different
* bits pointer. See RtlRes.c/RtlLoadObjectFromDIBFile.
*/
if (lplpBits && *lplpBits)
lpBits = *lplpBits;
fMonoGiven = fMono;
if (!fMono) {
if (LR_flags & (LR_LOADTRANSPARENT | LR_LOADMAP3DCOLORS))
ChangeDibColors(lpbihNew, LR_flags & ~LR_MONOCHROME);
bPlanesDesired = gpsi->Planes;
bppDesired = gpsi->BitsPixel;
fMono = LR_flags & LR_MONOCHROME;
}
if (fMono) {
bPlanesDesired =
bppDesired = 1;
}
/*
* HACK area
*/
if (lplpbih != NULL) {
/*
* pass back the translated/copied header
*/
*lplpbih = lpbihNew;
/*
* When loading icon/cursors on a system with multiple monitors
* with different color depths, always convert to VGA color.
*/
if (!fMono && !SYSMET(SAMEDISPLAYFORMAT)) {
bPlanesDesired = 1;
bppDesired = 4;
}
/*
* Return a ponter to the bits following this set of bits
* if there are any there.
* Note that the header given with an ICON DIB always reflects
* twice the height of the icon desired but the COLOR bitmap
* (if there is one) will only be half that high. We need to
* fixup cyDesired for monochrome icons so that the mask isnt
* stretched to half the height its supposed to be. Color
* bitmaps, however, must have the header corrected to reflect
* the bits actual height which is half what the header said.
* The correction must later be backed out so that the returned
* header reflects the dimensions of the XOR mask that immediately
* follows the color mask.
*/
if (fMonoGiven) {
*lplpBits = NULL;
if (cyDesired)
cyDesired <<= 1; // mono icon bitmaps are double high.
} else {
UserAssert(!(lpbihNew->biHeight & 1));
lpbihNew->biHeight >>= 1; // color icon headers are off by 2
/*
* Gross calculation! We subtract the XOR part of the mask
* for this calculation so that we submit a double-high mask.
* The first half of this is garbage, but for icons its not
* used. This may be a bug for cursor use of icons.
*/
*lplpBits = lpBits +
(BitmapWidth(lpbihNew->biWidth, lpbihNew->biBitCount) -
BitmapWidth(lpbihNew->biWidth, 1)) *
lpbihNew->biHeight;
}
}
if (cxDesired == 0)
cxDesired = lpbihNew->biWidth;
if (cyDesired == 0)
cyDesired = lpbihNew->biHeight;
hBmpRet = BitmapFromDIB(cxDesired,
cyDesired,
bPlanesDesired,
bppDesired,
LR_flags,
lpbihNew->biWidth,
lpbihNew->biHeight,
lpBits,
(LPBITMAPINFO)lpbihNew,
NULL);
if (lplpbih == NULL || hBmpRet == NULL) {
UserLocalFree(lpbihNew);
} else if (!fMonoGiven) {
lpbihNew->biHeight <<= 1; // restore header for next mask
}
return hBmpRet;
}
/*
* MyAbs
* Calcules my weighted absolute value of the difference between 2 nums.
* This of course normalizes values to >= zero. But it also doubles them
* if valueHave < valueWant. This is because you get worse results trying
* to extrapolate from less info up then interpolating from more info down.
* I paid $150 to take the SAT. I'm damned well going to get my vocab's
* money worth.
*/
UINT MyAbs(
int valueHave,
int valueWant)
{
int diff = (valueHave - valueWant);
if (diff < 0)
diff = 2 * (-diff);
return (UINT)diff;
}
/*
* Magnitude
* Used by the color-delta calculations. The reason is that num colors is
* always a power of 2. So we use the log 2 of the want vs. have values
* to avoid having weirdly huge sets.
*/
UINT Magnitude(
int nValue)
{
if (nValue < 4)
return 1;
else if (nValue < 8)
return 2;
else if (nValue < 16)
return 3;
else if (nValue < 256)
return 4;
else
return 8;
}
/*
* MatchImage
* This function takes LPINTs for width & height in case of "real size".
* For this option, we use dimensions of 1st icon in resdir as size to
* load, instead of system metrics.
* Returns a number that measures how "far away" the given image is
* from a desired one. The value is 0 for an exact match. Note that our
* formula has the following properties:
* (1) Differences in width/height count much more than differences in
* color format.
* (2) Fewer colors give a smaller difference than more
* (3) Bigger images are better than smaller, since shrinking produces
* better results than stretching.
* The formula is the sum of the following terms:
* Log2(colors wanted) - Log2(colors really), times -2 if the image
* has more colors than we'd like. This is because we will lose
* information when converting to fewer colors, like 16 color to
* monochrome.
* Log2(width really) - Log2(width wanted), times -2 if the image is
* narrower than what we'd like. This is because we will get a
* better result when consolidating more information into a smaller
* space, than when extrapolating from less information to more.
* Log2(height really) - Log2(height wanted), times -2 if the image is
* shorter than what we'd like. This is for the same reason as
* the width.
* Let's step through an example. Suppose we want a 16 color, 32x32 image,
* and are choosing from the following list:
* 16 color, 64x64 image
* 16 color, 16x16 image
* 8 color, 32x32 image
* 2 color, 32x32 image
* We'd prefer the images in the following order:
* 8 color, 32x32 : Match value is 0 + 0 + 1 == 1
* 16 color, 64x64 : Match value is 1 + 1 + 0 == 2
* 2 color, 32x32 : Match value is 0 + 0 + 3 == 3
* 16 color, 16x16 : Match value is 2*1 + 2*1 + 0 == 4
*/
UINT MatchImage(
LPRESDIR lprd,
LPINT lpcxWant,
LPINT lpcyWant,
UINT uColorsWant,
BOOL fIcon)
{
UINT uColorsNew;
int cxNew;
int cyNew;
cxNew = lprd->Icon.Width;
cyNew = lprd->Icon.Height;
if (fIcon) {
uColorsNew = lprd->Icon.ColorCount;
} else {
cyNew >>= 1;
uColorsNew = BPP01_MAXCOLORS;
}
/*
* 0 really means maximum size (256) or colors (256).
*/
if (!cxNew)
cxNew = BPP08_MAXCOLORS;
if (!*lpcxWant)
*lpcxWant = cxNew;
if (!cyNew)
cyNew = BPP08_MAXCOLORS;
if (!*lpcyWant)
*lpcyWant = cyNew;
if (!uColorsNew)
uColorsNew = BPP08_MAXCOLORS;
/*
* Here are the rules for our "match" formula:
* (1) A close size match is much preferable to a color match
* (2) Fewer colors are better than more
* (3) Bigger icons are better than smaller
* The color count, width, and height are powers of 2. So we use Magnitude()
* which calculates the order of magnitude in base 2.
*/
#if 0 //CHRISWIL: Not in Win95
return (MagnitudeDiff(uColorsWant, uColorsNew) +
MagnitudeDiff(cxNew, *lpcxWant) +
MagnitudeDiff(cyNew, *lpcyWant));
#else
return( 2*MyAbs(Magnitude(uColorsWant), Magnitude(uColorsNew)) +
MyAbs(cxNew, *lpcxWant) +
MyAbs(cyNew, *lpcyWant));
#endif
}
/*
* GetBestImage
* Among the different forms of images, choose the one that best matches the
* color format & dimensions of the request. We try to match the size, then
* the color info. So we find the item that
* (1) Has closest dimensions (smaller or bigger equally good) to minimize
* the width, height difference
* (2) Has best colors. We favor less over more colors.
* If we find an identical match, we return immediately.
*/
UINT GetBestImage(
LPRESDIR lprd,
UINT uCount,
int cxDesired,
int cyDesired,
UINT bpp,
BOOL fIcon)
{
UINT uIndex;
UINT uT;
UINT uIndexBest = 0;
UINT uBest = (UINT)-1;
/*
* Get desired number of colors in # value, not bits value. Note that
* we do NOT allow you to have 16- or 32- or 24- bit color icons.
* the icon resources can be 16, 24, 32 bpp, but the restable only has
* a color count, so a HiColor icon would have a max value in the
* restable. we treat a 0 in the color count as "max colors"
*/
if (bpp == 0)
bpp = (UINT)gpsi->BitCount;
if (bpp > 8)
bpp = 8;
bpp = 1 << bpp;
/*
* Loop through resource entries, saving the "closest" item so far. Most
* of the real work is in MatchImage(), which uses a fabricated formula
* to give us the results that we desire. Namely, an image as close in
* size to what we want preferring bigger over smaller, then an image
* with the right color format
*/
for (uIndex = 0; uIndex < uCount; uIndex++, lprd++) {
/*
* Get "matching" value. How close are we to what we want?
*/
uT = MatchImage(lprd, &cxDesired, &cyDesired, bpp, fIcon);
if (!uT) {
/*
* We've found an exact match!
*/
return uIndex;
} else if (uT < uBest) {
/*
* We've found a better match than the current alternative.
*/
uBest = uT;
uIndexBest = uIndex;
}
}
return uIndexBest;
}
/*
* GetIcoCurWidth
* When zero is passed in for a dimension, calculates what size we should
* really used. Done in a couple o' places, so made it a FN().
*/
_inline DWORD GetIcoCurWidth(
DWORD cxOrg,
BOOL fIcon,
UINT lrFlags,
DWORD cxDes)
{
if (cxOrg) {
return cxOrg;
} else if (lrFlags & LR_DEFAULTSIZE) {
return (fIcon ? SYSMET(CXICON) : SYSMET(CXCURSOR));
} else {
return cxDes;
}
}
/*
* GetIcoCurHeight
* Vertical counterpart to GetWidth().
*/
_inline DWORD GetIcoCurHeight(
DWORD cyOrg,
BOOL fIcon,
UINT lrFlags,
DWORD cyDes)
{
if (cyOrg) {
return cyOrg;
} else if (lrFlags & LR_DEFAULTSIZE) {
return (fIcon ? SYSMET(CYICON) : SYSMET(CYCURSOR));
} else {
return cyDes;
}
}
/*
* GetIcoCurBpp
* Returns best match Bpp based on lr-flags.
*/
_inline DWORD GetIcoCurBpp(
UINT lrFlags)
{
if (lrFlags & LR_MONOCHROME) {
#if DBG
if (lrFlags & LR_VGACOLOR) {
RIPMSG0(RIP_WARNING, "lrFlags has both MONOCHROME and VGACOLOR; assuming MONOCHROME");
}
#endif
return 1;
} else if (
TEST_PUSIF(PUSIF_PALETTEDISPLAY) ||
(lrFlags & LR_VGACOLOR) ||
!SYSMET(SAMEDISPLAYFORMAT)) {
return 4;
} else {
return 0;
}
}
/*
* WOWFindResourceExWCover
* The WOW FindResource routines expect an ansi string so we have to
* convert the calling string IFF it is not an ID
*/
HANDLE WOWFindResourceExWCover(
HANDLE hmod,
LPCWSTR rt,
LPCWSTR lpUniName,
WORD LangId)
{
LPSTR lpAnsiName;
HANDLE hRes;
if (ID(lpUniName))
return FINDRESOURCEEXA(hmod, (LPSTR)lpUniName, (LPSTR)rt, LangId);
/*
* Otherwise convert the name of the menu then call LoadMenu
*/
if (!WCSToMB(lpUniName, -1, &lpAnsiName, -1, TRUE))
return NULL;
hRes = FINDRESOURCEEXA(hmod, lpAnsiName, (LPSTR)rt, LangId);
UserLocalFree(lpAnsiName);
return hRes;
}
/*
* WOWLoadBitmapA
*/
HBITMAP WOWLoadBitmapA(
HINSTANCE hmod,
LPCSTR lpName,
LPBYTE pResData,
DWORD cbResData)
{
LPWSTR lpUniName;
HBITMAP hRet;
UNREFERENCED_PARAMETER(cbResData);
if (pResData == NULL) {
if (ID(lpName))
return LoadBmp(hmod, (LPCWSTR)lpName, 0, 0, 0);
if (!MBToWCS(lpName, -1, &lpUniName, -1, TRUE))
return NULL;
hRet = LoadBmp(hmod, lpUniName, 0, 0, 0);
UserLocalFree(lpUniName);
} else {
hRet = ConvertDIBBitmap((LPBITMAPINFOHEADER)pResData,
0,
0,
LR_DEFAULTSIZE,
NULL,
NULL);
}
return hRet;
}
/*
* WOWServerLoadCreateCursorIcon
*/
HICON WowServerLoadCreateCursorIcon(
HANDLE hmod,
LPWSTR pszModName,
DWORD dwExpWinVer,
LPCWSTR lpName,
DWORD cb,
PVOID pResData,
LPWSTR type,
BOOL fClient)
{
HICON hRet;
BOOL fIcon = (type == RT_ICON);
UINT LR_Flags = LR_SHARED;
UNREFERENCED_PARAMETER(pszModName);
UNREFERENCED_PARAMETER(dwExpWinVer);
UNREFERENCED_PARAMETER(cb);
UNREFERENCED_PARAMETER(fClient);
if (!fIcon)
LR_Flags |= LR_MONOCHROME;
if (pResData == NULL) {
hRet = LoadIcoCur(hmod,
lpName,
type,
0,
0,
LR_Flags | LR_DEFAULTSIZE);
} else {
hRet = ConvertDIBIcon((LPBITMAPINFOHEADER)pResData,
hmod,
lpName,
fIcon,
GetIcoCurWidth(0 , fIcon, LR_DEFAULTSIZE, 0),
GetIcoCurHeight(0, fIcon, LR_DEFAULTSIZE, 0),
LR_Flags);
}
return hRet;
}
/*
* WOWServerLoadCreateMenu
*/
HMENU WowServerLoadCreateMenu(
HANDLE hMod,
LPCSTR lpName,
CONST LPMENUTEMPLATE pmt,
DWORD cb,
BOOL fCallClient)
{
UNREFERENCED_PARAMETER(cb);
UNREFERENCED_PARAMETER(fCallClient);
if (pmt == NULL) {
return LoadMenuA(hMod, lpName);
} else
return CreateMenuFromResource(pmt);
}
/*
* DIBFromBitmap()
* Creates a memory block with DIB information from a physical bitmap tagged
* to a specific DC.
* A DIB block consists of a BITMAPINFOHEADER + RGB colors + DIB bits.
* Returns: UserLocalAlloc pointer to DIB info.
* 03-Nov-1995 SanfordS Created.
*/
PVOID DIBFromBitmap(
HBITMAP hbmp,
HDC hdc)
{
BITMAP bmp;
LPBITMAPINFOHEADER lpbi;
DWORD cbBits;
DWORD cbPalette;
DWORD cbTotal;
WORD cBits;
UserAssert(hbmp);
UserAssert(hdc);
if (GetObject(hbmp, sizeof(BITMAP), &bmp) == 0)
return NULL;
cBits = ((WORD)bmp.bmPlanes * (WORD)bmp.bmBitsPixel);
TrySmallerDIB:
cbBits = (DWORD)WIDTHBYTES((WORD)bmp.bmWidth * cBits) * (DWORD)bmp.bmHeight;
cbPalette = 0;
if (cBits <= 8)
cbPalette = (1 << cBits) * sizeof(RGBQUAD);
else
cbPalette = 3 * sizeof(RGBQUAD);
cbTotal = sizeof(BITMAPINFOHEADER) + cbPalette + cbBits;
lpbi = (LPBITMAPINFOHEADER)UserLocalAlloc(HEAP_ZERO_MEMORY, cbTotal);
if (lpbi == NULL) {
/*
* Try a smaller DIB, if we can. We can't if the DIB is mono.
*/
switch (cBits) {
case 4:
cBits = 1;
break;
case 8:
cBits = 4;
break;
case 16:
cBits = 8;
break;
case 24:
cBits = 16;
break;
case 32:
cBits = 24;
break;
default:
return NULL; // 1 or wierd.
}
RIPMSG1(RIP_WARNING, "Not enough memory to create large color DIB, trying %d bpp.", cBits);
goto TrySmallerDIB;
}
RtlZeroMemory(lpbi, sizeof(BITMAPINFOHEADER));
lpbi->biSize = sizeof(BITMAPINFOHEADER);
lpbi->biWidth = bmp.bmWidth;
lpbi->biHeight = bmp.bmHeight;
lpbi->biPlanes = 1;
lpbi->biBitCount = cBits;
/*
* Get old bitmap's DIB bits, using the current DC.
*/
GetDIBits(hdc,
hbmp,
0,
lpbi->biHeight,
((LPSTR)lpbi) + lpbi->biSize + cbPalette,
(LPBITMAPINFO)lpbi,
DIB_RGB_COLORS);
lpbi->biClrUsed = cbPalette / sizeof(RGBQUAD);
lpbi->biSizeImage = cbBits;
return lpbi;
}
/*
* CopyBmp
* Creates a new bitmap and copies the given bitmap to the new one,
* stretching and color-converting the bits if desired.
* 03-Nov-1995 SanfordS Created.
*/
HBITMAP CopyBmp(
HBITMAP hbmpOrg,
int cxNew,
int cyNew,
UINT LR_flags)
{
HBITMAP hbmNew = NULL;
LPBITMAPINFOHEADER pdib;
RtlEnterCriticalSection(&gcsHdc);
if (pdib = DIBFromBitmap(hbmpOrg, ghdcBits2)) {
#if 0 // Win-9x comments this code out
if (LR_flags & LR_COPYRETURNORG) {
DWORD bpp = GetIcoCurBpp(LR_flags);
if ((cxNew == 0 || cxNew == pdib->biWidth) &&
(cyNew == 0 || cyNew == pdib->biHeight) &&
(bpp == 0 || bpp == pdib->biBitCount)) {
hbmNew = hbmpOrg;
}
}
if (hbmNew == NULL)
hbmNew = ConvertDIBBitmap(pdib, cxNew, cyNew, LR_flags, NULL, NULL);
#endif
hbmNew = ConvertDIBBitmap(pdib, cxNew, cyNew, LR_flags, NULL, NULL);
UserLocalFree(pdib);
}
RtlLeaveCriticalSection(&gcsHdc);
if ((LR_flags & LR_COPYDELETEORG) && hbmNew && (hbmNew != hbmpOrg))
DeleteObject(hbmpOrg);
return hbmNew;
}
/*
* CopyImageFromRes
* This is used by the LR_COPYFROMRESOURCE option. We assume that the
* icon/cursor passed in is among the process list of loaded shared
* icons. If we find it there, we can attempt to load the icon from
* the resource to get an image that looks better than a stretched or
* compressed one.
* That way we will not stretch a 32x32 icon to 16x16 if someone added
* a 16x16 image to their class icon--a simple way for apps to jazz up
* their appearance.
* 12-Mar-1996 ChrisWil Created.
*/
HICON CopyImageFromRes(
LPWSTR pszModName,
LPWSTR pszResName,
PCURSORFIND pcfSearch,
UINT LR_flags)
{
HINSTANCE hmod;
HICON hicoDst = NULL;
/*
* Override the search-criteria if this is the user-module. By
* setting these to zero, we are basically saying "don't care" for
* these attributes.
*/
hmod = (pszModName ? WowGetModuleHandle(pszModName) : hmodUser);
if (hmod == hmodUser) {
pcfSearch->cx = 0;
pcfSearch->cy = 0;
pcfSearch->bpp = 0;
pszModName = szUSER32;
}
/*
* If a resource has been found with this name/bpp, then attempt
* to load the resource with the desired dimensions.
*/
if (FindExistingCursorIcon(pszModName, pszResName, pcfSearch)) {
hicoDst = LoadIcoCur(hmod,
pszResName,
(LPWSTR)ULongToPtr( pcfSearch->rt ),
pcfSearch->cx,
pcfSearch->cy,
LR_flags);
}
return hicoDst;
}
/*
* CopyIcoCur()
* Allocates a new icon resource and transmogrifies the old icon into the
* newly desired format.
* Note that if we have to stretch the icon, the hotspot area changes. For
* icons, the hotspot is set to be the middle of the icon.
* Returns:
* 01-Nov-1995 SanfordS Created.
* 12-Mar-1996 ChrisWil Added lookup for existing icon/cursor.
*/
HICON CopyIcoCur(
HICON hicoSrc,
BOOL fIcon,
int cxNew,
int cyNew,
UINT LR_flags)
{
HBITMAP hbmMaskNew;
HBITMAP hbmColorNew;
int cx;
int cy;
DWORD bpp;
DWORD bppDesired;
HICON hicoDst = NULL;
ICONINFO ii;
CURSORDATA cur;
UNICODE_STRING strModName;
UNICODE_STRING strResName;
WCHAR awszModName[MAX_PATH];
WCHAR awszResName[MAX_PATH];
/*
* Extract needed info from existing icon/cursor from the kernel
*/
if (!NtUserGetIconSize(hicoSrc, 0, &cx, &cy))
return NULL;
cy >>= 1;
if (LR_flags & LR_CREATEDIBSECTION)
LR_flags = (LR_flags & ~LR_CREATEDIBSECTION) | LR_CREATEREALDIB;
/*
* Setup unicode-strings for calls to kernel-side.
*/
strModName.Length = 0;
strModName.MaximumLength = MAX_PATH;
strModName.Buffer = awszModName;
strResName.Length = 0;
strResName.MaximumLength = MAX_PATH;
strResName.Buffer = awszResName;
/*
* Note: this creates copies of hbmMask and hbmColor that need to be
* freed before we leave.
*/
if (!NtUserGetIconInfo(hicoSrc,
&ii,
&strModName,
&strResName,
&bpp,
TRUE)) {
return NULL;
}
cxNew = GetIcoCurWidth(cxNew, fIcon, LR_flags, cx);
cyNew = GetIcoCurHeight(cyNew, fIcon, LR_flags, cy);
if (LR_flags & LR_COPYFROMRESOURCE) {
CURSORFIND cfSearch;
LPWSTR pszModName;
/*
* Setup the search criteria.
*/
cfSearch.hcur = hicoSrc;
cfSearch.rt = PtrToUlong((fIcon ? RT_ICON : RT_CURSOR));
cfSearch.cx = cxNew;
cfSearch.cy = cyNew;
cfSearch.bpp = bpp;
/*
* Copy the image. This performs a lookup for the hicoSrc. If
* it is not found in the process and shared caches, then we
* will proceed with copying the hicoSrc. If an icon is found
* in the cache, then we will attempt to reload the image for
* the best resolution possible.
*/
pszModName = (strModName.Length ? strModName.Buffer : NULL);
hicoDst = CopyImageFromRes(pszModName,
strResName.Buffer,
&cfSearch,
LR_flags);
if (hicoDst)
goto CleanupExit;
}
bppDesired = GetIcoCurBpp(LR_flags);
if ((cxNew != cx) ||
(cyNew != cy) ||
((bpp != 1) && (bppDesired != 0) && (bppDesired != bpp))) {
/*
* Since we have to stretch or maybe fixup the colors just get
* the DIB bits and let ConverDIBBitmap do all the magic.
*/
hbmMaskNew = CopyBmp(ii.hbmMask, cxNew, cyNew * 2, LR_MONOCHROME);
if (hbmMaskNew == NULL)
goto CleanupExit;
hbmColorNew = NULL;
if (ii.hbmColor) {
hbmColorNew = CopyBmp(ii.hbmColor, cxNew, cyNew, LR_flags);
if (hbmColorNew == NULL) {
DeleteObject(hbmMaskNew);
goto CleanupExit;
}
}
/*
* Replace ii.hbmxxx guys with our fixed up copies and delete the old.
*/
DeleteObject(ii.hbmMask);
ii.hbmMask = hbmMaskNew;
if (ii.hbmColor && (ii.hbmColor != hbmColorNew)) {
DeleteObject(ii.hbmColor);
ii.hbmColor = hbmColorNew;
}
/*
* tweak the hotspots for changes in size.
*/
if (cxNew != cx)
ii.xHotspot = MultDiv(ii.xHotspot, cxNew, cx);
if (cyNew != cy)
ii.yHotspot = MultDiv(ii.yHotspot, cyNew, cy);
} else if (LR_flags & LR_COPYRETURNORG) {
hicoDst = hicoSrc;
CleanupExit:
/*
* Free up the bitmaps which were created by GetIconInfo().
*/
DeleteObject(ii.hbmMask);
if (ii.hbmColor)
DeleteObject(ii.hbmColor);
goto Exit;
}
/*
* Build the icon/cursor object from the info. The bitmaps
* are not freed in this case.
*/
hicoDst = (HICON)NtUserCallOneParam(0, SFI__CREATEEMPTYCURSOROBJECT);
if (hicoDst == NULL)
goto CleanupExit;
RtlZeroMemory(&cur, sizeof(cur));
cur.lpName = strResName.Length ? strResName.Buffer : NULL;
cur.lpModName = strModName.Length ? strModName.Buffer : NULL;
cur.rt = ii.fIcon ? PTR_TO_ID(RT_ICON) : PTR_TO_ID(RT_CURSOR);
cur.bpp = bpp;
cur.cx = cxNew;
cur.cy = cyNew * 2;
cur.xHotspot = (short)ii.xHotspot;
cur.yHotspot = (short)ii.yHotspot;
cur.hbmMask = ii.hbmMask;
cur.hbmColor = ii.hbmColor;
if (!_SetCursorIconData(hicoDst, &cur)) {
NtUserDestroyCursor(hicoDst, CURSOR_ALWAYSDESTROY);
return NULL;
}
Exit:
/*
* destroy the original if asked to.
*/
if (hicoDst != hicoSrc && (LR_flags & LR_COPYDELETEORG))
DestroyCursor(hicoSrc);
return hicoDst;
}
/*
* CopyImage
* Allocates a new icon resource and copies the attributes of the old icon
* to the new icon.
* Returns: hIconNew
* 01-Nov-1995 SanfordS Created.
*/
HANDLE WINAPI CopyImage(
HANDLE hImage,
UINT IMAGE_flag,
int cxNew,
int cyNew,
UINT LR_flags)
{
if (LR_flags & ~LR_VALID) {
RIPERR0(ERROR_INVALID_PARAMETER, RIP_WARNING, "CopyImage: bad LR_flags.");
return NULL;
}
return InternalCopyImage(hImage, IMAGE_flag, cxNew, cyNew, LR_flags);
}
/*
* InternalCopyImage
* Performs the copyimage work. This is called from the callback-thunk.
*/
HANDLE InternalCopyImage(
HANDLE hImage,
UINT IMAGE_flag,
int cxNew,
int cyNew,
UINT LR_flags)
{
switch (IMAGE_flag) {
case IMAGE_BITMAP:
if (GetObjectType(hImage) != OBJ_BITMAP) {
RIPMSG0(RIP_ERROR, "CopyImage: invalid bitmap");
return NULL;
}
return (HICON)CopyBmp(hImage, cxNew, cyNew, LR_flags);
case IMAGE_CURSOR:
case IMAGE_ICON:
return CopyIcoCur(hImage,
(IMAGE_flag == IMAGE_ICON),
cxNew,
cyNew,
LR_flags);
}
RIPERR0(ERROR_INVALID_PARAMETER, RIP_WARNING, "CopyImage: bad IMAGE_flag.");
return NULL;
}
/*
* RtlGetIdFromDirectory
* History:
* 06-Apr-1991 ScottLu Cleaned up, make work with client/server.
* 16-Nov-1995 SanfordS Now uses LookupIconIdFromDirectoryEx
*/
int RtlGetIdFromDirectory(
PBYTE presbits,
BOOL fIcon,
int cxDesired,
int cyDesired,
DWORD LR_flags,
PDWORD pdwResSize)
{
LPNEWHEADER lpnh;
LPRESDIR lprsd;
UINT iImage;
UINT cImage;
UINT bpp;
/*
* Make sure this is pointing to valid resource bits.
*/
if (presbits == NULL)
return 0;
lpnh = (LPNEWHEADER)presbits;
/*
* Fill in defaults.
*/
cxDesired = GetIcoCurWidth(cxDesired, fIcon, LR_flags, 0);
cyDesired = GetIcoCurHeight(cyDesired, fIcon, LR_flags, 0);
bpp = GetIcoCurBpp(LR_flags);
/*
* We'll use the first image in the directory if we can't find one
* that's appropriate.
*/
cImage = lpnh->ResCount;
lprsd = (LPRESDIR)(lpnh + 1);
iImage = GetBestImage(lprsd, cImage, cxDesired, cyDesired, bpp, fIcon);
if (iImage == cImage)
iImage = 0;
if (pdwResSize != NULL)
*pdwResSize = (lprsd + iImage)->BytesInRes;
return ((LPRESDIR)(lprsd + iImage))->idIcon;
}
Reference in New Issue View Git Blame Copy Permalink