clres.c

Go to the documentation of this file.

/****************************** 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;
}

---