int DlgDirListComboBoxA(
HWND hwndDlg,
LPSTR lpszPathSpecClient,
int idComboBox,
int idStaticPath,
UINT attrib)
{
LPWSTR lpszPathSpec;
TL tlpwndDlg;
PWND pwndDlg;
BOOL fRet;
pwndDlg = ValidateHwnd(hwndDlg);
if (pwndDlg == NULL)
return FALSE;
lpszPathSpec = NULL;
if (lpszPathSpecClient) {
if (!MBToWCS(lpszPathSpecClient, -1, &lpszPathSpec, -1, TRUE))
return FALSE;
}
ThreadLock(pwndDlg, &tlpwndDlg);
fRet = xxxDlgDirListHelper(pwndDlg, lpszPathSpec, lpszPathSpecClient,
idComboBox, idStaticPath, attrib, FALSE);
ThreadUnlock(&tlpwndDlg);
if (lpszPathSpec) {
if (fRet) {
/*
* Non-zero retval means some text to copy out. Copy out up to
* the nul terminator (buffer will be big enough).
*/
WCSToMB(lpszPathSpec, -1, &lpszPathSpecClient, MAXLONG, FALSE);
}
UserLocalFree(lpszPathSpec);
}
return fRet;
}
int DlgDirSelectComboBoxExA(
HWND hwndDlg,
LPSTR pszOut,
int cchOut,
int idComboBox)
{
LPWSTR lpwsz;
BOOL fRet;
lpwsz = (LPWSTR)UserLocalAlloc(HEAP_ZERO_MEMORY, cchOut * sizeof(WCHAR));
if (!lpwsz) {
return FALSE;
}
fRet = DlgDirSelectComboBoxExW(hwndDlg, lpwsz, cchOut, idComboBox);
WCSToMB(lpwsz, -1, &pszOut, cchOut, FALSE);
UserLocalFree(lpwsz);
return fRet;
}
int SmartStretchDIBits(
HDC hdc,
int xD,
int yD,
int dxD,
int dyD,
int xS,
int yS,
int dxS,
int dyS,
LPVOID lpBits,
LPBITMAPINFO lpbi,
UINT wUsage,
DWORD rop)
{
LPBYTE lpBitsNew;
UINT bpp;
RGBQUAD rgb;
LPBITMAPINFOHEADER lpbiNew = NULL;
int i;
/*
* thunk to USER32
*/
UserAssert(rop == SRCCOPY);
UserAssert(wUsage == DIB_RGB_COLORS);
UserAssert(xS == 0 && yS == 0);
if ((GetDIBColorTable(hdc, 0, 1, &rgb) != 1) &&
(dxD != dxS || dyD != dyS) && // 1:1 stretch just call GDI
(dxD >= dxS/2) && (dyD >= dyS/2) && // less than 1:2 shrink call GDI
(lpbi->bmiHeader.biCompression == 0) && // must be un-compressed
(lpbi->bmiHeader.biBitCount == 4 || // input must be 4,8,24
lpbi->bmiHeader.biBitCount == 8 ||
lpbi->bmiHeader.biBitCount == 24)) {
bpp = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
bpp = (bpp > 8 ? 24 : 8);
lpbiNew = (LPBITMAPINFOHEADER)UserLocalAlloc(0,
sizeof(BITMAPINFOHEADER) + (256 * sizeof(RGBQUAD)) +
(UINT)((((dxD * bpp) / 8) + 3) & ~3) * (UINT)dyD);
if (lpbiNew) {
*lpbiNew = lpbi->bmiHeader;
lpbiNew->biWidth = dxD;
lpbiNew->biHeight = dyD;
lpbiNew->biBitCount = bpp;
lpBitsNew = (LPBYTE)lpbiNew +
sizeof(BITMAPINFOHEADER) +
(256 * sizeof(RGBQUAD));
if (ScaleDIB((LPBITMAPINFOHEADER)lpbi,
(LPVOID)lpBits,
lpbiNew,
lpBitsNew)) {
lpbi = (LPBITMAPINFO)lpbiNew;
lpBits = lpBitsNew;
dxS = dxD;
dyS = dyD;
}
}
}
i = StretchDIBits(hdc,
xD,
yD,
dxD,
dyD,
xS,
yS,
dxS,
dyS,
lpBits,
lpbi,
wUsage,
rop);
if (lpbiNew)
UserLocalFree(lpbiNew);
return i;
}
int DrawTextExA(
HDC hdc,
LPSTR lpchText,
int cchText,
LPRECT lprc,
UINT format,
LPDRAWTEXTPARAMS lpdtp)
{
LPWSTR lpwstr;
int iRet;
int iUniString;
WORD wCodePage = (WORD)GdiGetCodePage(hdc);
if (cchText == -1) {
// USER_AWCONV_COUNTSTRINGSZ does not count/convert trailing \0.
cchText = USER_AWCONV_COUNTSTRINGSZ;
} else if (cchText < -1) {
return 0;
}
if ((iUniString = MBToWCSEx(wCodePage, lpchText, cchText, &lpwstr, -1, TRUE)) == 0) {
if (cchText == USER_AWCONV_COUNTSTRINGSZ) {
lpwstr = (LPWSTR)gwszNullStr;
format &= ~DT_MODIFYSTRING;
} else {
return 0;
}
}
/*
* Grow the buffer to accomodate the ellipsis (see AddEllipsisAndDrawLine)
*/
if (format & DT_MODIFYSTRING) {
int iNewLen = (iUniString + CCHELLIPSIS + 1) * sizeof(*lpwstr);
LPWSTR lpwstrNew = UserLocalReAlloc(lpwstr, iNewLen, HEAP_ZERO_MEMORY);
if (lpwstrNew == NULL) {
UserLocalFree((HANDLE)lpwstr);
return FALSE;
}
lpwstr = lpwstrNew;
}
iRet = DrawTextExWorker(hdc, lpwstr, iUniString, lprc, format, lpdtp, GetTextCharset(hdc));
if (format & DT_MODIFYSTRING) {
/*
* Note that if the buffer grew and the caller provided the string size,
* then we won't return the additional characters... fixing this
* might break some apps so let's leave it alone until some one complains
*/
if (cchText < 0) {
UserAssert(cchText == USER_AWCONV_COUNTSTRINGSZ);
// Guess how many bytes we can put in the buffer...
// We can safely assume the maximum bytes available.
// At worst, even for DBCS, the buffer size required
// will be smaller than or equal to the orignal size,
// because some DBCS characters would be substituted
// to SBC ".", which is one byte each.
// On the other hand, the number of characters converted
// is limited by both iUniString and cchText.
//
if (IS_DBCS_ENABLED()) {
cchText = iUniString * DBCS_CHARSIZE;
} else {
cchText = iUniString * sizeof(CHAR);
}
}
WCSToMBEx(wCodePage, lpwstr, iUniString, &lpchText, cchText, FALSE);
}
if (lpwstr != gwszNullStr) {
UserLocalFree((HANDLE)lpwstr);
}
return iRet;
}
/***************************************************************************\
* _ClientEventCallback
*
* Description:
* Called from the server side to perform event callbacks.
*
* History:
* 11-12-91 sanfords Created.
\***************************************************************************/
DWORD _ClientEventCallback(
PCL_INSTANCE_INFO pcii,
PEVENT_PACKET pep)
{
HDDEDATA hData;
EnterDDECrit;
switch (pep->EventType) {
case 0: // MonitorFlags change event - everybody gets it
pcii->MonitorFlags = pep->Data;
break;
case MF_CALLBACKS:
{
MONCBSTRUCT mcb;
mcb = *((MONCBSTRUCT *)&pep->Data);
mcb.hsz1 = NORMAL_HSZ_FROM_LATOM(GlobalToLocalAtom((GATOM)mcb.hsz1));
mcb.hsz2 = NORMAL_HSZ_FROM_LATOM(GlobalToLocalAtom((GATOM)mcb.hsz2));
if ( mcb.wType == XTYP_REGISTER ||
mcb.wType == XTYP_UNREGISTER) {
mcb.hsz2 = INST_SPECIFIC_HSZ_FROM_LATOM((LATOM)mcb.hsz2);
}
hData = InternalCreateDataHandle(pcii, (LPSTR)&mcb,
pep->cbEventData, 0,
HDATA_NOAPPFREE | HDATA_READONLY | HDATA_EXECUTE, 0, 0);
if (hData) {
DoCallback(pcii, (WORD)XTYP_MONITOR, 0, 0, 0, 0, hData, 0L,
pep->EventType);
InternalFreeDataHandle((HDDEDATA)hData, TRUE);
DeleteAtom(LATOM_FROM_HSZ(mcb.hsz1));
DeleteAtom(LATOM_FROM_HSZ(mcb.hsz2));
}
}
break;
case MF_LINKS:
{
MONLINKSTRUCT ml;
ml = *((MONLINKSTRUCT *)&pep->Data);
ml.hszSvc = NORMAL_HSZ_FROM_LATOM(GlobalToLocalAtom((GATOM)ml.hszSvc));
ml.hszTopic = NORMAL_HSZ_FROM_LATOM(GlobalToLocalAtom((GATOM)ml.hszTopic));
ml.hszItem = NORMAL_HSZ_FROM_LATOM(GlobalToLocalAtom((GATOM)ml.hszItem));
hData = InternalCreateDataHandle(pcii, (LPSTR)&ml,
pep->cbEventData, 0,
HDATA_NOAPPFREE | HDATA_READONLY | HDATA_EXECUTE, 0, 0);
if (hData) {
DoCallback(pcii, (WORD)XTYP_MONITOR, 0, 0, 0, 0, hData, 0L,
pep->EventType);
InternalFreeDataHandle((HDDEDATA)hData, TRUE);
DeleteAtom(LATOM_FROM_HSZ(ml.hszSvc));
DeleteAtom(LATOM_FROM_HSZ(ml.hszTopic));
DeleteAtom(LATOM_FROM_HSZ(ml.hszItem));
}
}
break;
case MF_CONV:
{
MONCONVSTRUCT mc;
mc = *((MONCONVSTRUCT *)&pep->Data);
mc.hszSvc = NORMAL_HSZ_FROM_LATOM(GlobalToLocalAtom((GATOM)mc.hszSvc));
mc.hszTopic = NORMAL_HSZ_FROM_LATOM(GlobalToLocalAtom((GATOM)mc.hszTopic));
hData = InternalCreateDataHandle(pcii, (LPSTR)&mc,
pep->cbEventData, 0,
HDATA_NOAPPFREE | HDATA_READONLY | HDATA_EXECUTE, 0, 0);
if (hData) {
DoCallback(pcii, (WORD)XTYP_MONITOR, 0, 0, 0, 0, hData, 0L,
pep->EventType);
InternalFreeDataHandle((HDDEDATA)hData, TRUE);
DeleteAtom(LATOM_FROM_HSZ(mc.hszSvc));
DeleteAtom(LATOM_FROM_HSZ(mc.hszTopic));
}
}
break;
case MF_HSZ_INFO:
if (!(pcii->flags & IIF_UNICODE)) {
LPSTR pszAnsi;
/*
* Translate HSZ string back into ANSI
*/
if (WCSToMB(((PMONHSZSTRUCT)&pep->Data)->str,
((int)pep->cbEventData - (int)((PMONHSZSTRUCT)&pep->Data)->cb) / sizeof(WCHAR),
&pszAnsi,
(int)pep->cbEventData - (int)((PMONHSZSTRUCT)&pep->Data)->cb,
TRUE)) {
strcpy(((PMONHSZSTRUCTA)&pep->Data)->str, pszAnsi);
UserLocalFree(pszAnsi);
}
((PMONHSZSTRUCT)&pep->Data)->cb = sizeof(MONHSZSTRUCTA);
}
// fall through
case MF_SENDMSGS:
case MF_POSTMSGS:
if (pep->EventType == MF_POSTMSGS) {
PMONMSGSTRUCT pmms = (PMONMSGSTRUCT)&pep->Data;
BYTE buf[32];
/*
* We may need to translate the Execute string to/from
* UNICODE depending on what type of monitor this is
* going to.
*/
if (pmms->wMsg == WM_DDE_EXECUTE) {
BOOL fUnicodeText;
int flags;
flags = (IS_TEXT_UNICODE_UNICODE_MASK |
IS_TEXT_UNICODE_REVERSE_MASK |
(IS_TEXT_UNICODE_NOT_UNICODE_MASK &
(~IS_TEXT_UNICODE_ILLEGAL_CHARS)) |
IS_TEXT_UNICODE_NOT_ASCII_MASK);
#ifdef ISTEXTUNICODE_WORKS
fUnicodeText = RtlIsTextUnicode(pmms->dmhd.Data,
min(32, pmms->dmhd.cbData), &flags);
#else
fUnicodeText = (*(LPSTR)pmms->dmhd.Data == '\0');
#endif
if (pcii->flags & IIF_UNICODE && !fUnicodeText) {
/* Ascii->UNICODE */
RtlMultiByteToUnicodeN((LPWSTR)buf, 32, NULL,
(LPSTR)&pmms->dmhd.Data,
min(32, pmms->dmhd.cbData));
RtlCopyMemory(&pmms->dmhd.Data, buf, 32);
} else if (!(pcii->flags & IIF_UNICODE) && fUnicodeText) {
/* UNICODE->Ascii */
RtlUnicodeToMultiByteN((LPSTR)buf, 32, NULL,
(LPWSTR)&pmms->dmhd.Data,
min(32, pmms->dmhd.cbData));
RtlCopyMemory(&pmms->dmhd.Data, buf, 32);
}
}
}
case MF_ERRORS:
hData = InternalCreateDataHandle(pcii, (LPSTR)&pep->Data,
pep->cbEventData, 0,
HDATA_NOAPPFREE | HDATA_READONLY | HDATA_EXECUTE, 0, 0);
if (hData) {
DoCallback(pcii, (WORD)XTYP_MONITOR, 0, 0, 0, 0, hData, 0L,
pep->EventType);
InternalFreeDataHandle((HDDEDATA)hData, TRUE);
}
break;
}
LeaveDDECrit;
return (0);
}
WINUSERAPI HANDLE WINAPI SetSysColorsTemp(
CONST COLORREF *lpRGBs,
CONST HBRUSH *lpBrushes,
UINT_PTR cBrushes) // Count of brushes or handle
{
UINT cbRGBSize;
UINT i;
UINT abElements[COLOR_MAX];
/*
* See if we are resetting the colors back to a saved state
*/
if (lpRGBs == NULL) {
/*
* When restoring cBrushes is really a handle to the old global
* handle. Make sure that is true. Also lpBrushes is unused
*/
UNREFERENCED_PARAMETER(lpBrushes);
UserAssert(lpBrushes == NULL);
UserAssert(cBrushes == (ULONG_PTR)gpOriginalRGBs);
if (gpOriginalRGBs == NULL) {
RIPMSG0(RIP_ERROR, "SetSysColorsTemp: Can not restore if not saved");
return NULL;
}
/*
* reset the global Colors
*/
UserAssert((sizeof(abElements)/sizeof(abElements[0])) >= gcOriginalRGBs);
for (i = 0; i < gcOriginalRGBs; i++)
abElements[i] = i;
NtUserSetSysColors(gcOriginalRGBs, abElements, gpOriginalRGBs, 0);
UserLocalFree(gpOriginalRGBs);
gpOriginalRGBs = NULL;
gcOriginalRGBs = 0;
return (HANDLE)TRUE;
}
/*
* Make sure we aren't trying to set too many colors
* If we allow more then COLOR_MAX change the abElements array
*/
if (cBrushes > COLOR_MAX) {
RIPMSG1(RIP_ERROR, "SetSysColorsTemp: trying to set too many colors %lX", cBrushes);
return NULL;
}
/*
* If we have already a saved state then don't let them save it again
*/
if (gpOriginalRGBs != NULL) {
RIPMSG0(RIP_ERROR, "SetSysColorsTemp: temp colors already set");
return NULL;
}
/*
* If we are here then we must be setting the new temp colors
*
* First save the old colors
*/
cbRGBSize = sizeof(COLORREF) * (UINT)cBrushes;
UserAssert(sizeof(COLORREF) == sizeof(int));
gpOriginalRGBs = UserLocalAlloc(HEAP_ZERO_MEMORY, cbRGBSize);
if (gpOriginalRGBs == NULL) {
RIPMSG0(RIP_WARNING, "SetSysColorsTemp: unable to alloc temp colors buffer");
}
RtlCopyMemory(gpOriginalRGBs, gpsi->argbSystem, cbRGBSize);
/*
* Now set the new colors.
*/
UserAssert( (sizeof(abElements)/sizeof(abElements[0])) >= cBrushes);
for (i = 0; i < cBrushes; i++)
abElements[i] = i;
NtUserSetSysColors((UINT)cBrushes, abElements, lpRGBs, 0);
gcOriginalRGBs = (UINT)cBrushes;
return gpOriginalRGBs;
}
/***************************************************************************\
* ImmInitializeHotkeys()
*
* Called from user\client\UpdatePerUserSystemParameters()
*
* Read the User registry and set the IME hotkey.
*
* History:
* 25-Mar-1996 TakaoK Created
\***************************************************************************/
VOID CliImmInitializeHotKeys(DWORD dwAction, HKL hkl)
{
FE_KEYBOARDS feKbds = { 0, 0, 0, 0, };
BOOL fFoundAny;
UNREFERENCED_PARAMETER(hkl);
// First, initialize the hotkey list
CliImmSetHotKeyWorker(0, 0, 0, NULL, ISHK_INITIALIZE);
// Check if the user has customized IME hotkeys
// (they're stored in the registry)
fFoundAny = CliGetImeHotKeysFromRegistry();
if (dwAction == ISHK_INITIALIZE) {
TAGMSG0(DBGTAG_IMM, "Setting IME HotKeys for Init.\n");
// Get the user's default locale and set its flag
SetFeKeyboardFlags(LANGIDFROMLCID(GetUserDefaultLCID()), &feKbds);
// Get preloaded keyboards' locales and set their flags
CliGetPreloadKeyboardLayouts(&feKbds);
}
else {
UINT i;
UINT nLayouts;
LPHKL lphkl;
TAGMSG0(DBGTAG_IMM, "Setting IME HotKeys for Add.\n");
nLayouts = NtUserGetKeyboardLayoutList(0, NULL);
if (nLayouts == 0) {
return;
}
lphkl = UserLocalAlloc(0, nLayouts * sizeof(HKL));
if (lphkl == NULL) {
return;
}
NtUserGetKeyboardLayoutList(nLayouts, lphkl);
for (i = 0; i < nLayouts; ++i) {
//
// Set language flags. By its definition, LOWORD(hkl) is LANGID
//
SetFeKeyboardFlags(LOWORD(HandleToUlong(lphkl[i])), &feKbds);
}
UserLocalFree(lphkl);
}
if (feKbds.fJPN) {
TAGMSG0(DBGTAG_IMM, "JPN KL Preloaded.\n");
CliSetDefaultImeHotKeys(DefaultHotKeyTableJ, DefaultHotKeyNumJ, fFoundAny);
}
if (feKbds.fKOR) {
TAGMSG0(DBGTAG_IMM, "KOR KL Preloaded, but KOR hotkeys will not be registered.\n");
}
if (feKbds.fCHT) {
TAGMSG0(DBGTAG_IMM, "CHT KL Preloaded.\n");
CliSetDefaultImeHotKeys(DefaultHotKeyTableT, DefaultHotKeyNumT, fFoundAny);
}
if (feKbds.fCHS) {
TAGMSG0(DBGTAG_IMM, "CHS KL Preloaded.\n");
CliSetDefaultImeHotKeys(DefaultHotKeyTableC, DefaultHotKeyNumC, fFoundAny);
}
}
LRESULT APIENTRY ListBoxWndProcWorker(
PWND pwnd,
UINT message,
WPARAM wParam,
LPARAM lParam,
DWORD fAnsi)
{
HWND hwnd = HWq(pwnd);
PAINTSTRUCT ps;
HDC hdc;
LPRECT lprc;
PLBIV plb; /* List Box Instance Variable */
INT iSel; /* Index of selected item */
DWORD dw;
TL tlpwndParent;
UINT wFlags;
LPWSTR lpwsz = NULL;
LRESULT lReturn = 0;
static BOOL fInit = TRUE;
CheckLock(pwnd);
VALIDATECLASSANDSIZE(pwnd, FNID_LISTBOX);
INITCONTROLLOOKASIDE(&ListboxLookaside, LBIV, spwnd, 4);
/*
* Get the plb for the given window now since we will use it a lot in
* various handlers. This was stored using SetWindowLong(hwnd,0,plb)
* when the listbox was first created (by INITCONTROLLOOKASIDE above)
*/
plb = ((PLBWND)pwnd)->pLBIV;
/*
* Handle ANSI translations of input parameters
*/
if (fAnsi) {
switch (message) {
case LB_ADDSTRING:
case LB_ADDSTRINGUPPER:
case LB_ADDSTRINGLOWER:
case LB_FINDSTRING:
case LB_FINDSTRINGEXACT:
case LB_INSERTSTRING:
case LB_INSERTSTRINGUPPER:
case LB_INSERTSTRINGLOWER:
case LB_SELECTSTRING:
if (!plb->fHasStrings) {
break;
}
// Fall through...
case LB_ADDFILE:
case LB_DIR:
if (lParam) {
if (!MBToWCS((LPSTR)lParam, -1, &lpwsz, -1, TRUE))
return LB_ERR;
}
break;
default:
break;
}
if (lpwsz) {
lParam = (LPARAM)lpwsz;
}
}
switch (message) {
case LB_GETTOPINDEX: // Return index of top item displayed.
return plb->iTop;
case LB_SETTOPINDEX:
if (wParam && ((INT)wParam < 0 || (INT)wParam >= plb->cMac)) {
RIPERR0(ERROR_INVALID_INDEX, RIP_VERBOSE, "");
return LB_ERR;
}
if (plb->cMac) {
xxxNewITop(plb, (INT)wParam);
}
break;
case WM_STYLECHANGED:
plb->fRtoLReading = (TestWF(pwnd, WEFRTLREADING) != 0);
plb->fRightAlign = (TestWF(pwnd, WEFRIGHT) != 0);
xxxCheckRedraw(plb, FALSE, 0);
break;
case WM_WINDOWPOSCHANGED:
/*
* If we are in the middle of creation, ignore this
* message because it will generate a WM_SIZE message.
* See xxxLBCreate().
*/
if (!plb->fIgnoreSizeMsg)
goto CallDWP;
break;
case WM_SIZE:
/*
* If we are in the middle of creation, ignore size
* messages. See xxxLBCreate().
*/
if (!plb->fIgnoreSizeMsg)
xxxLBSize(plb, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
break;
case WM_ERASEBKGND:
ThreadLock(plb->spwndParent, &tlpwndParent);
FillWindow(HW(plb->spwndParent), hwnd, (HDC)wParam,
(HBRUSH)CTLCOLOR_LISTBOX);
ThreadUnlock(&tlpwndParent);
return TRUE;
case LB_RESETCONTENT:
xxxLBResetContent(plb);
break;
case WM_TIMER:
if (wParam == IDSYS_LBSEARCH) {
plb->iTypeSearch = 0;
NtUserKillTimer(hwnd, IDSYS_LBSEARCH);
xxxInvertLBItem(plb, plb->iSel, TRUE);
break;
}
message = WM_MOUSEMOVE;
xxxTrackMouse(plb, message, plb->ptPrev);
break;
/*
* Fall through
*/
case WM_MOUSEMOVE:
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_LBUTTONDBLCLK:
{
POINT pt;
POINTSTOPOINT(pt, lParam);
xxxTrackMouse(plb, message, pt);
}
break;
case WM_MBUTTONDOWN:
EnterReaderModeHelper(hwnd);
break;
case WM_CAPTURECHANGED:
//
// Note that this message should be handled only on unexpected
// capture changes currently.
//
UserAssert(TestWF(pwnd, WFWIN40COMPAT));
if (plb->fCaptured)
xxxLBButtonUp(plb, LBUP_NOTIFY);
break;
case LBCB_STARTTRACK:
//
// Start tracking mouse moves in the listbox, setting capture
//
if (!plb->pcbox)
break;
plb->fCaptured = FALSE;
if (wParam) {
POINT pt;
POINTSTOPOINT(pt, lParam);
_ScreenToClient(pwnd, &pt);
xxxTrackMouse(plb, WM_LBUTTONDOWN, pt);
} else {
NtUserSetCapture(hwnd);
plb->fCaptured = TRUE;
plb->iLastSelection = plb->iSel;
}
break;
case LBCB_ENDTRACK:
// Kill capture, tracking, etc.
if (plb->fCaptured)
xxxLBButtonUp(plb, LBUP_RELEASECAPTURE | (wParam ? LBUP_SELCHANGE :
LBUP_RESETSELECTION));
break;
case WM_PRINTCLIENT:
xxxLBPaint(plb, (HDC) wParam, NULL);
break;
case WM_PAINT:
if (wParam) {
hdc = (HDC) wParam;
lprc = NULL;
} else {
hdc = NtUserBeginPaint(hwnd, &ps);
lprc = &(ps.rcPaint);
}
if (IsLBoxVisible(plb))
xxxLBPaint(plb, hdc, lprc);
if (!wParam)
NtUserEndPaint(hwnd, &ps);
break;
case WM_NCDESTROY:
case WM_FINALDESTROY:
xxxDestroyLBox(plb, pwnd);
break;
case WM_SETFOCUS:
// DISABLED in Win 3.1 xxxUpdateWindow(pwnd);
CaretCreate(plb);
xxxLBSetCaret(plb, TRUE);
xxxNotifyOwner(plb, LBN_SETFOCUS);
if (FWINABLE()) {
if (_IsWindowVisible(pwnd)) {
LBEvent(plb, EVENT_OBJECT_FOCUS, plb->iSelBase);
}
}
break;
case WM_KILLFOCUS:
/*
* Reset the wheel delta count.
*/
gcWheelDelta = 0;
xxxLBSetCaret(plb, FALSE);
xxxCaretDestroy(plb);
xxxNotifyOwner(plb, LBN_KILLFOCUS);
if (plb->iTypeSearch) {
plb->iTypeSearch = 0;
NtUserKillTimer(hwnd, IDSYS_LBSEARCH);
}
if (plb->pszTypeSearch) {
UserLocalFree(plb->pszTypeSearch);
plb->pszTypeSearch = NULL;
}
break;
case WM_MOUSEWHEEL:
{
int cDetants;
int cPage;
int cLines;
RECT rc;
int windowWidth;
int cPos;
/*
* Don't handle zoom and datazoom.
*/
if (wParam & (MK_SHIFT | MK_CONTROL)) {
goto CallDWP;
}
lReturn = 1;
gcWheelDelta -= (short) HIWORD(wParam);
cDetants = gcWheelDelta / WHEEL_DELTA;
if ( cDetants != 0 &&
gpsi->ucWheelScrollLines > 0 &&
(pwnd->style & (WS_VSCROLL | WS_HSCROLL))) {
gcWheelDelta = gcWheelDelta % WHEEL_DELTA;
if (pwnd->style & WS_VSCROLL) {
cPage = max(1, (plb->cItemFullMax - 1));
cLines = cDetants *
(int) min((UINT) cPage, gpsi->ucWheelScrollLines);
cPos = max(0, min(plb->iTop + cLines, plb->cMac - 1));
if (cPos != plb->iTop) {
xxxLBoxCtlScroll(plb, SB_THUMBPOSITION, cPos);
xxxLBoxCtlScroll(plb, SB_ENDSCROLL, 0);
}
} else if (plb->fMultiColumn) {
cPage = max(1, plb->numberOfColumns);
cLines = cDetants * (int) min((UINT) cPage, gpsi->ucWheelScrollLines);
cPos = max(
0,
min((plb->iTop / plb->itemsPerColumn) + cLines,
plb->cMac - 1 - ((plb->cMac - 1) % plb->itemsPerColumn)));
if (cPos != plb->iTop) {
xxxLBoxCtlHScrollMultiColumn(plb, SB_THUMBPOSITION, cPos);
xxxLBoxCtlHScrollMultiColumn(plb, SB_ENDSCROLL, 0);
}
} else {
_GetClientRect(plb->spwnd, &rc);
windowWidth = rc.right;
cPage = max(plb->cxChar, (windowWidth / 3) * 2) /
plb->cxChar;
cLines = cDetants *
(int) min((UINT) cPage, gpsi->ucWheelScrollLines);
cPos = max(
0,
min(plb->xOrigin + (cLines * plb->cxChar),
plb->maxWidth));
if (cPos != plb->xOrigin) {
xxxLBoxCtlHScroll(plb, SB_THUMBPOSITION, cPos);
xxxLBoxCtlHScroll(plb, SB_ENDSCROLL, 0);
}
}
}
}
break;
case WM_VSCROLL:
xxxLBoxCtlScroll(plb, LOWORD(wParam), HIWORD(wParam));
break;
case WM_HSCROLL:
xxxLBoxCtlHScroll(plb, LOWORD(wParam), HIWORD(wParam));
break;
case WM_GETDLGCODE:
return DLGC_WANTARROWS | DLGC_WANTCHARS;
case WM_CREATE:
return xxxLBCreate(plb, pwnd, (LPCREATESTRUCT) lParam);
case WM_SETREDRAW:
/*
* If wParam is nonzero, the redraw flag is set
* If wParam is zero, the flag is cleared
*/
xxxLBSetRedraw(plb, (wParam != 0));
break;
case WM_ENABLE:
xxxLBInvalidateRect(plb, NULL, !plb->OwnerDraw);
break;
case WM_SETFONT:
xxxLBSetFont(plb, (HANDLE)wParam, LOWORD(lParam));
break;
case WM_GETFONT:
return (LRESULT)plb->hFont;
case WM_DRAGSELECT:
case WM_DRAGLOOP:
case WM_DRAGMOVE:
case WM_DROPFILES:
ThreadLock(plb->spwndParent, &tlpwndParent);
lReturn = SendMessage(HW(plb->spwndParent), message, wParam, lParam);
ThreadUnlock(&tlpwndParent);
return lReturn;
case WM_QUERYDROPOBJECT:
case WM_DROPOBJECT:
/*
* fix up control data, then pass message to parent
*/
LBDropObjectHandler(plb, (PDROPSTRUCT)lParam);
ThreadLock(plb->spwndParent, &tlpwndParent);
lReturn = SendMessage(HW(plb->spwndParent), message, wParam, lParam);
ThreadUnlock(&tlpwndParent);
return lReturn;
case LB_GETITEMRECT:
return LBGetItemRect(plb, (INT)wParam, (LPRECT)lParam);
case LB_GETITEMDATA:
return LBGetItemData(plb, (INT)wParam); // wParam = item index
case LB_SETITEMDATA:
/*
* wParam is item index
*/
return LBSetItemData(plb, (INT)wParam, lParam);
case LB_ADDSTRINGUPPER:
wFlags = UPPERCASE | LBI_ADD;
goto CallInsertItem;
case LB_ADDSTRINGLOWER:
wFlags = LOWERCASE | LBI_ADD;
goto CallInsertItem;
case LB_ADDSTRING:
wFlags = LBI_ADD;
goto CallInsertItem;
case LB_INSERTSTRINGUPPER:
wFlags = UPPERCASE;
goto CallInsertItem;
case LB_INSERTSTRINGLOWER:
wFlags = LOWERCASE;
goto CallInsertItem;
case LB_INSERTSTRING:
wFlags = 0;
CallInsertItem:
lReturn = ((LRESULT) xxxLBInsertItem(plb, (LPWSTR) lParam, (int) wParam, wFlags));
break;
case LB_INITSTORAGE:
return xxxLBInitStorage(plb, fAnsi, (INT)wParam, (INT)lParam);
case LB_DELETESTRING:
return xxxLBoxCtlDelete(plb, (INT)wParam);
case LB_DIR:
/*
* wParam - Dos attribute value.
* lParam - Points to a file specification string
*/
lReturn = xxxLbDir(plb, (INT)wParam, (LPWSTR)lParam);
break;
case LB_ADDFILE:
lReturn = xxxLbInsertFile(plb, (LPWSTR)lParam);
break;
case LB_SETSEL:
return xxxLBSetSel(plb, (wParam != 0), (INT)lParam);
case LB_SETCURSEL:
/*
* If window obscured, update so invert will work correctly
*/
// DISABLED in Win 3.1 xxxUpdateWindow(pwnd);
return xxxLBSetCurSel(plb, (INT)wParam);
case LB_GETSEL:
if (wParam >= (UINT) plb->cMac)
return((LRESULT) LB_ERR);
return IsSelected(plb, (INT)wParam, SELONLY);
case LB_GETCURSEL:
if (plb->wMultiple == SINGLESEL) {
return plb->iSel;
}
return plb->iSelBase;
case LB_SELITEMRANGE:
if (plb->wMultiple == SINGLESEL) {
/*
* Can't select a range if only single selections are enabled
*/
RIPERR0(ERROR_INVALID_INDEX, RIP_VERBOSE,"Invalid index passed to LB_SELITEMRANGE");
return LB_ERR;
}
xxxLBSelRange(plb, LOWORD(lParam), HIWORD(lParam), (wParam != 0));
break;
case LB_SELITEMRANGEEX:
if (plb->wMultiple == SINGLESEL) {
/*
* Can't select a range if only single selections are enabled
*/
RIPERR0(ERROR_INVALID_LB_MESSAGE, RIP_VERBOSE,"LB_SELITEMRANGEEX:Can't select a range if only single selections are enabled");
return LB_ERR;
} else {
BOOL fHighlight = ((DWORD)lParam > (DWORD)wParam);
if (fHighlight == FALSE) {
ULONG_PTR temp = lParam;
lParam = wParam;
wParam = temp;
}
xxxLBSelRange(plb, (INT)wParam, (INT)lParam, fHighlight);
}
break;
case LB_GETTEXTLEN:
if (lParam != 0) {
RIPMSG1(RIP_WARNING, "LB_GETTEXTLEN with lParam = %lx\n", lParam);
}
lReturn = LBGetText(plb, TRUE, fAnsi, (INT)wParam, NULL);
break;
case LB_GETTEXT:
lReturn = LBGetText(plb, FALSE, fAnsi, (INT)wParam, (LPWSTR)lParam);
break;
case LB_GETCOUNT:
// Lotus Approach calls CallWndProc(ListWndProc, LB_GETCOUNT,...)
// on a window that doesn't have a plb yet. So, we need to make
// this check. Bug #6675 - 11/7/94 --
if(plb)
return((LRESULT) plb->cMac);
else
return(0);
case LB_SETCOUNT:
return xxxLBSetCount(plb, (INT)wParam);
case LB_SELECTSTRING:
case LB_FINDSTRING:
iSel = xxxFindString(plb, (LPWSTR)lParam, (INT)wParam, PREFIX, TRUE);
if (message == LB_FINDSTRING || iSel == LB_ERR) {
lReturn = iSel;
} else {
lReturn = xxxLBSetCurSel(plb, iSel);
}
break;
case LB_GETLOCALE:
return plb->dwLocaleId;
case LB_SETLOCALE:
/*
* Validate locale
*/
wParam = ConvertDefaultLocale((LCID)wParam);
if (!IsValidLocale((LCID)wParam, LCID_INSTALLED))
return LB_ERR;
dw = plb->dwLocaleId;
plb->dwLocaleId = (DWORD)wParam;
return dw;
case WM_KEYDOWN:
/*
* IanJa: Use LOWORD() to get low 16-bits of wParam - this should
* work for Win16 & Win32. The value obtained is the virtual key
*/
xxxLBoxCtlKeyInput(plb, message, LOWORD(wParam));
break;
case WM_CHAR:
xxxLBoxCtlCharInput(plb, LOWORD(wParam), fAnsi);
break;
case LB_GETSELITEMS:
case LB_GETSELCOUNT:
/*
* IanJa/Win32 should this be LPWORD now?
*/
return LBoxGetSelItems(plb, (message == LB_GETSELCOUNT), (INT)wParam,
(LPINT)lParam);
case LB_SETTABSTOPS:
/*
* IanJa/Win32: Tabs given by array of INT for backwards compatability
*/
return LBSetTabStops(plb, (INT)wParam, (LPINT)lParam);
case LB_GETHORIZONTALEXTENT:
/*
* Return the max width of the listbox used for horizontal scrolling
*/
return plb->maxWidth;
case LB_SETHORIZONTALEXTENT:
/*
* Set the max width of the listbox used for horizontal scrolling
*/
if (plb->maxWidth != (INT)wParam) {
plb->maxWidth = (INT)wParam;
/*
* When horizontal extent is set, Show/hide the scroll bars.
* NOTE: LBShowHideScrollBars() takes care if Redraw is OFF.
* Fix for Bug #2477 -- 01/14/91 -- SANKAR --
*/
xxxLBShowHideScrollBars(plb); //Try to show or hide scroll bars
if (plb->fHorzBar && plb->fRightAlign && !(plb->fMultiColumn || plb->OwnerDraw)) {
/*
* origin to right
*/
xxxLBoxCtlHScroll(plb, SB_BOTTOM, 0);
}
}
break; /* originally returned register ax (message) ! */
case LB_SETCOLUMNWIDTH:
/*
* Set the width of a column in a multicolumn listbox
*/
plb->cxColumn = (INT)wParam;
LBCalcItemRowsAndColumns(plb);
if (IsLBoxVisible(plb))
NtUserInvalidateRect(hwnd, NULL, TRUE);
xxxLBShowHideScrollBars(plb);
break;
case LB_SETANCHORINDEX:
if ((INT)wParam >= plb->cMac) {
RIPERR0(ERROR_INVALID_INDEX, RIP_VERBOSE,"Invalid index passed to LB_SETANCHORINDEX");
return LB_ERR;
}
plb->iMouseDown = (INT)wParam;
plb->iLastMouseMove = (INT)wParam;
xxxInsureVisible(plb, (int) wParam, (BOOL)(lParam != 0));
break;
case LB_GETANCHORINDEX:
return plb->iMouseDown;
case LB_SETCARETINDEX:
if ( (plb->iSel == -1) || ((plb->wMultiple != SINGLESEL) &&
(plb->cMac > (INT)wParam))) {
/*
* Set's the iSelBase to the wParam
* if lParam, then don't scroll if partially visible
* else scroll into view if not fully visible
*/
xxxInsureVisible(plb, (INT)wParam, (BOOL)LOWORD(lParam));
xxxSetISelBase(plb, (INT)wParam);
break;
} else {
if ((INT)wParam >= plb->cMac) {
RIPERR0(ERROR_INVALID_INDEX, RIP_VERBOSE,"Invalid index passed to LB_SETCARETINDEX");
}
return LB_ERR;
}
break;
case LB_GETCARETINDEX:
return plb->iSelBase;
case LB_SETITEMHEIGHT:
case LB_GETITEMHEIGHT:
return LBGetSetItemHeightHandler(plb, message, (INT)wParam, LOWORD(lParam));
break;
case LB_FINDSTRINGEXACT:
lReturn = xxxFindString(plb, (LPWSTR)lParam, (INT)wParam, EQ, TRUE);
break;
case LB_ITEMFROMPOINT: {
POINT pt;
BOOL bOutside;
DWORD dwItem;
POINTSTOPOINT(pt, lParam);
bOutside = ISelFromPt(plb, pt, &dwItem);
UserAssert(bOutside == 1 || bOutside == 0);
return (LRESULT)MAKELONG(dwItem, bOutside);
}
case LBCB_CARETON:
/*
* Internal message for combo box support
*/
CaretCreate(plb);
// Set up the caret in the proper location for drop downs.
plb->iSelBase = plb->iSel;
xxxLBSetCaret(plb, TRUE);
if (FWINABLE()) {
if (_IsWindowVisible(pwnd)) {
LBEvent(plb, EVENT_OBJECT_FOCUS, plb->iSelBase);
}
}
return(plb->iSel);
case LBCB_CARETOFF:
/*
* Internal message for combo box support
*/
xxxLBSetCaret(plb, FALSE);
xxxCaretDestroy(plb);
break;
case WM_NCCREATE:
if ((pwnd->style & LBS_MULTICOLUMN) && (pwnd->style & WS_VSCROLL))
{
DWORD mask = WS_VSCROLL;
DWORD flags = 0;
if (!TestWF(pwnd, WFWIN40COMPAT)) {
mask |= WS_HSCROLL;
flags = WS_HSCROLL;
}
NtUserAlterWindowStyle(hwnd, mask, flags);
}
goto CallDWP;
default:
CallDWP:
return DefWindowProcWorker(pwnd, message, wParam, lParam, fAnsi);
}
/*
* Handle translation of ANSI output data and free buffer
*/
if (lpwsz) {
UserLocalFree(lpwsz);
}
return lReturn;
}
