2910 lines
79 KiB
C
2910 lines
79 KiB
C
#include "ctlspriv.h"
|
|
#pragma hdrstop
|
|
#include "usrctl32.h"
|
|
#include "combo.h"
|
|
#include "listbox.h" // For LBIV struct
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// InitComboboxClass() - Registers the control's window class
|
|
//
|
|
BOOL InitComboboxClass(HINSTANCE hInstance)
|
|
{
|
|
WNDCLASS wc;
|
|
|
|
wc.lpfnWndProc = ComboBox_WndProc;
|
|
wc.lpszClassName = WC_COMBOBOX;
|
|
wc.style = CS_GLOBALCLASS | CS_PARENTDC | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = sizeof(PCBOX);
|
|
wc.hInstance = hInstance;
|
|
wc.hIcon = NULL;
|
|
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wc.hbrBackground = NULL;
|
|
wc.lpszMenuName = NULL;
|
|
|
|
if (!RegisterClass(&wc) && !GetClassInfo(hInstance, WC_COMBOBOX, &wc))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// InitComboLBoxClass() - Registers the control's dropdown window class
|
|
//
|
|
// The dropdown list is a specially registered version
|
|
// of the listbox control called ComboLBox. We need to
|
|
// register this dummy control since apps looking for a
|
|
// combobox's listbox look for the classname ComboLBox
|
|
//
|
|
BOOL FAR PASCAL InitComboLBoxClass(HINSTANCE hinst)
|
|
{
|
|
WNDCLASS wc;
|
|
|
|
wc.lpfnWndProc = ListBox_WndProc;
|
|
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wc.hIcon = NULL;
|
|
wc.lpszMenuName = NULL;
|
|
wc.hInstance = hinst;
|
|
wc.lpszClassName = WC_COMBOLBOX;
|
|
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); // NULL;
|
|
wc.style = CS_GLOBALCLASS | CS_SAVEBITS | CS_DBLCLKS;
|
|
wc.cbWndExtra = sizeof(PLBIV);
|
|
wc.cbClsExtra = 0;
|
|
|
|
if (!RegisterClass(&wc) && !GetClassInfo(hinst, WC_COMBOLBOX, &wc))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// ComboBox_PressButton()
|
|
//
|
|
// Pops combobox button back up.
|
|
//
|
|
VOID ComboBox_PressButton(PCBOX pcbox, BOOL fPress)
|
|
{
|
|
//
|
|
// Publisher relies on getting a WM_PAINT message after the combo list
|
|
// pops back up. On a WM_PAINT they change the focus, which causes
|
|
// toolbar combos to send CBN_SELENDCANCEL notifications. On this
|
|
// notification they apply the font/pt size change you made to the
|
|
// selection.
|
|
//
|
|
// This happened in 3.1 because the dropdown list overlapped the button
|
|
// on the bottom or top by a pixel. Since we'd end up painting under
|
|
// the list SPB, when it went away USER would reinvalidate the dirty
|
|
// area. This would cause a paint message.
|
|
//
|
|
// In 4.0, this doesn't happen because the dropdown doesn't overlap. So
|
|
// we need to make sure Publisher gets a WM_PAINT anyway. We do this
|
|
// by changing where the dropdown shows up for 3.x apps
|
|
//
|
|
//
|
|
|
|
if ((pcbox->fButtonPressed != 0) != (fPress != 0))
|
|
{
|
|
HWND hwnd = pcbox->hwnd;
|
|
|
|
pcbox->fButtonPressed = (fPress != 0);
|
|
if (pcbox->f3DCombo)
|
|
{
|
|
InvalidateRect(hwnd, &pcbox->buttonrc, TRUE);
|
|
}
|
|
else
|
|
{
|
|
RECT rc;
|
|
|
|
CopyRect(&rc, &pcbox->buttonrc);
|
|
InflateRect(&rc, 0, GetSystemMetrics(SM_CYEDGE));
|
|
InvalidateRect(hwnd, &rc, TRUE);
|
|
}
|
|
|
|
UpdateWindow(hwnd);
|
|
|
|
NotifyWinEvent(EVENT_OBJECT_STATECHANGE, hwnd, OBJID_CLIENT, INDEX_COMBOBOX_BUTTON);
|
|
}
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// ComboBox_HotTrack
|
|
//
|
|
// If we're not already hot-tracking and the mouse is over the combobox,
|
|
// turn on hot-tracking and invalidate the drop-down button.
|
|
//
|
|
VOID ComboBox_HotTrack(PCBOX pcbox, POINT pt)
|
|
{
|
|
if (!pcbox->fButtonHotTracked && !pcbox->fMouseDown)
|
|
{
|
|
TRACKMOUSEEVENT tme;
|
|
|
|
tme.cbSize = sizeof(TRACKMOUSEEVENT);
|
|
tme.dwFlags = TME_LEAVE;
|
|
tme.hwndTrack = pcbox->hwnd;
|
|
tme.dwHoverTime = 0;
|
|
if (TrackMouseEvent(&tme))
|
|
{
|
|
if ((pcbox->CBoxStyle == SDROPDOWN &&
|
|
PtInRect(&pcbox->buttonrc, pt)) ||
|
|
pcbox->CBoxStyle == SDROPDOWNLIST)
|
|
{
|
|
pcbox->fButtonHotTracked = TRUE;
|
|
InvalidateRect(pcbox->hwnd, NULL, TRUE);
|
|
}
|
|
else
|
|
{
|
|
pcbox->fButtonHotTracked = FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// ComboBox_DBCharHandler
|
|
//
|
|
// Double Byte character handler for ANSI ComboBox
|
|
//
|
|
LRESULT ComboBox_DBCharHandler(PCBOX pcbox, HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
WORD w;
|
|
HWND hwndSend;
|
|
|
|
w = DbcsCombine(hwnd, (BYTE)wParam);
|
|
if (w == 0)
|
|
{
|
|
return CB_ERR; // Failed to assemble DBCS
|
|
}
|
|
|
|
UserAssert(pcbox->hwndList);
|
|
if (pcbox->fNoEdit)
|
|
{
|
|
hwndSend = pcbox->hwndList;
|
|
}
|
|
else if (pcbox->hwndEdit)
|
|
{
|
|
TraceMsg(TF_STANDARD, "UxCombobox: ComboBoxWndProcWorker: WM_CHAR is posted to Combobox itself(%08x).",
|
|
hwnd);
|
|
hwndSend = pcbox->hwndEdit;
|
|
}
|
|
else
|
|
{
|
|
return CB_ERR;
|
|
}
|
|
|
|
TraceMsg(TF_STANDARD, "UxCombobox: ComboBoxWndProcWorker: sending WM_CHAR %04x", w);
|
|
|
|
if (!TestWF(hwndSend, WFANSIPROC))
|
|
{
|
|
//
|
|
// If receiver is not ANSI WndProc (may be subclassed?),
|
|
// send a UNICODE message.
|
|
//
|
|
WCHAR wChar;
|
|
LPWSTR lpwstr = &wChar;
|
|
|
|
if (MBToWCSEx(CP_ACP, (LPCSTR)&w, 2, &lpwstr, 1, FALSE) == 0)
|
|
{
|
|
TraceMsg(TF_STANDARD, "UxCombobox: ComboBoxWndProcWorker: cannot convert 0x%04x to UNICODE.", w);
|
|
return CB_ERR;
|
|
}
|
|
|
|
return SendMessage(hwndSend, message, wChar, lParam);
|
|
}
|
|
|
|
//
|
|
// Post the Trailing byte to the target
|
|
// so that they can peek the second WM_CHAR
|
|
// message later.
|
|
// Note: it's safe since sender is A and receiver is A,
|
|
// translation layer does not perform any DBCS combining and cracking.
|
|
//PostMessageA(hwndSend, message, CrackCombinedDbcsTB(w), lParam);
|
|
//
|
|
return SendMessage(hwndSend, message, wParam, lParam);
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
BOOL ComboBox_MsgOKInit(UINT message, LRESULT* plRet)
|
|
{
|
|
switch (message)
|
|
{
|
|
default:
|
|
break;
|
|
case WM_SIZE:
|
|
case CB_SETMINVISIBLE:
|
|
case CB_GETMINVISIBLE:
|
|
*plRet = 0;
|
|
return FALSE;
|
|
case WM_STYLECHANGED:
|
|
case WM_GETTEXT:
|
|
case WM_GETTEXTLENGTH:
|
|
case WM_PRINT:
|
|
case WM_COMMAND:
|
|
case CBEC_KILLCOMBOFOCUS:
|
|
case WM_PRINTCLIENT:
|
|
case WM_SETFONT:
|
|
case WM_SYSKEYDOWN:
|
|
case WM_KEYDOWN:
|
|
case WM_CHAR:
|
|
case WM_LBUTTONDBLCLK:
|
|
case WM_LBUTTONDOWN:
|
|
case WM_MOUSEWHEEL:
|
|
case WM_CAPTURECHANGED:
|
|
case WM_LBUTTONUP:
|
|
case WM_MOUSEMOVE:
|
|
case WM_SETFOCUS:
|
|
case WM_KILLFOCUS:
|
|
case WM_SETREDRAW:
|
|
case WM_ENABLE:
|
|
case CB_SETDROPPEDWIDTH:
|
|
case CB_DIR:
|
|
case CB_ADDSTRING:
|
|
//
|
|
// Cannot handle those messages yet. Bail out.
|
|
//
|
|
*plRet = CB_ERR;
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// ComboBox_MessageItemHandler
|
|
//
|
|
// Handles WM_DRAWITEM,WM_MEASUREITEM,WM_DELETEITEM,WM_COMPAREITEM
|
|
// messages from the listbox.
|
|
//
|
|
LRESULT ComboBox_MessageItemHandler(PCBOX pcbox, UINT uMsg, LPVOID lpv)
|
|
{
|
|
LRESULT lRet;
|
|
|
|
//
|
|
// Send the <lpv>item message back to the application after changing some
|
|
// parameters to their combo box specific versions.
|
|
//
|
|
((LPMEASUREITEMSTRUCT)lpv)->CtlType = ODT_COMBOBOX;
|
|
((LPMEASUREITEMSTRUCT)lpv)->CtlID = GetWindowID(pcbox->hwnd);
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_DRAWITEM:
|
|
((LPDRAWITEMSTRUCT)lpv)->hwndItem = pcbox->hwnd;
|
|
break;
|
|
|
|
case WM_DELETEITEM:
|
|
((LPDELETEITEMSTRUCT)lpv)->hwndItem = pcbox->hwnd;
|
|
break;
|
|
|
|
case WM_COMPAREITEM:
|
|
((LPCOMPAREITEMSTRUCT)lpv)->hwndItem = pcbox->hwnd;
|
|
break;
|
|
}
|
|
|
|
lRet = SendMessage(pcbox->hwndParent, uMsg, (WPARAM)GetWindowID(pcbox->hwnd), (LPARAM)lpv);
|
|
|
|
return lRet;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
VOID ComboBox_Paint(PCBOX pcbox, HDC hdc)
|
|
{
|
|
RECT rc;
|
|
UINT msg;
|
|
HBRUSH hbr;
|
|
INT iStateId;
|
|
|
|
CCDBUFFER ccdb;
|
|
|
|
if (pcbox->fButtonPressed)
|
|
{
|
|
iStateId = CBXS_PRESSED;
|
|
}
|
|
else if ( !IsWindowEnabled(pcbox->hwnd))
|
|
{
|
|
iStateId = CBXS_DISABLED;
|
|
}
|
|
else if (pcbox->fButtonHotTracked)
|
|
{
|
|
iStateId = CBXS_HOT;
|
|
}
|
|
else
|
|
{
|
|
iStateId = CBXS_NORMAL;
|
|
}
|
|
|
|
rc.left = rc.top = 0;
|
|
rc.right = pcbox->cxCombo;
|
|
rc.bottom = pcbox->cyCombo;
|
|
|
|
hdc = CCBeginDoubleBuffer(hdc, &rc, &ccdb);
|
|
|
|
if ( !pcbox->hTheme )
|
|
{
|
|
DrawEdge(hdc, &rc, EDGE_SUNKEN, BF_RECT | BF_ADJUST | (!pcbox->f3DCombo ? BF_FLAT | BF_MONO : 0));
|
|
}
|
|
else
|
|
{
|
|
DrawThemeBackground(pcbox->hTheme, hdc, 0, iStateId, &rc, 0);
|
|
}
|
|
|
|
if ( !IsRectEmpty(&pcbox->buttonrc) )
|
|
{
|
|
//
|
|
// Draw in the dropdown arrow button
|
|
//
|
|
if (!pcbox->hTheme)
|
|
{
|
|
DrawFrameControl(hdc, &pcbox->buttonrc, DFC_SCROLL,
|
|
DFCS_SCROLLCOMBOBOX |
|
|
(pcbox->fButtonPressed ? DFCS_PUSHED | DFCS_FLAT : 0) |
|
|
(TESTFLAG(GET_STYLE(pcbox), WS_DISABLED) ? DFCS_INACTIVE : 0) |
|
|
(pcbox->fButtonHotTracked ? DFCS_HOT: 0));
|
|
}
|
|
else
|
|
{
|
|
DrawThemeBackground(pcbox->hTheme, hdc, CP_DROPDOWNBUTTON, iStateId, &pcbox->buttonrc, 0);
|
|
}
|
|
|
|
if (pcbox->fRightAlign )
|
|
{
|
|
rc.left = pcbox->buttonrc.right;
|
|
}
|
|
else
|
|
{
|
|
rc.right = pcbox->buttonrc.left;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Erase the background behind the edit/static item. Since a combo
|
|
// is an edit field/list box hybrid, we use the same coloring
|
|
// conventions.
|
|
//
|
|
msg = WM_CTLCOLOREDIT;
|
|
if (TESTFLAG(GET_STATE2(pcbox), WS_S2_WIN40COMPAT))
|
|
{
|
|
ULONG ulStyle = pcbox->hwndEdit ? GetWindowStyle(pcbox->hwndEdit) : 0;
|
|
if (TESTFLAG(GET_STYLE(pcbox), WS_DISABLED) ||
|
|
(!pcbox->fNoEdit && pcbox->hwndEdit && (ulStyle & ES_READONLY)))
|
|
{
|
|
msg = WM_CTLCOLORSTATIC;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
msg = WM_CTLCOLORLISTBOX;
|
|
}
|
|
|
|
//
|
|
// GetControlBrush
|
|
//
|
|
hbr = (HBRUSH)SendMessage(GetParent(pcbox->hwnd), msg, (WPARAM)hdc, (LPARAM)pcbox->hwnd);
|
|
|
|
if (pcbox->fNoEdit)
|
|
{
|
|
ComboBox_InternalUpdateEditWindow(pcbox, hdc);
|
|
}
|
|
else if (!pcbox->hTheme)
|
|
{
|
|
FillRect(hdc, &rc, hbr);
|
|
}
|
|
|
|
CCEndDoubleBuffer(&ccdb);
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// ComboBox_NotifyParent
|
|
//
|
|
// Sends the notification code to the parent of the combo box control
|
|
//
|
|
VOID ComboBox_NotifyParent(PCBOX pcbox, short notificationCode)
|
|
{
|
|
HWND hwndSend = (pcbox->hwndParent != 0) ? pcbox->hwndParent : pcbox->hwnd;
|
|
|
|
//
|
|
// wParam contains Control ID and notification code.
|
|
// lParam contains Handle to window
|
|
//
|
|
SendMessage(hwndSend, WM_COMMAND,
|
|
MAKELONG(GetWindowID(pcbox->hwnd), notificationCode),
|
|
(LPARAM)pcbox->hwnd);
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// ComboBox_UpdateListBoxWindow
|
|
//
|
|
// matches the text in the editcontrol. If fSelectionAlso is false, then we
|
|
// unselect the current listbox selection and just move the caret to the item
|
|
// which is the closest match to the text in the editcontrol.
|
|
//
|
|
VOID ComboBox_UpdateListBoxWindow(PCBOX pcbox, BOOL fSelectionAlso)
|
|
{
|
|
|
|
if (pcbox->hwndEdit)
|
|
{
|
|
INT cchText;
|
|
INT sItem, sSel;
|
|
LPWSTR pText = NULL;
|
|
|
|
sItem = CB_ERR;
|
|
|
|
cchText = (int)SendMessage(pcbox->hwndEdit, WM_GETTEXTLENGTH, 0, 0);
|
|
if (cchText)
|
|
{
|
|
cchText++;
|
|
pText = (LPWSTR)UserLocalAlloc(HEAP_ZERO_MEMORY, cchText*sizeof(WCHAR));
|
|
if (pText != NULL)
|
|
{
|
|
try
|
|
{
|
|
SendMessage(pcbox->hwndEdit, WM_GETTEXT, cchText, (LPARAM)pText);
|
|
sItem = (int)SendMessage(pcbox->hwndList, LB_FINDSTRING,
|
|
(WPARAM)-1L, (LPARAM)pText);
|
|
}
|
|
finally
|
|
{
|
|
UserLocalFree((HANDLE)pText);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fSelectionAlso)
|
|
{
|
|
sSel = sItem;
|
|
}
|
|
else
|
|
{
|
|
sSel = CB_ERR;
|
|
}
|
|
|
|
if (sItem == CB_ERR)
|
|
{
|
|
sItem = 0;
|
|
|
|
//
|
|
// Old apps: w/ editable combos, selected 1st item in list even if
|
|
// it didn't match text in edit field. This is not desirable
|
|
// behavior for 4.0 dudes esp. with cancel allowed. Reason:
|
|
// (1) User types in text that doesn't match list choices
|
|
// (2) User drops combo
|
|
// (3) User pops combo back up
|
|
// (4) User presses OK in dialog that does stuff w/ combo
|
|
// contents.
|
|
// In 3.1, when the combo dropped, we'd select the 1st item anyway.
|
|
// So the last CBN_SELCHANGE the owner got would be 0--which is
|
|
// bogus because it really should be -1. In fact if you type anything
|
|
// into the combo afterwards it will reset itself to -1.
|
|
//
|
|
// 4.0 dudes won't get this bogus 0 selection.
|
|
//
|
|
if (fSelectionAlso && !TESTFLAG(GET_STATE2(pcbox), WS_S2_WIN40COMPAT))
|
|
{
|
|
sSel = 0;
|
|
}
|
|
}
|
|
|
|
SendMessage(pcbox->hwndList, LB_SETCURSEL, (DWORD)sSel, 0);
|
|
SendMessage(pcbox->hwndList, LB_SETCARETINDEX, (DWORD)sItem, 0);
|
|
SendMessage(pcbox->hwndList, LB_SETTOPINDEX, (DWORD)sItem, 0);
|
|
}
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// ComboBox_InvertStaticWindow
|
|
//
|
|
// Inverts the static text/picture window associated with the combo
|
|
// box. Gets its own hdc, if the one given is null.
|
|
//
|
|
VOID ComboBox_InvertStaticWindow(PCBOX pcbox, BOOL fNewSelectionState, HDC hdc)
|
|
{
|
|
BOOL focusSave = pcbox->fFocus;
|
|
|
|
pcbox->fFocus = (UINT)fNewSelectionState;
|
|
ComboBox_InternalUpdateEditWindow(pcbox, hdc);
|
|
|
|
pcbox->fFocus = (UINT)focusSave;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// ComboBox_GetFocusHandler
|
|
//
|
|
// Handles getting the focus for the combo box
|
|
//
|
|
VOID ComboBox_GetFocusHandler(PCBOX pcbox)
|
|
{
|
|
if (pcbox->fFocus)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// The combo box has gotten the focus for the first time.
|
|
//
|
|
|
|
//
|
|
// First turn on the listbox caret
|
|
//
|
|
|
|
if (pcbox->CBoxStyle == SDROPDOWNLIST)
|
|
{
|
|
SendMessage(pcbox->hwndList, LBCB_CARETON, 0, 0);
|
|
}
|
|
|
|
//
|
|
// and select all the text in the editcontrol or static text rectangle.
|
|
//
|
|
|
|
if (pcbox->fNoEdit)
|
|
{
|
|
//
|
|
// Invert the static text rectangle
|
|
//
|
|
ComboBox_InvertStaticWindow(pcbox, TRUE, (HDC)NULL);
|
|
}
|
|
else if (pcbox->hwndEdit)
|
|
{
|
|
UserAssert(pcbox->hwnd);
|
|
SendMessage(pcbox->hwndEdit, EM_SETSEL, 0, MAXLONG);
|
|
}
|
|
|
|
pcbox->fFocus = TRUE;
|
|
|
|
//
|
|
// Notify the parent we have the focus
|
|
//
|
|
ComboBox_NotifyParent(pcbox, CBN_SETFOCUS);
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// ComboBox_KillFocusHandler
|
|
//
|
|
// Handles losing the focus for the combo box.
|
|
//
|
|
VOID ComboBox_KillFocusHandler(PCBOX pcbox)
|
|
{
|
|
if (!pcbox->fFocus || pcbox->hwndList == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// The combo box is losing the focus. Send buttonup clicks so that
|
|
// things release the mouse capture if they have it... If the
|
|
// pwndListBox is null, don't do anything. This occurs if the combo box
|
|
// is destroyed while it has the focus.
|
|
//
|
|
SendMessage(pcbox->hwnd, WM_LBUTTONUP, 0L, 0xFFFFFFFFL);
|
|
if (!ComboBox_HideListBoxWindow(pcbox, TRUE, FALSE))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Turn off the listbox caret
|
|
//
|
|
if (pcbox->CBoxStyle == SDROPDOWNLIST)
|
|
{
|
|
SendMessage(pcbox->hwndList, LBCB_CARETOFF, 0, 0);
|
|
}
|
|
|
|
if (pcbox->fNoEdit)
|
|
{
|
|
//
|
|
// Invert the static text rectangle
|
|
//
|
|
ComboBox_InvertStaticWindow(pcbox, FALSE, (HDC)NULL);
|
|
}
|
|
else if (pcbox->hwndEdit)
|
|
{
|
|
SendMessage(pcbox->hwndEdit, EM_SETSEL, 0, 0);
|
|
}
|
|
|
|
pcbox->fFocus = FALSE;
|
|
ComboBox_NotifyParent(pcbox, CBN_KILLFOCUS);
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// ComboBox_CommandHandler
|
|
//
|
|
// Check the various notification codes from the controls and do the
|
|
// proper thing.
|
|
// always returns 0L
|
|
//
|
|
LONG ComboBox_CommandHandler(PCBOX pcbox, DWORD wParam, HWND hwndControl)
|
|
{
|
|
//
|
|
// Check the edit control notification codes. Note that currently, edit
|
|
// controls don't send EN_KILLFOCUS messages to the parent.
|
|
//
|
|
if (!pcbox->fNoEdit && (hwndControl == pcbox->hwndEdit))
|
|
{
|
|
//
|
|
// Edit control notification codes
|
|
//
|
|
switch (HIWORD(wParam))
|
|
{
|
|
case EN_SETFOCUS:
|
|
if (!pcbox->fFocus)
|
|
{
|
|
//
|
|
// The edit control has the focus for the first time which means
|
|
// this is the first time the combo box has received the focus
|
|
// and the parent must be notified that we have the focus.
|
|
//
|
|
ComboBox_GetFocusHandler(pcbox);
|
|
}
|
|
|
|
break;
|
|
|
|
case EN_CHANGE:
|
|
ComboBox_NotifyParent(pcbox, CBN_EDITCHANGE);
|
|
ComboBox_UpdateListBoxWindow(pcbox, FALSE);
|
|
break;
|
|
|
|
case EN_UPDATE:
|
|
ComboBox_NotifyParent(pcbox, CBN_EDITUPDATE);
|
|
break;
|
|
|
|
case EN_ERRSPACE:
|
|
ComboBox_NotifyParent(pcbox, CBN_ERRSPACE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check listbox control notification codes
|
|
//
|
|
if (hwndControl == pcbox->hwndList)
|
|
{
|
|
//
|
|
// Listbox control notification codes
|
|
//
|
|
switch ((int)HIWORD(wParam))
|
|
{
|
|
case LBN_DBLCLK:
|
|
ComboBox_NotifyParent(pcbox, CBN_DBLCLK);
|
|
break;
|
|
|
|
case LBN_ERRSPACE:
|
|
ComboBox_NotifyParent(pcbox, CBN_ERRSPACE);
|
|
break;
|
|
|
|
case LBN_SELCHANGE:
|
|
case LBN_SELCANCEL:
|
|
if (!pcbox->fKeyboardSelInListBox)
|
|
{
|
|
//
|
|
// If the selchange is caused by the user keyboarding through,
|
|
// we don't want to hide the listbox.
|
|
//
|
|
if (!ComboBox_HideListBoxWindow(pcbox, TRUE, TRUE))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pcbox->fKeyboardSelInListBox = FALSE;
|
|
}
|
|
|
|
ComboBox_NotifyParent(pcbox, CBN_SELCHANGE);
|
|
ComboBox_InternalUpdateEditWindow(pcbox, NULL);
|
|
|
|
if (pcbox->fNoEdit)
|
|
{
|
|
NotifyWinEvent(EVENT_OBJECT_VALUECHANGE, pcbox->hwnd, OBJID_CLIENT, INDEX_COMBOBOX);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// ComboBox_CompleteEditWindow
|
|
//
|
|
//
|
|
// Completes the text in the edit box with the closest match from the
|
|
// listbox. If a prefix match can't be found, the edit control text isn't
|
|
// updated. Assume a DROPDOWN style combo box.
|
|
//
|
|
VOID ComboBox_CompleteEditWindow(PCBOX pcbox)
|
|
{
|
|
int cchText;
|
|
int cchItemText;
|
|
int itemNumber;
|
|
LPWSTR pText;
|
|
|
|
//
|
|
// Firstly check the edit control.
|
|
//
|
|
if (pcbox->hwndEdit == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// +1 for null terminator
|
|
//
|
|
cchText = (int)SendMessage(pcbox->hwndEdit, WM_GETTEXTLENGTH, 0, 0);
|
|
|
|
if (cchText)
|
|
{
|
|
cchText++;
|
|
pText = (LPWSTR)UserLocalAlloc(HEAP_ZERO_MEMORY, cchText*sizeof(WCHAR));
|
|
if (!pText)
|
|
{
|
|
goto Unlock;
|
|
}
|
|
|
|
//
|
|
// We want to be sure to free the above allocated memory even if
|
|
// the client dies during callback (xxx) or some of the following
|
|
// window revalidation fails.
|
|
//
|
|
try
|
|
{
|
|
SendMessage(pcbox->hwndEdit, WM_GETTEXT, cchText, (LPARAM)pText);
|
|
itemNumber = (int)SendMessage(pcbox->hwndList,
|
|
LB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)pText);
|
|
|
|
if (itemNumber == -1)
|
|
{
|
|
itemNumber = (int)SendMessage(pcbox->hwndList,
|
|
LB_FINDSTRING, (WPARAM)-1, (LPARAM)pText);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
UserLocalFree((HANDLE)pText);
|
|
}
|
|
|
|
if (itemNumber == -1)
|
|
{
|
|
//
|
|
// No close match. Blow off.
|
|
//
|
|
goto Unlock;
|
|
}
|
|
|
|
cchItemText = (int)SendMessage(pcbox->hwndList, LB_GETTEXTLEN,
|
|
itemNumber, 0);
|
|
if (cchItemText)
|
|
{
|
|
cchItemText++;
|
|
pText = (LPWSTR)UserLocalAlloc(HEAP_ZERO_MEMORY, cchItemText*sizeof(WCHAR));
|
|
if (!pText)
|
|
{
|
|
goto Unlock;
|
|
}
|
|
|
|
//
|
|
// We want to be sure to free the above allocated memory even if
|
|
// the client dies during callback (xxx) or some of the following
|
|
// window revalidation fails.
|
|
//
|
|
try
|
|
{
|
|
SendMessage(pcbox->hwndList, LB_GETTEXT, itemNumber, (LPARAM)pText);
|
|
SendMessage(pcbox->hwndEdit, WM_SETTEXT, 0, (LPARAM)pText);
|
|
}
|
|
finally
|
|
{
|
|
UserLocalFree((HANDLE)pText);
|
|
}
|
|
|
|
SendMessage(pcbox->hwndEdit, EM_SETSEL, 0, MAXLONG);
|
|
}
|
|
}
|
|
|
|
Unlock:
|
|
return;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// ComboBox_HideListBoxWindow
|
|
//
|
|
// Hides the dropdown listbox window if it is a dropdown style.
|
|
//
|
|
BOOL ComboBox_HideListBoxWindow(PCBOX pcbox, BOOL fNotifyParent, BOOL fSelEndOK)
|
|
{
|
|
HWND hwnd = pcbox->hwnd;
|
|
HWND hwndList = pcbox->hwndList;
|
|
|
|
//
|
|
// For 3.1+ apps, send CBN_SELENDOK to all types of comboboxes but only
|
|
// allow CBN_SELENDCANCEL to be sent for droppable comboboxes
|
|
//
|
|
if (fNotifyParent && TESTFLAG(GET_STATE2(pcbox), WS_S2_WIN31COMPAT) &&
|
|
((pcbox->CBoxStyle & SDROPPABLE) || fSelEndOK))
|
|
{
|
|
if (fSelEndOK)
|
|
{
|
|
ComboBox_NotifyParent(pcbox, CBN_SELENDOK);
|
|
}
|
|
else
|
|
{
|
|
ComboBox_NotifyParent(pcbox, CBN_SELENDCANCEL);
|
|
}
|
|
|
|
if (!IsWindow(hwnd))
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// return, we don't hide simple combo boxes.
|
|
//
|
|
if (!(pcbox->CBoxStyle & SDROPPABLE))
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Send a faked buttonup message to the listbox so that it can release
|
|
// the capture and all.
|
|
//
|
|
SendMessage(pcbox->hwndList, LBCB_ENDTRACK, fSelEndOK, 0);
|
|
|
|
if (pcbox->fLBoxVisible)
|
|
{
|
|
WORD swpFlags = SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE;
|
|
|
|
if (!TESTFLAG(GET_STATE2(pcbox), WS_S2_WIN31COMPAT))
|
|
{
|
|
swpFlags |= SWP_FRAMECHANGED;
|
|
}
|
|
|
|
pcbox->fLBoxVisible = FALSE;
|
|
|
|
//
|
|
// Hide the listbox window
|
|
//
|
|
ShowWindow(hwndList, SW_HIDE);
|
|
|
|
//
|
|
// Invalidate the item area now since SWP() might update stuff.
|
|
// Since the combo is CS_VREDRAW/CS_HREDRAW, a size change will
|
|
// redraw the whole thing, including the item rect. But if it
|
|
// isn't changing size, we still want to redraw the item anyway
|
|
// to show focus/selection.
|
|
//
|
|
if (!(pcbox->CBoxStyle & SEDITABLE))
|
|
{
|
|
InvalidateRect(hwnd, &pcbox->editrc, TRUE);
|
|
}
|
|
|
|
SetWindowPos(hwnd, HWND_TOP, 0, 0,
|
|
pcbox->cxCombo, pcbox->cyCombo, swpFlags);
|
|
|
|
//
|
|
// In case size didn't change
|
|
//
|
|
UpdateWindow(hwnd);
|
|
|
|
if (pcbox->CBoxStyle & SEDITABLE)
|
|
{
|
|
ComboBox_CompleteEditWindow(pcbox);
|
|
}
|
|
|
|
if (fNotifyParent)
|
|
{
|
|
//
|
|
// Notify parent we will be popping up the combo box.
|
|
//
|
|
ComboBox_NotifyParent(pcbox, CBN_CLOSEUP);
|
|
|
|
if (!IsWindow(hwnd))
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// ComboBox_ShowListBoxWindow
|
|
//
|
|
// Lowers the dropdown listbox window.
|
|
//
|
|
VOID ComboBox_ShowListBoxWindow(PCBOX pcbox, BOOL fTrack)
|
|
{
|
|
RECT editrc;
|
|
RECT rcWindow;
|
|
RECT rcList;
|
|
int itemNumber;
|
|
int iHeight;
|
|
int yTop;
|
|
DWORD dwMult;
|
|
int cyItem;
|
|
HWND hwnd = pcbox->hwnd;
|
|
HWND hwndList = pcbox->hwndList;
|
|
BOOL fAnimPos;
|
|
HMONITOR hMonitor;
|
|
MONITORINFO mi = {0};
|
|
BOOL bCBAnim = FALSE;
|
|
|
|
//
|
|
// This function is only called for droppable list comboboxes
|
|
//
|
|
UserAssert(pcbox->CBoxStyle & SDROPPABLE);
|
|
|
|
//
|
|
// Notify parent we will be dropping down the combo box.
|
|
//
|
|
ComboBox_NotifyParent(pcbox, CBN_DROPDOWN);
|
|
|
|
//
|
|
// Invalidate the button rect so that the depressed arrow is drawn.
|
|
//
|
|
InvalidateRect(hwnd, &pcbox->buttonrc, TRUE);
|
|
|
|
pcbox->fLBoxVisible = TRUE;
|
|
|
|
if (pcbox->CBoxStyle == SDROPDOWN)
|
|
{
|
|
//
|
|
// If an item in the listbox matches the text in the edit control,
|
|
// scroll it to the top of the listbox. Select the item only if the
|
|
// mouse button isn't down otherwise we will select the item when the
|
|
// mouse button goes up.
|
|
//
|
|
ComboBox_UpdateListBoxWindow(pcbox, !pcbox->fMouseDown);
|
|
|
|
if (!pcbox->fMouseDown)
|
|
{
|
|
ComboBox_CompleteEditWindow(pcbox);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Scroll the currently selected item to the top of the listbox.
|
|
//
|
|
itemNumber = (int)SendMessage(pcbox->hwndList, LB_GETCURSEL, 0, 0);
|
|
if (itemNumber == -1)
|
|
{
|
|
itemNumber = 0;
|
|
}
|
|
|
|
SendMessage(pcbox->hwndList, LB_SETTOPINDEX, itemNumber, 0);
|
|
SendMessage(pcbox->hwndList, LBCB_CARETON, 0, 0);
|
|
|
|
//
|
|
// We need to invalidate the edit rect so that the focus frame/invert
|
|
// will be turned off when the listbox is visible. Tandy wants this for
|
|
// his typical reasons...
|
|
//
|
|
InvalidateRect(hwnd, &pcbox->editrc, TRUE);
|
|
}
|
|
|
|
//
|
|
// Figure out where to position the dropdown listbox. We want it just
|
|
// touching the edge around the edit rectangle. Note that since the
|
|
// listbox is a popup, we need the position in screen coordinates.
|
|
//
|
|
|
|
//
|
|
// We want the dropdown to pop below or above the combo
|
|
//
|
|
|
|
//
|
|
// Get screen coords
|
|
//
|
|
GetWindowRect(pcbox->hwnd, &rcWindow);
|
|
editrc.left = rcWindow.left;
|
|
editrc.top = rcWindow.top;
|
|
editrc.right = rcWindow.left + pcbox->cxCombo;
|
|
editrc.bottom = rcWindow.top + pcbox->cyCombo;
|
|
|
|
//
|
|
// List area
|
|
//
|
|
cyItem = (int)SendMessage(pcbox->hwndList, LB_GETITEMHEIGHT, 0, 0);
|
|
|
|
if (cyItem == 0)
|
|
{
|
|
//
|
|
// Make sure that it's not 0
|
|
//
|
|
TraceMsg(TF_STANDARD, "UxCombobox: LB_GETITEMHEIGHT is returning 0" );
|
|
cyItem = SYSFONT_CYCHAR;
|
|
}
|
|
|
|
//
|
|
// we shoulda' just been able to use cyDrop here, but thanks to VB's need
|
|
// to do things their OWN SPECIAL WAY, we have to keep monitoring the size
|
|
// of the listbox 'cause VB changes it directly (jeffbog 03/21/94)
|
|
//
|
|
GetWindowRect(pcbox->hwndList, &rcList);
|
|
iHeight = max(pcbox->cyDrop, rcList.bottom - rcList.top);
|
|
|
|
if (dwMult = (DWORD)SendMessage(pcbox->hwndList, LB_GETCOUNT, 0, 0))
|
|
{
|
|
dwMult = (DWORD)(LOWORD(dwMult) * cyItem);
|
|
dwMult += GetSystemMetrics(SM_CYEDGE);
|
|
|
|
if (dwMult < 0x7FFF)
|
|
{
|
|
iHeight = min(LOWORD(dwMult), iHeight);
|
|
}
|
|
}
|
|
|
|
if (!GET_STYLE(pcbox) & CBS_NOINTEGRALHEIGHT)
|
|
{
|
|
UserAssert(cyItem);
|
|
iHeight = ((iHeight - GetSystemMetrics(SM_CYEDGE)) / cyItem) * cyItem + GetSystemMetrics(SM_CYEDGE);
|
|
}
|
|
|
|
//
|
|
// Other 1/2 of old app combo fix. Make dropdown overlap combo window
|
|
// a little. That way we can have a chance of invalidating the overlap
|
|
// and causing a repaint to help out Publisher 2.0's toolbar combos.
|
|
// See comments for PressButton() above.
|
|
//
|
|
hMonitor = MonitorFromWindow(pcbox->hwnd, MONITOR_DEFAULTTOPRIMARY);
|
|
mi.cbSize = sizeof(mi);
|
|
GetMonitorInfo(hMonitor, &mi);
|
|
if (editrc.bottom + iHeight <= mi.rcMonitor.bottom)
|
|
{
|
|
yTop = editrc.bottom;
|
|
if (!pcbox->f3DCombo)
|
|
{
|
|
yTop -= GetSystemMetrics(SM_CYBORDER);
|
|
}
|
|
|
|
fAnimPos = TRUE;
|
|
}
|
|
else
|
|
{
|
|
yTop = max(editrc.top - iHeight, mi.rcMonitor.top);
|
|
if (!pcbox->f3DCombo)
|
|
{
|
|
yTop += GetSystemMetrics(SM_CYBORDER);
|
|
}
|
|
|
|
fAnimPos = FALSE;
|
|
}
|
|
|
|
if (!TESTFLAG(GET_STATE2(pcbox), WS_S2_WIN40COMPAT))
|
|
{
|
|
//
|
|
// fix for Winword B#7504, Combo-ListBox text gets
|
|
// truncated by a small width, this is do to us
|
|
// now setting size here in SetWindowPos, rather than
|
|
// earlier where we did this in Win3.1
|
|
//
|
|
|
|
GetWindowRect(pcbox->hwndList, &rcList);
|
|
if ((rcList.right - rcList.left ) > pcbox->cxDrop)
|
|
{
|
|
pcbox->cxDrop = rcList.right - rcList.left;
|
|
}
|
|
}
|
|
|
|
if (!TESTFLAG(GET_EXSTYLE(pcbox), WS_EX_LAYOUTRTL))
|
|
{
|
|
SetWindowPos(hwndList, HWND_TOPMOST, editrc.left,
|
|
yTop, max(pcbox->cxDrop, pcbox->cxCombo), iHeight, SWP_NOACTIVATE);
|
|
}
|
|
else
|
|
{
|
|
int cx = max(pcbox->cxDrop, pcbox->cxCombo);
|
|
|
|
SetWindowPos(hwndList, HWND_TOPMOST, editrc.right - cx,
|
|
yTop, cx, iHeight, SWP_NOACTIVATE);
|
|
}
|
|
|
|
//
|
|
// Get any drawing in the combo box window out of the way so it doesn't
|
|
// invalidate any of the SPB underneath the list window.
|
|
//
|
|
UpdateWindow(hwnd);
|
|
|
|
SystemParametersInfo(SPI_GETCOMBOBOXANIMATION, 0, (LPVOID)&bCBAnim, 0);
|
|
if (!bCBAnim)
|
|
{
|
|
ShowWindow(hwndList, SW_SHOWNA);
|
|
}
|
|
else
|
|
{
|
|
AnimateWindow(hwndList, CMS_QANIMATION, (fAnimPos ? AW_VER_POSITIVE :
|
|
AW_VER_NEGATIVE) | AW_SLIDE);
|
|
}
|
|
|
|
//
|
|
// Restart search buffer from first char
|
|
//
|
|
{
|
|
PLBIV plb = ListBox_GetPtr(pcbox->hwndList);
|
|
|
|
if ((plb != NULL) && (plb != (PLBIV)-1))
|
|
{
|
|
plb->iTypeSearch = 0;
|
|
}
|
|
}
|
|
|
|
if (fTrack && TESTFLAG(GET_STATE2(pcbox), WS_S2_WIN40COMPAT))
|
|
{
|
|
SendMessage(pcbox->hwndList, LBCB_STARTTRACK, FALSE, 0);
|
|
}
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// ComboBox_InternalUpdateEditWindow
|
|
//
|
|
// Updates the editcontrol/statictext window so that it contains the text
|
|
// given by the current selection in the listbox. If the listbox has no
|
|
// selection (ie. -1), then we erase all the text in the editcontrol.
|
|
//
|
|
// hdcPaint is from WM_PAINT messages Begin/End Paint hdc. If null, we should
|
|
// get our own dc.
|
|
//
|
|
VOID ComboBox_InternalUpdateEditWindow(PCBOX pcbox, HDC hdcPaint)
|
|
{
|
|
int cchText = 0;
|
|
LPWSTR pText = NULL;
|
|
int sItem;
|
|
HDC hdc;
|
|
UINT msg;
|
|
HBRUSH hbrSave;
|
|
HBRUSH hbrControl;
|
|
HANDLE hOldFont;
|
|
DRAWITEMSTRUCT dis;
|
|
RECT rc;
|
|
HWND hwnd = pcbox->hwnd;
|
|
|
|
sItem = (int)SendMessage(pcbox->hwndList, LB_GETCURSEL, 0, 0);
|
|
|
|
//
|
|
// This 'try-finally' block ensures that the allocated 'pText' will
|
|
// be freed no matter how this routine is exited.
|
|
//
|
|
try
|
|
{
|
|
if (sItem != -1)
|
|
{
|
|
cchText = (int)SendMessage(pcbox->hwndList, LB_GETTEXTLEN, (DWORD)sItem, 0);
|
|
pText = (LPWSTR)UserLocalAlloc(HEAP_ZERO_MEMORY, (cchText+1) * sizeof(WCHAR));
|
|
if (pText)
|
|
{
|
|
cchText = (int)SendMessage(pcbox->hwndList, LB_GETTEXT,
|
|
(DWORD)sItem, (LPARAM)pText);
|
|
}
|
|
else
|
|
{
|
|
cchText = 0;
|
|
}
|
|
}
|
|
|
|
if (!pcbox->fNoEdit)
|
|
{
|
|
if (pcbox->hwndEdit)
|
|
{
|
|
if (GET_STYLE(pcbox) & CBS_HASSTRINGS)
|
|
{
|
|
SetWindowText(pcbox->hwndEdit, pText ? pText : TEXT(""));
|
|
}
|
|
|
|
if (pcbox->fFocus)
|
|
{
|
|
//
|
|
// Only hilite the text if we have the focus.
|
|
//
|
|
SendMessage(pcbox->hwndEdit, EM_SETSEL, 0, MAXLONG);
|
|
}
|
|
}
|
|
}
|
|
else if (IsComboVisible(pcbox))
|
|
{
|
|
if (hdcPaint)
|
|
{
|
|
hdc = hdcPaint;
|
|
}
|
|
else
|
|
{
|
|
hdc = GetDC(hwnd);
|
|
}
|
|
|
|
SetBkMode(hdc, OPAQUE);
|
|
if (TESTFLAG(GET_STATE2(pcbox), WS_S2_WIN40COMPAT))
|
|
{
|
|
if (TESTFLAG(GET_STYLE(pcbox), WS_DISABLED))
|
|
{
|
|
msg = WM_CTLCOLORSTATIC;
|
|
}
|
|
else
|
|
{
|
|
msg = WM_CTLCOLOREDIT;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
msg = WM_CTLCOLORLISTBOX;
|
|
}
|
|
|
|
hbrControl = (HBRUSH)SendMessage(GetParent(hwnd), msg, (WPARAM)hdc, (LPARAM)hwnd);
|
|
hbrSave = SelectObject(hdc, hbrControl);
|
|
|
|
CopyRect(&rc, &pcbox->editrc);
|
|
InflateRect(&rc, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
|
|
PatBlt(hdc, rc.left, rc.top, rc.right - rc.left,
|
|
rc.bottom - rc.top, PATCOPY);
|
|
InflateRect(&rc, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
|
|
|
|
if (pcbox->fFocus && !pcbox->fLBoxVisible)
|
|
{
|
|
//
|
|
// Fill in the selected area
|
|
//
|
|
|
|
//
|
|
// only do the FillRect if we know its not
|
|
// ownerdraw item, otherwise we mess up people up
|
|
// BUT: for Compat's sake we still do this for Win 3.1 guys
|
|
//
|
|
if (!TESTFLAG(GET_STATE2(pcbox), WS_S2_WIN40COMPAT) || !pcbox->OwnerDraw)
|
|
{
|
|
FillRect(hdc, &rc, GetSysColorBrush(COLOR_HIGHLIGHT));
|
|
}
|
|
|
|
SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
|
|
SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
|
|
}
|
|
else if (TESTFLAG(GET_STYLE(pcbox), WS_DISABLED) && !pcbox->OwnerDraw)
|
|
{
|
|
if ((COLORREF)GetSysColor(COLOR_GRAYTEXT) != GetBkColor(hdc))
|
|
{
|
|
SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
|
|
}
|
|
}
|
|
|
|
if (pcbox->hFont != NULL)
|
|
{
|
|
hOldFont = SelectObject(hdc, pcbox->hFont);
|
|
}
|
|
|
|
if (pcbox->OwnerDraw)
|
|
{
|
|
//
|
|
// Let the app draw the stuff in the static text box.
|
|
//
|
|
dis.CtlType = ODT_COMBOBOX;
|
|
dis.CtlID = GetWindowID(pcbox->hwnd);
|
|
dis.itemID = sItem;
|
|
dis.itemAction = ODA_DRAWENTIRE;
|
|
dis.itemState = (UINT)
|
|
((pcbox->fFocus && !pcbox->fLBoxVisible ? ODS_SELECTED : 0) |
|
|
(TESTFLAG(GET_STYLE(pcbox), WS_DISABLED) ? ODS_DISABLED : 0) |
|
|
(pcbox->fFocus && !pcbox->fLBoxVisible ? ODS_FOCUS : 0) |
|
|
(TESTFLAG(GET_STATE2(pcbox), WS_S2_WIN40COMPAT) ? ODS_COMBOBOXEDIT : 0) |
|
|
(TESTFLAG(GET_EXSTYLE(pcbox), WS_EXP_UIFOCUSHIDDEN) ? ODS_NOFOCUSRECT : 0) |
|
|
(TESTFLAG(GET_EXSTYLE(pcbox), WS_EXP_UIACCELHIDDEN) ? ODS_NOACCEL : 0));
|
|
|
|
dis.hwndItem = hwnd;
|
|
dis.hDC = hdc;
|
|
CopyRect(&dis.rcItem, &rc);
|
|
|
|
//
|
|
// Don't let ownerdraw dudes draw outside of the combo client
|
|
// bounds.
|
|
//
|
|
IntersectClipRect(hdc, rc.left, rc.top, rc.right, rc.bottom);
|
|
|
|
dis.itemData = (ULONG_PTR)SendMessage(pcbox->hwndList,
|
|
LB_GETITEMDATA, (UINT)sItem, 0);
|
|
|
|
SendMessage(pcbox->hwndParent, WM_DRAWITEM, dis.CtlID, (LPARAM)&dis);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Start the text one pixel within the rect so that we leave a
|
|
// nice hilite border around the text.
|
|
//
|
|
|
|
int x;
|
|
UINT align;
|
|
|
|
if (pcbox->fRightAlign )
|
|
{
|
|
align = TA_RIGHT;
|
|
x = rc.right - GetSystemMetrics(SM_CXBORDER);
|
|
}
|
|
else
|
|
{
|
|
x = rc.left + GetSystemMetrics(SM_CXBORDER);
|
|
align = 0;
|
|
}
|
|
|
|
if (pcbox->fRtoLReading)
|
|
{
|
|
align |= TA_RTLREADING;
|
|
}
|
|
|
|
if (align)
|
|
{
|
|
SetTextAlign(hdc, GetTextAlign(hdc) | align);
|
|
}
|
|
|
|
//
|
|
// Draw the text, leaving a gap on the left & top for selection.
|
|
//
|
|
ExtTextOut(hdc, x, rc.top + GetSystemMetrics(SM_CYBORDER), ETO_CLIPPED | ETO_OPAQUE,
|
|
&rc, pText ? pText : TEXT(""), cchText, NULL);
|
|
if (pcbox->fFocus && !pcbox->fLBoxVisible)
|
|
{
|
|
if (!TESTFLAG(GET_EXSTYLE(pcbox), WS_EXP_UIFOCUSHIDDEN))
|
|
{
|
|
DrawFocusRect(hdc, &rc);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pcbox->hFont && hOldFont)
|
|
{
|
|
SelectObject(hdc, hOldFont);
|
|
}
|
|
|
|
if (hbrSave)
|
|
{
|
|
SelectObject(hdc, hbrSave);
|
|
}
|
|
|
|
if (!hdcPaint)
|
|
{
|
|
ReleaseDC(hwnd, hdc);
|
|
}
|
|
}
|
|
|
|
}
|
|
finally
|
|
{
|
|
if (pText != NULL)
|
|
{
|
|
UserLocalFree((HANDLE)pText);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// ComboBox_GetTextLengthHandler
|
|
//
|
|
// For the combo box without an edit control, returns size of current selected
|
|
// item
|
|
//
|
|
LONG ComboBox_GetTextLengthHandler(PCBOX pcbox)
|
|
{
|
|
int item;
|
|
int cchText;
|
|
|
|
item = (int)SendMessage(pcbox->hwndList, LB_GETCURSEL, 0, 0);
|
|
|
|
if (item == LB_ERR)
|
|
{
|
|
//
|
|
// No selection so no text.
|
|
//
|
|
cchText = 0;
|
|
}
|
|
else
|
|
{
|
|
cchText = (int)SendMessage(pcbox->hwndList, LB_GETTEXTLEN, item, 0);
|
|
}
|
|
|
|
return cchText;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// ComboBox_GetTextHandler
|
|
//
|
|
// For the combo box without an edit control, copies cbString bytes of the
|
|
// string in the static text box to the buffer given by lpszString.
|
|
//
|
|
LONG ComboBox_GetTextHandler(PCBOX pcbox, int cchString, LPWSTR lpszString)
|
|
{
|
|
int item;
|
|
int cchText;
|
|
LPWSTR lpszBuffer;
|
|
DWORD dw;
|
|
|
|
if (!cchString || !lpszString)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Null the buffer to be nice.
|
|
//
|
|
*lpszString = 0;
|
|
|
|
item = (int)SendMessage(pcbox->hwndList, LB_GETCURSEL, 0, 0);
|
|
|
|
if (item == LB_ERR)
|
|
{
|
|
//
|
|
// No selection so no text.
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
cchText = (int)SendMessage(pcbox->hwndList, LB_GETTEXTLEN, item, 0);
|
|
|
|
cchText++;
|
|
if ((cchText <= cchString) ||
|
|
(!TESTFLAG(GET_STATE2(pcbox), WS_S2_WIN31COMPAT) && cchString == 2))
|
|
{
|
|
//
|
|
// Just do the copy if the given buffer size is large enough to hold
|
|
// everything. Or if old 3.0 app. (Norton used to pass 2 & expect 3
|
|
// chars including the \0 in 3.0; Bug #7018 win31: vatsanp)
|
|
//
|
|
dw = (int)SendMessage(pcbox->hwndList, LB_GETTEXT, item,
|
|
(LPARAM)lpszString);
|
|
return dw;
|
|
}
|
|
|
|
lpszBuffer = (LPWSTR)UserLocalAlloc(HEAP_ZERO_MEMORY, cchText*sizeof(WCHAR));
|
|
if (!lpszBuffer)
|
|
{
|
|
//
|
|
// Bail. Not enough memory to chop up the text.
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
try
|
|
{
|
|
SendMessage(pcbox->hwndList, LB_GETTEXT, item, (LPARAM)lpszBuffer);
|
|
RtlCopyMemory((PBYTE)lpszString, (PBYTE)lpszBuffer, cchString * sizeof(WCHAR));
|
|
lpszString[cchString - 1] = 0;
|
|
}
|
|
finally
|
|
{
|
|
UserLocalFree((HANDLE)lpszBuffer);
|
|
}
|
|
|
|
return cchString;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
// ComboBox_GetInfo
|
|
//
|
|
// return information about this combobox to the caller
|
|
// in the ComboBoxInfo struct
|
|
//
|
|
BOOL ComboBox_GetInfo(PCBOX pcbox, PCOMBOBOXINFO pcbi)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
|
|
if (!pcbi || pcbi->cbSize != sizeof(COMBOBOXINFO))
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// populate the structure
|
|
//
|
|
pcbi->hwndCombo = pcbox->hwnd;
|
|
pcbi->hwndItem = pcbox->hwndEdit;
|
|
pcbi->hwndList = pcbox->hwndList;
|
|
|
|
pcbi->rcItem = pcbox->editrc;
|
|
pcbi->rcButton = pcbox->buttonrc;
|
|
|
|
pcbi->stateButton = 0;
|
|
if (pcbox->CBoxStyle == CBS_SIMPLE)
|
|
{
|
|
pcbi->stateButton |= STATE_SYSTEM_INVISIBLE;
|
|
}
|
|
if (pcbox->fButtonPressed)
|
|
{
|
|
pcbi->stateButton |= STATE_SYSTEM_PRESSED;
|
|
}
|
|
|
|
bRet = TRUE;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------//
|
|
//
|
|
// ComboBox_WndProc
|
|
//
|
|
// WndProc for comboboxes.
|
|
//
|
|
LRESULT WINAPI ComboBox_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
PCBOX pcbox;
|
|
POINT pt;
|
|
LPWSTR lpwsz = NULL;
|
|
LRESULT lReturn = TRUE;
|
|
static BOOL fInit = TRUE;
|
|
INT i;
|
|
RECT rcCombo;
|
|
RECT rcList;
|
|
RECT rcWindow;
|
|
|
|
//
|
|
// Get the instance data for this combobox control
|
|
//
|
|
pcbox = ComboBox_GetPtr(hwnd);
|
|
if (!pcbox && uMsg != WM_NCCREATE)
|
|
{
|
|
goto CallDWP;
|
|
}
|
|
|
|
//
|
|
// Protect the combobox during the initialization.
|
|
//
|
|
if (!pcbox || pcbox->hwndList == NULL)
|
|
{
|
|
if (!ComboBox_MsgOKInit(uMsg, &lReturn))
|
|
{
|
|
TraceMsg(TF_STANDARD, "UxCombobox: ComboBoxWndProcWorker: msg=%04x is sent to hwnd=%08x in the middle of initialization.",
|
|
uMsg, hwnd);
|
|
return lReturn;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Dispatch the various messages we can receive
|
|
//
|
|
switch (uMsg)
|
|
{
|
|
case CBEC_KILLCOMBOFOCUS:
|
|
|
|
//
|
|
// Private message coming from editcontrol informing us that the combo
|
|
// box is losing the focus to a window which isn't in this combo box.
|
|
//
|
|
ComboBox_KillFocusHandler(pcbox);
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
|
|
//
|
|
// So that we can handle notification messages from the listbox and
|
|
// edit control.
|
|
//
|
|
return ComboBox_CommandHandler(pcbox, (DWORD)wParam, (HWND)lParam);
|
|
|
|
case WM_STYLECHANGED:
|
|
{
|
|
LONG OldStyle;
|
|
LONG NewStyle = 0;
|
|
|
|
UserAssert(pcbox->hwndList != NULL);
|
|
|
|
pcbox->fRtoLReading = TESTFLAG(GET_EXSTYLE(pcbox), WS_EX_RTLREADING);
|
|
pcbox->fRightAlign = TESTFLAG(GET_EXSTYLE(pcbox), WS_EX_RIGHT);
|
|
|
|
if (pcbox->fRtoLReading)
|
|
{
|
|
NewStyle |= (WS_EX_RTLREADING | WS_EX_LEFTSCROLLBAR);
|
|
}
|
|
|
|
if (pcbox->fRightAlign)
|
|
{
|
|
NewStyle |= WS_EX_RIGHT;
|
|
}
|
|
|
|
OldStyle = GetWindowExStyle(pcbox->hwndList) & ~(WS_EX_RIGHT|WS_EX_RTLREADING|WS_EX_LEFTSCROLLBAR);
|
|
SetWindowLong(pcbox->hwndList, GWL_EXSTYLE, OldStyle|NewStyle);
|
|
|
|
if (!pcbox->fNoEdit && pcbox->hwndEdit)
|
|
{
|
|
OldStyle = GetWindowExStyle(pcbox->hwndEdit) & ~(WS_EX_RIGHT|WS_EX_RTLREADING|WS_EX_LEFTSCROLLBAR);
|
|
SetWindowLong(pcbox->hwndEdit, GWL_EXSTYLE, OldStyle|NewStyle);
|
|
}
|
|
|
|
ComboBox_Position(pcbox);
|
|
InvalidateRect(hwnd, NULL, FALSE);
|
|
|
|
break;
|
|
}
|
|
case WM_CTLCOLORMSGBOX:
|
|
case WM_CTLCOLOREDIT:
|
|
case WM_CTLCOLORLISTBOX:
|
|
case WM_CTLCOLORBTN:
|
|
case WM_CTLCOLORDLG:
|
|
case WM_CTLCOLORSCROLLBAR:
|
|
case WM_CTLCOLORSTATIC:
|
|
case WM_CTLCOLOR:
|
|
//
|
|
// Causes compatibility problems for 3.X apps. Forward only
|
|
// for 4.0
|
|
//
|
|
if (TESTFLAG(GET_STATE2(pcbox), WS_S2_WIN40COMPAT))
|
|
{
|
|
LRESULT ret;
|
|
|
|
ret = SendMessage(pcbox->hwndParent, uMsg, wParam, lParam);
|
|
return ret;
|
|
}
|
|
else
|
|
{
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_GETTEXT:
|
|
if (pcbox->fNoEdit)
|
|
{
|
|
return ComboBox_GetTextHandler(pcbox, (int)wParam, (LPWSTR)lParam);
|
|
}
|
|
|
|
goto CallEditSendMessage;
|
|
|
|
break;
|
|
|
|
case WM_GETTEXTLENGTH:
|
|
|
|
//
|
|
// If the is not edit control, CBS_DROPDOWNLIST, then we have to
|
|
// ask the list box for the size
|
|
//
|
|
|
|
if (pcbox->fNoEdit)
|
|
{
|
|
return ComboBox_GetTextLengthHandler(pcbox);
|
|
}
|
|
|
|
// FALL THROUGH
|
|
|
|
case WM_CLEAR:
|
|
case WM_CUT:
|
|
case WM_PASTE:
|
|
case WM_COPY:
|
|
case WM_SETTEXT:
|
|
goto CallEditSendMessage;
|
|
break;
|
|
|
|
case WM_CREATE:
|
|
|
|
//
|
|
// wParam - not used
|
|
// lParam - Points to the CREATESTRUCT data structure for the window.
|
|
//
|
|
return ComboBox_CreateHandler(pcbox, hwnd);
|
|
|
|
case WM_ERASEBKGND:
|
|
|
|
//
|
|
// Just return 1L so that the background isn't erased
|
|
//
|
|
return 1L;
|
|
|
|
case WM_GETFONT:
|
|
return (LRESULT)pcbox->hFont;
|
|
|
|
case WM_PRINT:
|
|
if (!DefWindowProc(hwnd, uMsg, wParam, lParam))
|
|
return FALSE;
|
|
|
|
if ( (lParam & PRF_OWNED) &&
|
|
(pcbox->CBoxStyle & SDROPPABLE) &&
|
|
IsWindowVisible(pcbox->hwndList) )
|
|
{
|
|
INT iDC = SaveDC((HDC) wParam);
|
|
|
|
GetWindowRect(hwnd, &rcCombo);
|
|
GetWindowRect(pcbox->hwndList, &rcList);
|
|
|
|
OffsetWindowOrgEx((HDC) wParam, 0, rcCombo.top - rcList.top, NULL);
|
|
|
|
lParam &= ~PRF_CHECKVISIBLE;
|
|
SendMessage(pcbox->hwndList, WM_PRINT, wParam, lParam);
|
|
RestoreDC((HDC) wParam, iDC);
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
case WM_PRINTCLIENT:
|
|
ComboBox_Paint(pcbox, (HDC) wParam);
|
|
break;
|
|
|
|
case WM_PAINT:
|
|
{
|
|
HDC hdc;
|
|
PAINTSTRUCT ps;
|
|
|
|
//
|
|
// wParam - perhaps a hdc
|
|
//
|
|
hdc = (wParam) ? (HDC) wParam : BeginPaint(hwnd, &ps);
|
|
|
|
if (IsComboVisible(pcbox))
|
|
{
|
|
ComboBox_Paint(pcbox, hdc);
|
|
}
|
|
|
|
if (!wParam)
|
|
{
|
|
EndPaint(hwnd, &ps);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case WM_GETDLGCODE:
|
|
//
|
|
// wParam - not used
|
|
// lParam - not used
|
|
//
|
|
{
|
|
LRESULT code = DLGC_WANTCHARS | DLGC_WANTARROWS;
|
|
|
|
//
|
|
// If the listbox is dropped and the ENTER key is pressed,
|
|
// we want this message so we can close up the listbox
|
|
//
|
|
if ((lParam != 0) &&
|
|
(((LPMSG)lParam)->message == WM_KEYDOWN) &&
|
|
pcbox->fLBoxVisible &&
|
|
((wParam == VK_RETURN) || (wParam == VK_ESCAPE)))
|
|
{
|
|
code |= DLGC_WANTMESSAGE;
|
|
}
|
|
|
|
return code;
|
|
}
|
|
|
|
case WM_SETFONT:
|
|
ComboBox_SetFontHandler(pcbox, (HANDLE)wParam, LOWORD(lParam));
|
|
break;
|
|
|
|
case WM_SYSKEYDOWN:
|
|
//
|
|
// Check if the alt key is down
|
|
//
|
|
if (lParam & 0x20000000L)
|
|
{
|
|
//
|
|
// Handle Combobox support. We want alt up or down arrow to behave
|
|
// like F4 key which completes the combo box selection
|
|
//
|
|
if (lParam & 0x1000000)
|
|
{
|
|
//
|
|
// This is an extended key such as the arrow keys not on the
|
|
// numeric keypad so just drop the combobox.
|
|
//
|
|
if (wParam == VK_DOWN || wParam == VK_UP)
|
|
{
|
|
goto DropCombo;
|
|
}
|
|
|
|
goto CallDWP;
|
|
}
|
|
|
|
if (GetKeyState(VK_NUMLOCK) & 0x1)
|
|
{
|
|
//
|
|
// If numlock down, just send all system keys to dwp
|
|
//
|
|
goto CallDWP;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We just want to ignore keys on the number pad...
|
|
//
|
|
if (!(wParam == VK_DOWN || wParam == VK_UP))
|
|
{
|
|
goto CallDWP;
|
|
}
|
|
}
|
|
DropCombo:
|
|
if (!pcbox->fLBoxVisible)
|
|
{
|
|
//
|
|
// If the listbox isn't visible, just show it
|
|
//
|
|
ComboBox_ShowListBoxWindow(pcbox, TRUE);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Ok, the listbox is visible. So hide the listbox window.
|
|
//
|
|
if (!ComboBox_HideListBoxWindow(pcbox, TRUE, TRUE))
|
|
{
|
|
return 0L;
|
|
}
|
|
}
|
|
}
|
|
goto CallDWP;
|
|
break;
|
|
|
|
case WM_KEYDOWN:
|
|
//
|
|
// If the listbox is dropped and the ENTER key is pressed,
|
|
// close up the listbox successfully. If ESCAPE is pressed,
|
|
// close it up like cancel.
|
|
//
|
|
if (pcbox->fLBoxVisible)
|
|
{
|
|
if ((wParam == VK_RETURN) || (wParam == VK_ESCAPE))
|
|
{
|
|
ComboBox_HideListBoxWindow(pcbox, TRUE, (wParam != VK_ESCAPE));
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// FALL THROUGH
|
|
//
|
|
|
|
case WM_CHAR:
|
|
if (g_fDBCSEnabled && IsDBCSLeadByte((BYTE)wParam))
|
|
{
|
|
return ComboBox_DBCharHandler(pcbox, hwnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
if (pcbox->fNoEdit)
|
|
{
|
|
goto CallListSendMessage;
|
|
}
|
|
else
|
|
{
|
|
goto CallEditSendMessage;
|
|
}
|
|
break;
|
|
|
|
case WM_LBUTTONDBLCLK:
|
|
case WM_LBUTTONDOWN:
|
|
|
|
pcbox->fButtonHotTracked = FALSE;
|
|
//
|
|
// Set the focus to the combo box if we get a mouse click on it.
|
|
//
|
|
if (!pcbox->fFocus)
|
|
{
|
|
SetFocus(hwnd);
|
|
if (!pcbox->fFocus)
|
|
{
|
|
//
|
|
// Don't do anything if we still don't have the focus.
|
|
//
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If user clicked in button rect and we are a combobox with edit, then
|
|
// drop the listbox. (The button rect is 0 if there is no button so the
|
|
// ptinrect will return false.) If a drop down list (no edit), clicking
|
|
// anywhere on the face causes the list to drop.
|
|
//
|
|
|
|
POINTSTOPOINT(pt, lParam);
|
|
if ((pcbox->CBoxStyle == SDROPDOWN &&
|
|
PtInRect(&pcbox->buttonrc, pt)) ||
|
|
pcbox->CBoxStyle == SDROPDOWNLIST)
|
|
{
|
|
//
|
|
// Set the fMouseDown flag so that we can handle clicking on
|
|
// the popdown button and dragging into the listbox (when it just
|
|
// dropped down) to make a selection.
|
|
//
|
|
pcbox->fButtonPressed = TRUE;
|
|
if (pcbox->fLBoxVisible)
|
|
{
|
|
if (pcbox->fMouseDown)
|
|
{
|
|
pcbox->fMouseDown = FALSE;
|
|
ReleaseCapture();
|
|
}
|
|
ComboBox_PressButton(pcbox, FALSE);
|
|
|
|
if (!ComboBox_HideListBoxWindow(pcbox, TRUE, TRUE))
|
|
{
|
|
return 0L;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ComboBox_ShowListBoxWindow(pcbox, FALSE);
|
|
|
|
// Setting and resetting this flag must always be followed
|
|
// imediately by SetCapture or ReleaseCapture
|
|
//
|
|
pcbox->fMouseDown = TRUE;
|
|
SetCapture(hwnd);
|
|
NotifyWinEvent(EVENT_OBJECT_STATECHANGE, hwnd, OBJID_CLIENT, INDEX_COMBOBOX_BUTTON);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_MOUSEWHEEL:
|
|
//
|
|
// Handle only scrolling.
|
|
//
|
|
if (wParam & (MK_CONTROL | MK_SHIFT))
|
|
{
|
|
goto CallDWP;
|
|
}
|
|
|
|
//
|
|
// If the listbox is visible, send it the message to scroll.
|
|
//
|
|
if (pcbox->fLBoxVisible)
|
|
{
|
|
goto CallListSendMessage;
|
|
}
|
|
|
|
//
|
|
// If we're in extended UI mode or the edit control isn't yet created,
|
|
// bail.
|
|
//
|
|
if (pcbox->fExtendedUI || pcbox->hwndEdit == NULL)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Emulate arrow up/down messages to the edit control.
|
|
//
|
|
i = abs(((short)HIWORD(wParam))/WHEEL_DELTA);
|
|
wParam = ((short)HIWORD(wParam) > 0) ? VK_UP : VK_DOWN;
|
|
|
|
while (i-- > 0)
|
|
{
|
|
SendMessage(pcbox->hwndEdit, WM_KEYDOWN, wParam, 0);
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
case WM_CAPTURECHANGED:
|
|
if (!TESTFLAG(GET_STATE2(pcbox), WS_S2_WIN40COMPAT))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if ((pcbox->fMouseDown))
|
|
{
|
|
pcbox->fMouseDown = FALSE;
|
|
ComboBox_PressButton(pcbox, FALSE);
|
|
|
|
//
|
|
// Pop combo listbox back up, canceling.
|
|
//
|
|
if (pcbox->fLBoxVisible)
|
|
{
|
|
ComboBox_HideListBoxWindow(pcbox, TRUE, FALSE);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_LBUTTONUP:
|
|
ComboBox_PressButton(pcbox, FALSE);
|
|
|
|
//
|
|
// Clear this flag so that mouse moves aren't sent to the listbox
|
|
//
|
|
if (pcbox->fMouseDown || ((pcbox->CBoxStyle & SDROPPABLE) && pcbox->fLBoxVisible))
|
|
{
|
|
if (pcbox->fMouseDown)
|
|
{
|
|
pcbox->fMouseDown = FALSE;
|
|
|
|
if (pcbox->CBoxStyle == SDROPDOWN)
|
|
{
|
|
//
|
|
// If an item in the listbox matches the text in the edit
|
|
// control, scroll it to the top of the listbox. Select the
|
|
// item only if the mouse button isn't down otherwise we
|
|
// will select the item when the mouse button goes up.
|
|
//
|
|
ComboBox_UpdateListBoxWindow(pcbox, TRUE);
|
|
ComboBox_CompleteEditWindow(pcbox);
|
|
}
|
|
|
|
ReleaseCapture();
|
|
}
|
|
|
|
//
|
|
// Now, we want listbox to track mouse moves while mouse up
|
|
// until mouse down, and select items as though they were
|
|
// clicked on.
|
|
//
|
|
if (TESTFLAG(GET_STATE2(pcbox), WS_S2_WIN40COMPAT))
|
|
{
|
|
SendMessage(pcbox->hwndList, LBCB_STARTTRACK, FALSE, 0);
|
|
}
|
|
}
|
|
|
|
if (pcbox->hTheme)
|
|
{
|
|
POINTSTOPOINT(pt, lParam);
|
|
ComboBox_HotTrack(pcbox, pt);
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_MOUSELEAVE:
|
|
pcbox->fButtonHotTracked = FALSE;
|
|
InvalidateRect(hwnd, NULL, TRUE);
|
|
break;
|
|
|
|
case WM_MOUSEMOVE:
|
|
if (pcbox->fMouseDown)
|
|
{
|
|
POINTSTOPOINT(pt, lParam);
|
|
|
|
ClientToScreen(hwnd, &pt);
|
|
GetWindowRect(pcbox->hwndList, &rcList);
|
|
if (PtInRect(&rcList, pt))
|
|
{
|
|
//
|
|
// This handles dropdown comboboxes/listboxes so that clicking
|
|
// on the dropdown button and dragging into the listbox window
|
|
// will let the user make a listbox selection.
|
|
//
|
|
pcbox->fMouseDown = FALSE;
|
|
ReleaseCapture();
|
|
|
|
if (pcbox->CBoxStyle & SEDITABLE)
|
|
{
|
|
// If an item in the listbox matches the text in the edit
|
|
// control, scroll it to the top of the listbox. Select the
|
|
// item only if the mouse button isn't down otherwise we
|
|
// will select the item when the mouse button goes up.
|
|
|
|
//
|
|
// We need to select the item which matches the editcontrol
|
|
// so that if the user drags out of the listbox, we don't
|
|
// cancel back to his origonal selection
|
|
//
|
|
ComboBox_UpdateListBoxWindow(pcbox, TRUE);
|
|
}
|
|
|
|
//
|
|
// Convert point to listbox coordinates and send a buttondown
|
|
// message to the listbox window.
|
|
//
|
|
ScreenToClient(pcbox->hwndList, &pt);
|
|
lParam = POINTTOPOINTS(pt);
|
|
uMsg = WM_LBUTTONDOWN;
|
|
|
|
goto CallListSendMessage;
|
|
}
|
|
}
|
|
|
|
if (pcbox->hTheme)
|
|
{
|
|
POINTSTOPOINT(pt, lParam);
|
|
ComboBox_HotTrack(pcbox, pt);
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_NCDESTROY:
|
|
case WM_FINALDESTROY:
|
|
ComboBox_NcDestroyHandler(hwnd, pcbox);
|
|
|
|
break;
|
|
|
|
case WM_SETFOCUS:
|
|
if (pcbox->fNoEdit)
|
|
{
|
|
//
|
|
// There is no editcontrol so set the focus to the combo box itself.
|
|
//
|
|
ComboBox_GetFocusHandler(pcbox);
|
|
}
|
|
else if (pcbox->hwndEdit)
|
|
{
|
|
//
|
|
// Set the focus to the edit control window if there is one
|
|
//
|
|
SetFocus(pcbox->hwndEdit);
|
|
}
|
|
break;
|
|
|
|
case WM_KILLFOCUS:
|
|
|
|
//
|
|
// wParam has the new focus hwnd
|
|
//
|
|
if ((wParam == 0) || !IsChild(hwnd, (HWND)wParam))
|
|
{
|
|
//
|
|
// We only give up the focus if the new window getting the focus
|
|
// doesn't belong to the combo box.
|
|
//
|
|
ComboBox_KillFocusHandler(pcbox);
|
|
}
|
|
|
|
if ( IsWindow(hwnd) )
|
|
{
|
|
PLBIV plb = ListBox_GetPtr(pcbox->hwndList);
|
|
|
|
if ((plb != NULL) && (plb != (PLBIV)-1))
|
|
{
|
|
plb->iTypeSearch = 0;
|
|
if (plb->pszTypeSearch)
|
|
{
|
|
UserLocalFree(plb->pszTypeSearch);
|
|
plb->pszTypeSearch = NULL;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_SETREDRAW:
|
|
|
|
//
|
|
// wParam - specifies state of the redraw flag. nonzero = redraw
|
|
// lParam - not used
|
|
//
|
|
|
|
//
|
|
// effects: Sets the state of the redraw flag for this combo box
|
|
// and its children.
|
|
//
|
|
pcbox->fNoRedraw = (UINT)!((BOOL)wParam);
|
|
|
|
//
|
|
// Must check pcbox->spwnEdit in case we get this message before
|
|
// WM_CREATE - PCBOX won't be initialized yet. (Eudora does this)
|
|
//
|
|
if (!pcbox->fNoEdit && pcbox->hwndEdit)
|
|
{
|
|
SendMessage(pcbox->hwndEdit, uMsg, wParam, lParam);
|
|
}
|
|
|
|
goto CallListSendMessage;
|
|
break;
|
|
|
|
case WM_ENABLE:
|
|
|
|
//
|
|
// Invalidate the rect to cause it to be drawn in grey for its
|
|
// disabled view or ungreyed for non-disabled view.
|
|
//
|
|
InvalidateRect(hwnd, NULL, FALSE);
|
|
if ((pcbox->CBoxStyle & SEDITABLE) && pcbox->hwndEdit)
|
|
{
|
|
//
|
|
// Enable/disable the edit control window
|
|
//
|
|
EnableWindow(pcbox->hwndEdit, !TESTFLAG(GET_STYLE(pcbox), WS_DISABLED));
|
|
}
|
|
|
|
//
|
|
// Enable/disable the listbox window
|
|
//
|
|
UserAssert(pcbox->hwndList);
|
|
EnableWindow(pcbox->hwndList, !TESTFLAG(GET_STYLE(pcbox), WS_DISABLED));
|
|
break;
|
|
|
|
case WM_SIZE:
|
|
|
|
//
|
|
// wParam - defines the type of resizing fullscreen, sizeiconic,
|
|
// sizenormal etc.
|
|
// lParam - new width in LOWORD, new height in HIGHUINT of client area
|
|
//
|
|
UserAssert(pcbox->hwndList);
|
|
if (LOWORD(lParam) == 0 || HIWORD(lParam) == 0)
|
|
{
|
|
//
|
|
// If being sized to a zero width or to a zero height or we aren't
|
|
// fully initialized, just return.
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// OPTIMIZATIONS -- first check if old and new widths are the same
|
|
//
|
|
GetWindowRect(hwnd, &rcWindow);
|
|
if (pcbox->cxCombo == rcWindow.right - rcWindow.left)
|
|
{
|
|
int iNewHeight = rcWindow.bottom - rcWindow.top;
|
|
|
|
//
|
|
// now check if new height is the dropped down height
|
|
//
|
|
if (pcbox->fLBoxVisible)
|
|
{
|
|
//
|
|
// Check if new height is the full size height
|
|
//
|
|
if (pcbox->cyDrop + pcbox->cyCombo == iNewHeight)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Check if new height is the closed up height
|
|
//
|
|
if (pcbox->cyCombo == iNewHeight)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
ComboBox_SizeHandler(pcbox);
|
|
|
|
break;
|
|
|
|
case WM_WINDOWPOSCHANGING:
|
|
if (lParam)
|
|
{
|
|
((LPWINDOWPOS)lParam)->flags |= SWP_NOCOPYBITS;
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_WININICHANGE:
|
|
InitGlobalMetrics(wParam);
|
|
break;
|
|
|
|
case CB_GETDROPPEDSTATE:
|
|
|
|
//
|
|
// returns 1 if combo is dropped down else 0
|
|
// wParam - not used
|
|
// lParam - not used
|
|
//
|
|
return pcbox->fLBoxVisible;
|
|
|
|
case CB_GETDROPPEDCONTROLRECT:
|
|
|
|
//
|
|
// wParam - not used
|
|
// lParam - lpRect which will get the dropped down window rect in
|
|
// screen coordinates.
|
|
//
|
|
if ( lParam )
|
|
{
|
|
GetWindowRect(hwnd, &rcWindow);
|
|
((LPRECT)lParam)->left = rcWindow.left;
|
|
((LPRECT)lParam)->top = rcWindow.top;
|
|
((LPRECT)lParam)->right = rcWindow.left + max(pcbox->cxDrop, pcbox->cxCombo);
|
|
((LPRECT)lParam)->bottom = rcWindow.top + pcbox->cyCombo + pcbox->cyDrop;
|
|
}
|
|
else
|
|
{
|
|
lReturn = 0;
|
|
}
|
|
|
|
break;
|
|
|
|
case CB_SETDROPPEDWIDTH:
|
|
if (pcbox->CBoxStyle & SDROPPABLE)
|
|
{
|
|
if (wParam)
|
|
{
|
|
wParam = max(wParam, (UINT)pcbox->cxCombo);
|
|
|
|
if (wParam != (UINT) pcbox->cxDrop)
|
|
{
|
|
pcbox->cxDrop = (int)wParam;
|
|
ComboBox_Position(pcbox);
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// fall thru
|
|
//
|
|
|
|
case CB_GETDROPPEDWIDTH:
|
|
if (pcbox->CBoxStyle & SDROPPABLE)
|
|
{
|
|
return (LRESULT)max(pcbox->cxDrop, pcbox->cxCombo);
|
|
}
|
|
else
|
|
{
|
|
return CB_ERR;
|
|
}
|
|
|
|
break;
|
|
|
|
case CB_DIR:
|
|
//
|
|
// wParam - Dos attribute value.
|
|
// lParam - Points to a file specification string
|
|
//
|
|
return lParam ? CBDir(pcbox, LOWORD(wParam), (LPWSTR)lParam) : CB_ERR;
|
|
|
|
case CB_SETEXTENDEDUI:
|
|
|
|
//
|
|
// wParam - specifies state to set extendui flag to.
|
|
// Currently only 1 is allowed. Return CB_ERR (-1) if
|
|
// failure else 0 if success.
|
|
//
|
|
if (pcbox->CBoxStyle & SDROPPABLE)
|
|
{
|
|
if (!wParam)
|
|
{
|
|
pcbox->fExtendedUI = 0;
|
|
return 0;
|
|
}
|
|
|
|
if (wParam == 1)
|
|
{
|
|
pcbox->fExtendedUI = 1;
|
|
return 0;
|
|
}
|
|
|
|
TraceMsg(TF_STANDARD,
|
|
"UxCombobox: Invalid parameter \"wParam\" (%ld) to ComboBoxWndProcWorker",
|
|
wParam);
|
|
|
|
}
|
|
else
|
|
{
|
|
TraceMsg(TF_STANDARD,
|
|
"UxCombobox: Invalid message (%ld) sent to ComboBoxWndProcWorker",
|
|
uMsg);
|
|
}
|
|
|
|
return CB_ERR;
|
|
|
|
case CB_GETEXTENDEDUI:
|
|
if (pcbox->CBoxStyle & SDROPPABLE)
|
|
{
|
|
if (pcbox->fExtendedUI)
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
case CB_GETEDITSEL:
|
|
|
|
//
|
|
// wParam - not used
|
|
// lParam - not used
|
|
// effects: Gets the selection range for the given edit control. The
|
|
// starting BYTE-position is in the low order word. It contains the
|
|
// the BYTE-position of the first nonselected character after the end
|
|
// of the selection in the high order word. Returns CB_ERR if no
|
|
// editcontrol.
|
|
//
|
|
uMsg = EM_GETSEL;
|
|
|
|
goto CallEditSendMessage;
|
|
break;
|
|
|
|
case CB_LIMITTEXT:
|
|
|
|
//
|
|
// wParam - max number of bytes that can be entered
|
|
// lParam - not used
|
|
// effects: Specifies the maximum number of bytes of text the user may
|
|
// enter. If maxLength is 0, we may enter MAXINT number of BYTES.
|
|
//
|
|
uMsg = EM_LIMITTEXT;
|
|
|
|
goto CallEditSendMessage;
|
|
break;
|
|
|
|
case CB_SETEDITSEL:
|
|
|
|
//
|
|
// wParam - ichStart
|
|
// lParam - ichEnd
|
|
//
|
|
uMsg = EM_SETSEL;
|
|
|
|
wParam = (int)(SHORT)LOWORD(lParam);
|
|
lParam = (int)(SHORT)HIWORD(lParam);
|
|
|
|
goto CallEditSendMessage;
|
|
break;
|
|
|
|
case CB_ADDSTRING:
|
|
|
|
//
|
|
// wParam - not used
|
|
// lParam - Points to null terminated string to be added to listbox
|
|
//
|
|
if (!pcbox->fCase)
|
|
{
|
|
uMsg = LB_ADDSTRING;
|
|
}
|
|
else
|
|
{
|
|
uMsg = (pcbox->fCase & UPPERCASE) ? LB_ADDSTRINGUPPER : LB_ADDSTRINGLOWER;
|
|
}
|
|
|
|
goto CallListSendMessage;
|
|
break;
|
|
|
|
case CB_DELETESTRING:
|
|
|
|
//
|
|
// wParam - index to string to be deleted
|
|
// lParam - not used
|
|
//
|
|
uMsg = LB_DELETESTRING;
|
|
|
|
goto CallListSendMessage;
|
|
break;
|
|
|
|
case CB_INITSTORAGE:
|
|
//
|
|
// wParamLo - number of items
|
|
// lParam - number of bytes of string space
|
|
//
|
|
uMsg = LB_INITSTORAGE;
|
|
|
|
goto CallListSendMessage;
|
|
|
|
case CB_SETTOPINDEX:
|
|
//
|
|
// wParamLo - index to make top
|
|
// lParam - not used
|
|
//
|
|
uMsg = LB_SETTOPINDEX;
|
|
|
|
goto CallListSendMessage;
|
|
|
|
case CB_GETTOPINDEX:
|
|
//
|
|
// wParamLo / lParam - not used
|
|
//
|
|
uMsg = LB_GETTOPINDEX;
|
|
|
|
goto CallListSendMessage;
|
|
|
|
case CB_GETCOUNT:
|
|
//
|
|
// wParam - not used
|
|
// lParam - not used
|
|
//
|
|
uMsg = LB_GETCOUNT;
|
|
|
|
goto CallListSendMessage;
|
|
break;
|
|
|
|
case CB_GETCURSEL:
|
|
//
|
|
// wParam - not used
|
|
// lParam - not used
|
|
//
|
|
uMsg = LB_GETCURSEL;
|
|
|
|
goto CallListSendMessage;
|
|
break;
|
|
|
|
case CB_GETLBTEXT:
|
|
//
|
|
// wParam - index of string to be copied
|
|
// lParam - buffer that is to receive the string
|
|
//
|
|
uMsg = LB_GETTEXT;
|
|
|
|
goto CallListSendMessage;
|
|
break;
|
|
|
|
case CB_GETLBTEXTLEN:
|
|
//
|
|
// wParam - index to string
|
|
// lParam - now used for cbANSI
|
|
//
|
|
uMsg = LB_GETTEXTLEN;
|
|
|
|
goto CallListSendMessage;
|
|
break;
|
|
|
|
case CB_INSERTSTRING:
|
|
//
|
|
// wParam - position to receive the string
|
|
// lParam - points to the string
|
|
//
|
|
if (!pcbox->fCase)
|
|
{
|
|
uMsg = LB_INSERTSTRING;
|
|
}
|
|
else
|
|
{
|
|
uMsg = (pcbox->fCase & UPPERCASE) ? LB_INSERTSTRINGUPPER : LB_INSERTSTRINGLOWER;
|
|
}
|
|
|
|
goto CallListSendMessage;
|
|
break;
|
|
|
|
case CB_RESETCONTENT:
|
|
//
|
|
// wParam - not used
|
|
// lParam - not used
|
|
// If we come here before WM_CREATE has been processed,
|
|
// pcbox->spwndList will be NULL.
|
|
//
|
|
UserAssert(pcbox->hwndList);
|
|
SendMessage(pcbox->hwndList, LB_RESETCONTENT, 0, 0);
|
|
ComboBox_InternalUpdateEditWindow(pcbox, NULL);
|
|
|
|
break;
|
|
|
|
case CB_GETHORIZONTALEXTENT:
|
|
uMsg = LB_GETHORIZONTALEXTENT;
|
|
|
|
goto CallListSendMessage;
|
|
|
|
case CB_SETHORIZONTALEXTENT:
|
|
uMsg = LB_SETHORIZONTALEXTENT;
|
|
|
|
goto CallListSendMessage;
|
|
|
|
case CB_FINDSTRING:
|
|
//
|
|
// wParam - index of starting point for search
|
|
// lParam - points to prefix string
|
|
//
|
|
uMsg = LB_FINDSTRING;
|
|
|
|
goto CallListSendMessage;
|
|
break;
|
|
|
|
case CB_FINDSTRINGEXACT:
|
|
//
|
|
// wParam - index of starting point for search
|
|
// lParam - points to a exact string
|
|
//
|
|
uMsg = LB_FINDSTRINGEXACT;
|
|
|
|
goto CallListSendMessage;
|
|
break;
|
|
|
|
case CB_SELECTSTRING:
|
|
//
|
|
// wParam - index of starting point for search
|
|
// lParam - points to prefix string
|
|
//
|
|
UserAssert(pcbox->hwndList);
|
|
lParam = SendMessage(pcbox->hwndList, LB_SELECTSTRING, wParam, lParam);
|
|
ComboBox_InternalUpdateEditWindow(pcbox, NULL);
|
|
|
|
return lParam;
|
|
|
|
case CB_SETCURSEL:
|
|
//
|
|
// wParam - Contains index to be selected
|
|
// lParam - not used
|
|
// If we come here before WM_CREATE has been processed,
|
|
// pcbox->spwndList will be NULL.
|
|
//
|
|
UserAssert(pcbox->hwndList);
|
|
|
|
lParam = SendMessage(pcbox->hwndList, LB_SETCURSEL, wParam, lParam);
|
|
if (lParam != -1)
|
|
{
|
|
SendMessage(pcbox->hwndList, LB_SETTOPINDEX, wParam, 0);
|
|
}
|
|
ComboBox_InternalUpdateEditWindow(pcbox, NULL);
|
|
|
|
return lParam;
|
|
|
|
case CB_GETITEMDATA:
|
|
uMsg = LB_GETITEMDATA;
|
|
|
|
goto CallListSendMessage;
|
|
break;
|
|
|
|
case CB_SETITEMDATA:
|
|
uMsg = LB_SETITEMDATA;
|
|
|
|
goto CallListSendMessage;
|
|
break;
|
|
|
|
case CB_SETITEMHEIGHT:
|
|
if (wParam == -1)
|
|
{
|
|
if (HIWORD(lParam) != 0)
|
|
{
|
|
return CB_ERR;
|
|
}
|
|
|
|
return ComboBox_SetEditItemHeight(pcbox, LOWORD(lParam));
|
|
}
|
|
|
|
uMsg = LB_SETITEMHEIGHT;
|
|
goto CallListSendMessage;
|
|
|
|
break;
|
|
|
|
case CB_GETITEMHEIGHT:
|
|
if (wParam == -1)
|
|
{
|
|
return pcbox->editrc.bottom - pcbox->editrc.top;
|
|
}
|
|
|
|
uMsg = LB_GETITEMHEIGHT;
|
|
|
|
goto CallListSendMessage;
|
|
break;
|
|
|
|
case CB_SHOWDROPDOWN:
|
|
//
|
|
// wParam - True then drop down the listbox if possible else hide it
|
|
// lParam - not used
|
|
//
|
|
if (wParam && !pcbox->fLBoxVisible)
|
|
{
|
|
ComboBox_ShowListBoxWindow(pcbox, TRUE);
|
|
}
|
|
else
|
|
{
|
|
if (!wParam && pcbox->fLBoxVisible)
|
|
{
|
|
ComboBox_HideListBoxWindow(pcbox, TRUE, FALSE);
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case CB_SETLOCALE:
|
|
//
|
|
// wParam - locale id
|
|
// lParam - not used
|
|
//
|
|
uMsg = LB_SETLOCALE;
|
|
goto CallListSendMessage;
|
|
|
|
break;
|
|
|
|
case CB_GETLOCALE:
|
|
//
|
|
// wParam - not used
|
|
// lParam - not used
|
|
//
|
|
uMsg = LB_GETLOCALE;
|
|
goto CallListSendMessage;
|
|
break;
|
|
|
|
case CB_GETCOMBOBOXINFO:
|
|
//
|
|
// wParam - not used
|
|
// lParam - pointer to COMBOBOXINFO struct
|
|
//
|
|
lReturn = ComboBox_GetInfo(pcbox, (PCOMBOBOXINFO)lParam);
|
|
break;
|
|
|
|
case CB_SETMINVISIBLE:
|
|
if (wParam > 0)
|
|
{
|
|
PLBIV plb = ListBox_GetPtr(pcbox->hwndList);
|
|
|
|
pcbox->iMinVisible = (int)wParam;
|
|
if (plb && !plb->fNoIntegralHeight)
|
|
{
|
|
// forward through to the listbox to let him adjust
|
|
// his size if necessary
|
|
SendMessage(pcbox->hwndList, uMsg, wParam, 0L);
|
|
}
|
|
|
|
lReturn = TRUE;
|
|
}
|
|
else
|
|
{
|
|
lReturn = FALSE;
|
|
}
|
|
|
|
break;
|
|
|
|
case CB_GETMINVISIBLE:
|
|
|
|
return pcbox->iMinVisible;
|
|
|
|
case WM_MEASUREITEM:
|
|
case WM_DELETEITEM:
|
|
case WM_DRAWITEM:
|
|
case WM_COMPAREITEM:
|
|
return ComboBox_MessageItemHandler(pcbox, uMsg, (LPVOID)lParam);
|
|
|
|
case WM_NCCREATE:
|
|
//
|
|
// wParam - Contains a handle to the window being created
|
|
// lParam - Points to the CREATESTRUCT data structure for the window.
|
|
//
|
|
|
|
//
|
|
// Allocate the combobox instance stucture
|
|
//
|
|
pcbox = (PCBOX)UserLocalAlloc(HEAP_ZERO_MEMORY, sizeof(CBOX));
|
|
if (pcbox)
|
|
{
|
|
//
|
|
// Success... store the instance pointer.
|
|
//
|
|
TraceMsg(TF_STANDARD, "COMBOBOX: Setting combobox instance pointer.");
|
|
ComboBox_SetPtr(hwnd, pcbox);
|
|
|
|
return ComboBox_NcCreateHandler(pcbox, hwnd);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Failed... return FALSE.
|
|
//
|
|
// From a WM_NCCREATE msg, this will cause the
|
|
// CreateWindow call to fail.
|
|
//
|
|
TraceMsg(TF_STANDARD, "COMBOBOX: Unable to allocate combobox instance structure.");
|
|
lReturn = FALSE;
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_PARENTNOTIFY:
|
|
if (LOWORD(wParam) == WM_DESTROY)
|
|
{
|
|
if ((HWND)lParam == pcbox->hwndEdit)
|
|
{
|
|
pcbox->CBoxStyle &= ~SEDITABLE;
|
|
pcbox->fNoEdit = TRUE;
|
|
pcbox->hwndEdit = hwnd;
|
|
}
|
|
else if ((HWND)lParam == pcbox->hwndList)
|
|
{
|
|
pcbox->CBoxStyle &= ~SDROPPABLE;
|
|
pcbox->hwndList = NULL;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_UPDATEUISTATE:
|
|
//
|
|
// Propagate the change to the list control, if any
|
|
//
|
|
UserAssert(pcbox->hwndList);
|
|
SendMessage(pcbox->hwndList, WM_UPDATEUISTATE, wParam, lParam);
|
|
|
|
goto CallDWP;
|
|
|
|
case WM_GETOBJECT:
|
|
|
|
if(lParam == OBJID_QUERYCLASSNAMEIDX)
|
|
{
|
|
lReturn = MSAA_CLASSNAMEIDX_COMBOBOX;
|
|
}
|
|
else
|
|
{
|
|
lReturn = FALSE;
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_THEMECHANGED:
|
|
|
|
if ( pcbox->hTheme )
|
|
{
|
|
CloseThemeData(pcbox->hTheme);
|
|
}
|
|
|
|
pcbox->hTheme = OpenThemeData(pcbox->hwnd, L"Combobox");
|
|
|
|
ComboBox_Position(pcbox);
|
|
InvalidateRect(pcbox->hwnd, NULL, TRUE);
|
|
|
|
lReturn = TRUE;
|
|
|
|
break;
|
|
|
|
case WM_HELP:
|
|
{
|
|
LPHELPINFO lpHelpInfo;
|
|
|
|
//
|
|
// Check if this message is from a child of this combo
|
|
//
|
|
if ((lpHelpInfo = (LPHELPINFO)lParam) != NULL &&
|
|
((pcbox->hwndEdit && lpHelpInfo->iCtrlId == (SHORT)GetWindowID(pcbox->hwndEdit)) ||
|
|
lpHelpInfo->iCtrlId == (SHORT)GetWindowID(pcbox->hwndList) ))
|
|
{
|
|
//
|
|
// Make it look like the WM_HELP is coming form this combo.
|
|
// Then DefWindowProcWorker will pass it up to our parent,
|
|
// who can do whatever he wants with it.
|
|
//
|
|
lpHelpInfo->iCtrlId = (SHORT)GetWindowID(hwnd);
|
|
lpHelpInfo->hItemHandle = hwnd;
|
|
#if 0 // PORTPORT: GetContextHelpId
|
|
lpHelpInfo->dwContextId = GetContextHelpId(hwnd);
|
|
#endif
|
|
}
|
|
//
|
|
// Fall through to DefWindowProc
|
|
//
|
|
}
|
|
|
|
default:
|
|
|
|
if ( (GetSystemMetrics(SM_PENWINDOWS)) &&
|
|
(uMsg >= WM_PENWINFIRST && uMsg <= WM_PENWINLAST))
|
|
{
|
|
goto CallEditSendMessage;
|
|
}
|
|
else
|
|
{
|
|
|
|
CallDWP:
|
|
lReturn = DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
}
|
|
}
|
|
|
|
return lReturn;
|
|
|
|
//
|
|
// The following forward messages off to the child controls.
|
|
//
|
|
CallEditSendMessage:
|
|
if (!pcbox->fNoEdit && pcbox->hwndEdit)
|
|
{
|
|
lReturn = SendMessage(pcbox->hwndEdit, uMsg, wParam, lParam);
|
|
}
|
|
else
|
|
{
|
|
TraceMsg(TF_STANDARD, "COMBOBOX: Invalid combobox message %#.4x", uMsg);
|
|
lReturn = CB_ERR;
|
|
}
|
|
return lReturn;
|
|
|
|
CallListSendMessage:
|
|
UserAssert(pcbox->hwndList);
|
|
lReturn = SendMessage(pcbox->hwndList, uMsg, wParam, lParam);
|
|
|
|
return lReturn;
|
|
}
|