4 * Copyright 1997 Alex Korobka
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 * This code was audited for completeness against the documented features
23 * of Comctl32.dll version 6.0 on Oct. 4, 2004, by Dimitrie O. Paun.
25 * Unless otherwise noted, we believe this code to be complete, as per
26 * the specification mentioned above.
27 * If you discover missing features, or bugs, please note them below.
30 * - ComboBox_[GS]etMinVisible()
31 * - CB_GETMINVISIBLE, CB_SETMINVISIBLE
44 #include "wine/unicode.h"
45 #include "user_private.h"
49 #include "wine/debug.h"
51 WINE_DEFAULT_DEBUG_CHANNEL(combo);
53 /* bits in the dwKeyData */
54 #define KEYDATA_ALT 0x2000
55 #define KEYDATA_PREVSTATE 0x4000
58 * Additional combo box definitions
61 #define CB_NOTIFY( lphc, code ) \
62 (SendMessageW((lphc)->owner, WM_COMMAND, \
63 MAKEWPARAM(GetWindowLongPtrW((lphc)->self,GWLP_ID), (code)), (LPARAM)(lphc)->self))
65 #define CB_DISABLED( lphc ) (!IsWindowEnabled((lphc)->self))
66 #define CB_OWNERDRAWN( lphc ) ((lphc)->dwStyle & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE))
67 #define CB_HASSTRINGS( lphc ) ((lphc)->dwStyle & CBS_HASSTRINGS)
68 #define CB_HWND( lphc ) ((lphc)->self)
69 #define CB_GETTYPE( lphc ) ((lphc)->dwStyle & (CBS_DROPDOWNLIST))
71 #define ISWIN31 (LOWORD(GetVersion()) == 0x0a03)
76 static HBITMAP hComboBmp = 0;
77 static UINT CBitHeight, CBitWidth;
80 * Look and feel dependent "constants"
83 #define COMBO_YBORDERGAP 5
84 #define COMBO_XBORDERSIZE() 2
85 #define COMBO_YBORDERSIZE() 2
86 #define COMBO_EDITBUTTONSPACE() 0
87 #define EDIT_CONTROL_PADDING() 1
89 /*********************************************************************
90 * combo class descriptor
92 static const WCHAR comboboxW[] = {'C','o','m','b','o','B','o','x',0};
93 const struct builtin_class_descr COMBO_builtin_class =
96 CS_PARENTDC | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW, /* style */
97 WINPROC_COMBO, /* proc */
98 sizeof(HEADCOMBO *), /* extra */
99 IDC_ARROW, /* cursor */
104 /***********************************************************************
107 * Load combo button bitmap.
109 static BOOL COMBO_Init(void)
113 if( hComboBmp ) return TRUE;
114 if( (hDC = CreateCompatibleDC(0)) )
117 if( (hComboBmp = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_COMBO))) )
123 GetObjectW( hComboBmp, sizeof(bm), &bm );
124 CBitHeight = bm.bmHeight;
125 CBitWidth = bm.bmWidth;
127 TRACE("combo bitmap [%i,%i]\n", CBitWidth, CBitHeight );
129 hPrevB = SelectObject( hDC, hComboBmp);
130 SetRect( &r, 0, 0, CBitWidth, CBitHeight );
131 InvertRect( hDC, &r );
132 SelectObject( hDC, hPrevB );
141 /***********************************************************************
144 static LRESULT COMBO_NCCreate(HWND hwnd, LONG style)
148 if (COMBO_Init() && (lphc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HEADCOMBO))) )
151 SetWindowLongPtrW( hwnd, 0, (LONG_PTR)lphc );
153 /* some braindead apps do try to use scrollbar/border flags */
155 lphc->dwStyle = style & ~(WS_BORDER | WS_HSCROLL | WS_VSCROLL);
156 SetWindowLongW( hwnd, GWL_STYLE, style & ~(WS_BORDER | WS_HSCROLL | WS_VSCROLL) );
159 * We also have to remove the client edge style to make sure
160 * we don't end-up with a non client area.
162 SetWindowLongW( hwnd, GWL_EXSTYLE,
163 GetWindowLongW( hwnd, GWL_EXSTYLE ) & ~WS_EX_CLIENTEDGE );
165 if( !(style & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) )
166 lphc->dwStyle |= CBS_HASSTRINGS;
167 if( !(GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_NOPARENTNOTIFY) )
168 lphc->wState |= CBF_NOTIFY;
170 TRACE("[%p], style = %08x\n", lphc, lphc->dwStyle );
176 /***********************************************************************
179 static LRESULT COMBO_NCDestroy( LPHEADCOMBO lphc )
184 TRACE("[%p]: freeing storage\n", lphc->self);
186 if( (CB_GETTYPE(lphc) != CBS_SIMPLE) && lphc->hWndLBox )
187 DestroyWindow( lphc->hWndLBox );
189 SetWindowLongPtrW( lphc->self, 0, 0 );
190 HeapFree( GetProcessHeap(), 0, lphc );
195 /***********************************************************************
196 * CBGetTextAreaHeight
198 * This method will calculate the height of the text area of the
200 * The height of the text area is set in two ways.
201 * It can be set explicitly through a combobox message or through a
202 * WM_MEASUREITEM callback.
203 * If this is not the case, the height is set to font height + 4px
204 * This height was determined through experimentation.
205 * CBCalcPlacement will add 2*COMBO_YBORDERSIZE pixels for the border
207 static INT CBGetTextAreaHeight(
213 if( lphc->editHeight ) /* explicitly set height */
215 iTextItemHeight = lphc->editHeight;
220 HDC hDC = GetDC(hwnd);
225 hPrevFont = SelectObject( hDC, lphc->hFont );
227 GetTextMetricsW(hDC, &tm);
229 baseUnitY = tm.tmHeight;
232 SelectObject( hDC, hPrevFont );
234 ReleaseDC(hwnd, hDC);
236 iTextItemHeight = baseUnitY + 4;
240 * Check the ownerdraw case if we haven't asked the parent the size
243 if ( CB_OWNERDRAWN(lphc) &&
244 (lphc->wState & CBF_MEASUREITEM) )
246 MEASUREITEMSTRUCT measureItem;
248 INT originalItemHeight = iTextItemHeight;
249 UINT id = (UINT)GetWindowLongPtrW( lphc->self, GWLP_ID );
252 * We use the client rect for the width of the item.
254 GetClientRect(hwnd, &clientRect);
256 lphc->wState &= ~CBF_MEASUREITEM;
259 * Send a first one to measure the size of the text area
261 measureItem.CtlType = ODT_COMBOBOX;
262 measureItem.CtlID = id;
263 measureItem.itemID = -1;
264 measureItem.itemWidth = clientRect.right;
265 measureItem.itemHeight = iTextItemHeight - 6; /* ownerdrawn cb is taller */
266 measureItem.itemData = 0;
267 SendMessageW(lphc->owner, WM_MEASUREITEM, id, (LPARAM)&measureItem);
268 iTextItemHeight = 6 + measureItem.itemHeight;
271 * Send a second one in the case of a fixed ownerdraw list to calculate the
272 * size of the list items. (we basically do this on behalf of the listbox)
274 if (lphc->dwStyle & CBS_OWNERDRAWFIXED)
276 measureItem.CtlType = ODT_COMBOBOX;
277 measureItem.CtlID = id;
278 measureItem.itemID = 0;
279 measureItem.itemWidth = clientRect.right;
280 measureItem.itemHeight = originalItemHeight;
281 measureItem.itemData = 0;
282 SendMessageW(lphc->owner, WM_MEASUREITEM, id, (LPARAM)&measureItem);
283 lphc->fixedOwnerDrawHeight = measureItem.itemHeight;
287 * Keep the size for the next time
289 lphc->editHeight = iTextItemHeight;
292 return iTextItemHeight;
295 /***********************************************************************
298 * The dummy resize is used for listboxes that have a popup to trigger
299 * a re-arranging of the contents of the combobox and the recalculation
300 * of the size of the "real" control window.
302 static void CBForceDummyResize(
308 newComboHeight = CBGetTextAreaHeight(lphc->self,lphc) + 2*COMBO_YBORDERSIZE();
310 GetWindowRect(lphc->self, &windowRect);
313 * We have to be careful, resizing a combobox also has the meaning that the
314 * dropped rect will be resized. In this case, we want to trigger a resize
315 * to recalculate layout but we don't want to change the dropped rectangle
316 * So, we pass the height of text area of control as the height.
317 * this will cancel-out in the processing of the WM_WINDOWPOSCHANGING
320 SetWindowPos( lphc->self,
323 windowRect.right - windowRect.left,
325 SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE );
328 /***********************************************************************
331 * Set up component coordinates given valid lphc->RectCombo.
333 static void CBCalcPlacement(
341 * Again, start with the client rectangle.
343 GetClientRect(hwnd, lprEdit);
348 InflateRect(lprEdit, -COMBO_XBORDERSIZE(), -COMBO_YBORDERSIZE());
351 * Chop off the bottom part to fit with the height of the text area.
353 lprEdit->bottom = lprEdit->top + CBGetTextAreaHeight(hwnd, lphc);
356 * The button starts the same vertical position as the text area.
358 CopyRect(lprButton, lprEdit);
361 * If the combobox is "simple" there is no button.
363 if( CB_GETTYPE(lphc) == CBS_SIMPLE )
364 lprButton->left = lprButton->right = lprButton->bottom = 0;
368 * Let's assume the combobox button is the same width as the
370 * size the button horizontally and cut-off the text area.
372 lprButton->left = lprButton->right - GetSystemMetrics(SM_CXVSCROLL);
373 lprEdit->right = lprButton->left;
377 * In the case of a dropdown, there is an additional spacing between the
378 * text area and the button.
380 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
382 lprEdit->right -= COMBO_EDITBUTTONSPACE();
386 * If we have an edit control, we space it away from the borders slightly.
388 if (CB_GETTYPE(lphc) != CBS_DROPDOWNLIST)
390 InflateRect(lprEdit, -EDIT_CONTROL_PADDING(), -EDIT_CONTROL_PADDING());
394 * Adjust the size of the listbox popup.
396 if( CB_GETTYPE(lphc) == CBS_SIMPLE )
399 * Use the client rectangle to initialize the listbox rectangle
401 GetClientRect(hwnd, lprLB);
404 * Then, chop-off the top part.
406 lprLB->top = lprEdit->bottom + COMBO_YBORDERSIZE();
411 * Make sure the dropped width is as large as the combobox itself.
413 if (lphc->droppedWidth < (lprButton->right + COMBO_XBORDERSIZE()))
415 lprLB->right = lprLB->left + (lprButton->right + COMBO_XBORDERSIZE());
418 * In the case of a dropdown, the popup listbox is offset to the right.
419 * so, we want to make sure it's flush with the right side of the
422 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
423 lprLB->right -= COMBO_EDITBUTTONSPACE();
426 lprLB->right = lprLB->left + lphc->droppedWidth;
429 /* don't allow negative window width */
430 if (lprEdit->right < lprEdit->left)
431 lprEdit->right = lprEdit->left;
433 TRACE("\ttext\t= (%s)\n", wine_dbgstr_rect(lprEdit));
435 TRACE("\tbutton\t= (%s)\n", wine_dbgstr_rect(lprButton));
437 TRACE("\tlbox\t= (%s)\n", wine_dbgstr_rect(lprLB));
440 /***********************************************************************
441 * CBGetDroppedControlRect
443 static void CBGetDroppedControlRect( LPHEADCOMBO lphc, LPRECT lpRect)
445 /* In windows, CB_GETDROPPEDCONTROLRECT returns the upper left corner
446 of the combo box and the lower right corner of the listbox */
448 GetWindowRect(lphc->self, lpRect);
450 lpRect->right = lpRect->left + lphc->droppedRect.right - lphc->droppedRect.left;
451 lpRect->bottom = lpRect->top + lphc->droppedRect.bottom - lphc->droppedRect.top;
455 /***********************************************************************
456 * COMBO_WindowPosChanging
458 static LRESULT COMBO_WindowPosChanging(
461 WINDOWPOS* posChanging)
464 * We need to override the WM_WINDOWPOSCHANGING method to handle all
465 * the non-simple comboboxes. The problem is that those controls are
466 * always the same height. We have to make sure they are not resized
469 if ( ( CB_GETTYPE(lphc) != CBS_SIMPLE ) &&
470 ((posChanging->flags & SWP_NOSIZE) == 0) )
474 newComboHeight = CBGetTextAreaHeight(hwnd,lphc) +
475 2*COMBO_YBORDERSIZE();
478 * Resizing a combobox has another side effect, it resizes the dropped
479 * rectangle as well. However, it does it only if the new height for the
480 * combobox is more than the height it should have. In other words,
481 * if the application resizing the combobox only had the intention to resize
482 * the actual control, for example, to do the layout of a dialog that is
483 * resized, the height of the dropdown is not changed.
485 if (posChanging->cy > newComboHeight)
487 TRACE("posChanging->cy=%d, newComboHeight=%d, oldbot=%d, oldtop=%d\n",
488 posChanging->cy, newComboHeight, lphc->droppedRect.bottom,
489 lphc->droppedRect.top);
490 lphc->droppedRect.bottom = lphc->droppedRect.top + posChanging->cy - newComboHeight;
493 posChanging->cy = newComboHeight;
499 /***********************************************************************
502 static LRESULT COMBO_Create( HWND hwnd, LPHEADCOMBO lphc, HWND hwndParent, LONG style,
505 static const WCHAR clbName[] = {'C','o','m','b','o','L','B','o','x',0};
506 static const WCHAR editName[] = {'E','d','i','t',0};
508 if( !CB_GETTYPE(lphc) ) lphc->dwStyle |= CBS_SIMPLE;
509 if( CB_GETTYPE(lphc) != CBS_DROPDOWNLIST ) lphc->wState |= CBF_EDIT;
511 lphc->owner = hwndParent;
514 * The item height and dropped width are not set when the control
517 lphc->droppedWidth = lphc->editHeight = 0;
520 * The first time we go through, we want to measure the ownerdraw item
522 lphc->wState |= CBF_MEASUREITEM;
524 /* M$ IE 3.01 actually creates (and rapidly destroys) an ownerless combobox */
526 if( lphc->owner || !(style & WS_VISIBLE) )
532 * Initialize the dropped rect to the size of the client area of the
533 * control and then, force all the areas of the combobox to be
536 GetClientRect( hwnd, &lphc->droppedRect );
537 CBCalcPlacement(hwnd, lphc, &lphc->textRect, &lphc->buttonRect, &lphc->droppedRect );
540 * Adjust the position of the popup listbox if it's necessary
542 if ( CB_GETTYPE(lphc) != CBS_SIMPLE )
544 lphc->droppedRect.top = lphc->textRect.bottom + COMBO_YBORDERSIZE();
547 * If it's a dropdown, the listbox is offset
549 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
550 lphc->droppedRect.left += COMBO_EDITBUTTONSPACE();
552 if (lphc->droppedRect.bottom < lphc->droppedRect.top)
553 lphc->droppedRect.bottom = lphc->droppedRect.top;
554 if (lphc->droppedRect.right < lphc->droppedRect.left)
555 lphc->droppedRect.right = lphc->droppedRect.left;
556 MapWindowPoints( hwnd, 0, (LPPOINT)&lphc->droppedRect, 2 );
559 /* create listbox popup */
561 lbeStyle = (LBS_NOTIFY | LBS_COMBOBOX | WS_BORDER | WS_CLIPSIBLINGS | WS_CHILD) |
562 (style & (WS_VSCROLL | CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE));
564 if( lphc->dwStyle & CBS_SORT )
565 lbeStyle |= LBS_SORT;
566 if( lphc->dwStyle & CBS_HASSTRINGS )
567 lbeStyle |= LBS_HASSTRINGS;
568 if( lphc->dwStyle & CBS_NOINTEGRALHEIGHT )
569 lbeStyle |= LBS_NOINTEGRALHEIGHT;
570 if( lphc->dwStyle & CBS_DISABLENOSCROLL )
571 lbeStyle |= LBS_DISABLENOSCROLL;
573 if( CB_GETTYPE(lphc) == CBS_SIMPLE ) /* child listbox */
575 lbeStyle |= WS_VISIBLE;
578 * In win 95 look n feel, the listbox in the simple combobox has
579 * the WS_EXCLIENTEDGE style instead of the WS_BORDER style.
581 lbeStyle &= ~WS_BORDER;
582 lbeExStyle |= WS_EX_CLIENTEDGE;
586 lbeExStyle |= (WS_EX_TOPMOST | WS_EX_TOOLWINDOW);
590 lphc->hWndLBox = CreateWindowExW(lbeExStyle, clbName, NULL, lbeStyle,
591 lphc->droppedRect.left,
592 lphc->droppedRect.top,
593 lphc->droppedRect.right - lphc->droppedRect.left,
594 lphc->droppedRect.bottom - lphc->droppedRect.top,
595 hwnd, (HMENU)ID_CB_LISTBOX,
596 (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE ), lphc );
598 lphc->hWndLBox = CreateWindowExA(lbeExStyle, "ComboLBox", NULL, lbeStyle,
599 lphc->droppedRect.left,
600 lphc->droppedRect.top,
601 lphc->droppedRect.right - lphc->droppedRect.left,
602 lphc->droppedRect.bottom - lphc->droppedRect.top,
603 hwnd, (HMENU)ID_CB_LISTBOX,
604 (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE ), lphc );
609 lbeStyle = WS_CHILD | WS_VISIBLE | ES_NOHIDESEL | ES_LEFT | ES_COMBO;
611 if( lphc->wState & CBF_EDIT )
613 if( lphc->dwStyle & CBS_OEMCONVERT )
614 lbeStyle |= ES_OEMCONVERT;
615 if( lphc->dwStyle & CBS_AUTOHSCROLL )
616 lbeStyle |= ES_AUTOHSCROLL;
617 if( lphc->dwStyle & CBS_LOWERCASE )
618 lbeStyle |= ES_LOWERCASE;
619 else if( lphc->dwStyle & CBS_UPPERCASE )
620 lbeStyle |= ES_UPPERCASE;
622 if (!IsWindowEnabled(hwnd)) lbeStyle |= WS_DISABLED;
625 lphc->hWndEdit = CreateWindowExW(0, editName, NULL, lbeStyle,
626 lphc->textRect.left, lphc->textRect.top,
627 lphc->textRect.right - lphc->textRect.left,
628 lphc->textRect.bottom - lphc->textRect.top,
629 hwnd, (HMENU)ID_CB_EDIT,
630 (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE ), NULL );
632 lphc->hWndEdit = CreateWindowExA(0, "Edit", NULL, lbeStyle,
633 lphc->textRect.left, lphc->textRect.top,
634 lphc->textRect.right - lphc->textRect.left,
635 lphc->textRect.bottom - lphc->textRect.top,
636 hwnd, (HMENU)ID_CB_EDIT,
637 (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE ), NULL );
639 if( !lphc->hWndEdit )
645 if( CB_GETTYPE(lphc) != CBS_SIMPLE )
647 /* Now do the trick with parent */
648 SetParent(lphc->hWndLBox, HWND_DESKTOP);
650 * If the combo is a dropdown, we must resize the control
651 * to fit only the text area and button. To do this,
652 * we send a dummy resize and the WM_WINDOWPOSCHANGING message
653 * will take care of setting the height for us.
655 CBForceDummyResize(lphc);
658 TRACE("init done\n");
661 ERR("edit control failure.\n");
662 } else ERR("listbox failure.\n");
663 } else ERR("no owner for visible combo.\n");
665 /* CreateWindow() will send WM_NCDESTROY to cleanup */
670 /***********************************************************************
673 * Paint combo button (normal, pressed, and disabled states).
675 static void CBPaintButton( LPHEADCOMBO lphc, HDC hdc, RECT rectButton)
677 UINT buttonState = DFCS_SCROLLCOMBOBOX;
679 if( lphc->wState & CBF_NOREDRAW )
683 if (lphc->wState & CBF_BUTTONDOWN)
684 buttonState |= DFCS_PUSHED;
686 if (CB_DISABLED(lphc))
687 buttonState |= DFCS_INACTIVE;
689 DrawFrameControl(hdc, &rectButton, DFC_SCROLL, buttonState);
692 /***********************************************************************
695 * Paint CBS_DROPDOWNLIST text field / update edit control contents.
697 static void CBPaintText(
705 if( lphc->wState & CBF_NOREDRAW ) return;
709 /* follow Windows combobox that sends a bunch of text
710 * inquiries to its listbox while processing WM_PAINT. */
712 if( (id = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0) ) != LB_ERR )
714 size = SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, id, 0);
716 FIXME("LB_ERR probably not handled yet\n");
717 if( (pText = HeapAlloc( GetProcessHeap(), 0, (size + 1) * sizeof(WCHAR))) )
719 /* size from LB_GETTEXTLEN may be too large, from LB_GETTEXT is accurate */
720 size=SendMessageW(lphc->hWndLBox, LB_GETTEXT, (WPARAM)id, (LPARAM)pText);
721 pText[size] = '\0'; /* just in case */
725 if( !CB_OWNERDRAWN(lphc) )
728 if( lphc->wState & CBF_EDIT )
730 static const WCHAR empty_stringW[] = { 0 };
731 if( CB_HASSTRINGS(lphc) ) SetWindowTextW( lphc->hWndEdit, pText ? pText : empty_stringW );
732 if( lphc->wState & CBF_FOCUSED )
733 SendMessageW(lphc->hWndEdit, EM_SETSEL, 0, (LPARAM)(-1));
735 else /* paint text field ourselves */
737 UINT itemState = ODS_COMBOBOXEDIT;
738 HFONT hPrevFont = (lphc->hFont) ? SelectObject(hdc, lphc->hFont) : 0;
741 * Give ourselves some space.
743 InflateRect( &rectEdit, -1, -1 );
745 if( CB_OWNERDRAWN(lphc) )
749 UINT ctlid = (UINT)GetWindowLongPtrW( lphc->self, GWLP_ID );
751 /* setup state for DRAWITEM message. Owner will highlight */
752 if ( (lphc->wState & CBF_FOCUSED) &&
753 !(lphc->wState & CBF_DROPPED) )
754 itemState |= ODS_SELECTED | ODS_FOCUS;
757 * Save the current clip region.
758 * To retrieve the clip region, we need to create one "dummy"
761 clipRegion = CreateRectRgnIndirect(&rectEdit);
763 if (GetClipRgn(hdc, clipRegion)!=1)
765 DeleteObject(clipRegion);
769 if (!IsWindowEnabled(lphc->self)) itemState |= ODS_DISABLED;
771 dis.CtlType = ODT_COMBOBOX;
773 dis.hwndItem = lphc->self;
774 dis.itemAction = ODA_DRAWENTIRE;
776 dis.itemState = itemState;
778 dis.rcItem = rectEdit;
779 dis.itemData = SendMessageW(lphc->hWndLBox, LB_GETITEMDATA,
783 * Clip the DC and have the parent draw the item.
785 IntersectClipRect(hdc,
786 rectEdit.left, rectEdit.top,
787 rectEdit.right, rectEdit.bottom);
789 SendMessageW(lphc->owner, WM_DRAWITEM, ctlid, (LPARAM)&dis );
792 * Reset the clipping region.
794 SelectClipRgn(hdc, clipRegion);
798 static const WCHAR empty_stringW[] = { 0 };
800 if ( (lphc->wState & CBF_FOCUSED) &&
801 !(lphc->wState & CBF_DROPPED) ) {
804 FillRect( hdc, &rectEdit, GetSysColorBrush(COLOR_HIGHLIGHT) );
805 SetBkColor( hdc, GetSysColor( COLOR_HIGHLIGHT ) );
806 SetTextColor( hdc, GetSysColor( COLOR_HIGHLIGHTTEXT ) );
812 ETO_OPAQUE | ETO_CLIPPED,
814 pText ? pText : empty_stringW , size, NULL );
816 if(lphc->wState & CBF_FOCUSED && !(lphc->wState & CBF_DROPPED))
817 DrawFocusRect( hdc, &rectEdit );
821 SelectObject(hdc, hPrevFont );
823 HeapFree( GetProcessHeap(), 0, pText );
826 /***********************************************************************
829 static void CBPaintBorder(
831 const HEADCOMBO *lphc,
836 if (CB_GETTYPE(lphc) != CBS_SIMPLE)
838 GetClientRect(hwnd, &clientRect);
842 CopyRect(&clientRect, &lphc->textRect);
844 InflateRect(&clientRect, EDIT_CONTROL_PADDING(), EDIT_CONTROL_PADDING());
845 InflateRect(&clientRect, COMBO_XBORDERSIZE(), COMBO_YBORDERSIZE());
848 DrawEdge(hdc, &clientRect, EDGE_SUNKEN, BF_RECT);
851 /***********************************************************************
852 * COMBO_PrepareColors
854 * This method will sent the appropriate WM_CTLCOLOR message to
855 * prepare and setup the colors for the combo's DC.
857 * It also returns the brush to use for the background.
859 static HBRUSH COMBO_PrepareColors(
866 * Get the background brush for this control.
868 if (CB_DISABLED(lphc))
870 hBkgBrush = (HBRUSH)SendMessageW(lphc->owner, WM_CTLCOLORSTATIC,
871 (WPARAM)hDC, (LPARAM)lphc->self );
874 * We have to change the text color since WM_CTLCOLORSTATIC will
875 * set it to the "enabled" color. This is the same behavior as the
878 SetTextColor(hDC, GetSysColor(COLOR_GRAYTEXT));
882 /* FIXME: In which cases WM_CTLCOLORLISTBOX should be sent? */
883 hBkgBrush = (HBRUSH)SendMessageW(lphc->owner, WM_CTLCOLOREDIT,
884 (WPARAM)hDC, (LPARAM)lphc->self );
891 hBkgBrush = GetSysColorBrush(COLOR_WINDOW);
897 /***********************************************************************
900 static LRESULT COMBO_Paint(LPHEADCOMBO lphc, HDC hParamDC)
905 hDC = (hParamDC) ? hParamDC
906 : BeginPaint( lphc->self, &ps);
908 TRACE("hdc=%p\n", hDC);
910 if( hDC && !(lphc->wState & CBF_NOREDRAW) )
912 HBRUSH hPrevBrush, hBkgBrush;
915 * Retrieve the background brush and select it in the
918 hBkgBrush = COMBO_PrepareColors(lphc, hDC);
920 hPrevBrush = SelectObject( hDC, hBkgBrush );
921 if (!(lphc->wState & CBF_EDIT))
922 FillRect(hDC, &lphc->textRect, hBkgBrush);
925 * In non 3.1 look, there is a sunken border on the combobox
927 CBPaintBorder(lphc->self, lphc, hDC);
929 if( !IsRectEmpty(&lphc->buttonRect) )
931 CBPaintButton(lphc, hDC, lphc->buttonRect);
934 /* paint the edit control padding area */
935 if (CB_GETTYPE(lphc) != CBS_DROPDOWNLIST)
937 RECT rPadEdit = lphc->textRect;
939 InflateRect(&rPadEdit, EDIT_CONTROL_PADDING(), EDIT_CONTROL_PADDING());
941 FrameRect( hDC, &rPadEdit, GetSysColorBrush(COLOR_WINDOW) );
944 if( !(lphc->wState & CBF_EDIT) )
945 CBPaintText( lphc, hDC, lphc->textRect);
948 SelectObject( hDC, hPrevBrush );
952 EndPaint(lphc->self, &ps);
957 /***********************************************************************
960 * Select listbox entry according to the contents of the edit control.
962 static INT CBUpdateLBox( LPHEADCOMBO lphc, BOOL bSelect )
968 length = SendMessageW( lphc->hWndEdit, WM_GETTEXTLENGTH, 0, 0 );
971 pText = HeapAlloc( GetProcessHeap(), 0, (length + 1) * sizeof(WCHAR));
973 TRACE("\t edit text length %i\n", length );
977 GetWindowTextW( lphc->hWndEdit, pText, length + 1);
978 idx = SendMessageW(lphc->hWndLBox, LB_FINDSTRING,
979 (WPARAM)(-1), (LPARAM)pText );
980 HeapFree( GetProcessHeap(), 0, pText );
983 SendMessageW(lphc->hWndLBox, LB_SETCURSEL, (WPARAM)(bSelect ? idx : -1), 0);
985 /* probably superfluous but Windows sends this too */
986 SendMessageW(lphc->hWndLBox, LB_SETCARETINDEX, (WPARAM)(idx < 0 ? 0 : idx), 0);
987 SendMessageW(lphc->hWndLBox, LB_SETTOPINDEX, (WPARAM)(idx < 0 ? 0 : idx), 0);
992 /***********************************************************************
995 * Copy a listbox entry to the edit control.
997 static void CBUpdateEdit( LPHEADCOMBO lphc , INT index )
1000 LPWSTR pText = NULL;
1001 static const WCHAR empty_stringW[] = { 0 };
1003 TRACE("\t %i\n", index );
1005 if( index >= 0 ) /* got an entry */
1007 length = SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, (WPARAM)index, 0);
1008 if( length != LB_ERR)
1010 if( (pText = HeapAlloc( GetProcessHeap(), 0, (length + 1) * sizeof(WCHAR))) )
1012 SendMessageW(lphc->hWndLBox, LB_GETTEXT,
1013 (WPARAM)index, (LPARAM)pText );
1018 if( CB_HASSTRINGS(lphc) )
1020 lphc->wState |= (CBF_NOEDITNOTIFY | CBF_NOLBSELECT);
1021 SendMessageW(lphc->hWndEdit, WM_SETTEXT, 0, pText ? (LPARAM)pText : (LPARAM)empty_stringW);
1022 lphc->wState &= ~(CBF_NOEDITNOTIFY | CBF_NOLBSELECT);
1025 if( lphc->wState & CBF_FOCUSED )
1026 SendMessageW(lphc->hWndEdit, EM_SETSEL, 0, (LPARAM)(-1));
1028 HeapFree( GetProcessHeap(), 0, pText );
1031 /***********************************************************************
1034 * Show listbox popup.
1036 static void CBDropDown( LPHEADCOMBO lphc )
1039 MONITORINFO mon_info;
1044 TRACE("[%p]: drop down\n", lphc->self);
1046 CB_NOTIFY( lphc, CBN_DROPDOWN );
1050 lphc->wState |= CBF_DROPPED;
1051 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
1053 lphc->droppedIndex = CBUpdateLBox( lphc, TRUE );
1055 /* Update edit only if item is in the list */
1056 if( !(lphc->wState & CBF_CAPTURE) && lphc->droppedIndex >= 0)
1057 CBUpdateEdit( lphc, lphc->droppedIndex );
1061 lphc->droppedIndex = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
1063 SendMessageW(lphc->hWndLBox, LB_SETTOPINDEX,
1064 (WPARAM)(lphc->droppedIndex == LB_ERR ? 0 : lphc->droppedIndex), 0 );
1065 SendMessageW(lphc->hWndLBox, LB_CARETON, 0, 0);
1068 /* now set popup position */
1069 GetWindowRect( lphc->self, &rect );
1072 * If it's a dropdown, the listbox is offset
1074 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
1075 rect.left += COMBO_EDITBUTTONSPACE();
1077 /* if the dropped height is greater than the total height of the dropped
1078 items list, then force the drop down list height to be the total height
1079 of the items in the dropped list */
1081 /* And Remove any extra space (Best Fit) */
1082 nDroppedHeight = lphc->droppedRect.bottom - lphc->droppedRect.top;
1083 /* if listbox length has been set directly by its handle */
1084 GetWindowRect(lphc->hWndLBox, &r);
1085 if (nDroppedHeight < r.bottom - r.top)
1086 nDroppedHeight = r.bottom - r.top;
1087 nItems = (int)SendMessageW(lphc->hWndLBox, LB_GETCOUNT, 0, 0);
1094 nIHeight = (int)SendMessageW(lphc->hWndLBox, LB_GETITEMHEIGHT, 0, 0);
1096 nHeight = nIHeight*nItems;
1098 if (nHeight < nDroppedHeight - COMBO_YBORDERSIZE())
1099 nDroppedHeight = nHeight + COMBO_YBORDERSIZE();
1101 if (nDroppedHeight < nHeight)
1104 nDroppedHeight = (nItems+1)*nIHeight;
1105 else if (nDroppedHeight < 6*nIHeight)
1106 nDroppedHeight = 6*nIHeight;
1110 /*If height of dropped rectangle gets beyond a screen size it should go up, otherwise down.*/
1111 monitor = MonitorFromRect( &rect, MONITOR_DEFAULTTOPRIMARY );
1112 mon_info.cbSize = sizeof(mon_info);
1113 GetMonitorInfoW( monitor, &mon_info );
1115 if( (rect.bottom + nDroppedHeight) >= mon_info.rcWork.bottom )
1116 rect.bottom = rect.top - nDroppedHeight;
1118 SetWindowPos( lphc->hWndLBox, HWND_TOP, rect.left, rect.bottom,
1119 lphc->droppedRect.right - lphc->droppedRect.left,
1121 SWP_NOACTIVATE | SWP_SHOWWINDOW);
1124 if( !(lphc->wState & CBF_NOREDRAW) )
1125 RedrawWindow( lphc->self, NULL, 0, RDW_INVALIDATE |
1126 RDW_ERASE | RDW_UPDATENOW | RDW_NOCHILDREN );
1128 EnableWindow( lphc->hWndLBox, TRUE );
1129 if (GetCapture() != lphc->self)
1130 SetCapture(lphc->hWndLBox);
1133 /***********************************************************************
1136 * Hide listbox popup.
1138 static void CBRollUp( LPHEADCOMBO lphc, BOOL ok, BOOL bButton )
1140 HWND hWnd = lphc->self;
1142 TRACE("[%p]: sel ok? [%i] dropped? [%i]\n",
1143 lphc->self, ok, (INT)(lphc->wState & CBF_DROPPED));
1145 CB_NOTIFY( lphc, (ok) ? CBN_SELENDOK : CBN_SELENDCANCEL );
1147 if( IsWindow( hWnd ) && CB_GETTYPE(lphc) != CBS_SIMPLE )
1150 if( lphc->wState & CBF_DROPPED )
1154 lphc->wState &= ~CBF_DROPPED;
1155 ShowWindow( lphc->hWndLBox, SW_HIDE );
1157 if(GetCapture() == lphc->hWndLBox)
1162 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
1164 rect = lphc->buttonRect;
1175 rect = lphc->textRect;
1180 if( bButton && !(lphc->wState & CBF_NOREDRAW) )
1181 RedrawWindow( hWnd, &rect, 0, RDW_INVALIDATE |
1182 RDW_ERASE | RDW_UPDATENOW | RDW_NOCHILDREN );
1183 CB_NOTIFY( lphc, CBN_CLOSEUP );
1188 /***********************************************************************
1191 * Used by the ComboLBox to show/hide itself in response to VK_F4, etc...
1193 BOOL COMBO_FlipListbox( LPHEADCOMBO lphc, BOOL ok, BOOL bRedrawButton )
1195 if( lphc->wState & CBF_DROPPED )
1197 CBRollUp( lphc, ok, bRedrawButton );
1205 /***********************************************************************
1208 static void CBRepaintButton( LPHEADCOMBO lphc )
1210 InvalidateRect(lphc->self, &lphc->buttonRect, TRUE);
1211 UpdateWindow(lphc->self);
1214 /***********************************************************************
1217 static void COMBO_SetFocus( LPHEADCOMBO lphc )
1219 if( !(lphc->wState & CBF_FOCUSED) )
1221 if( CB_GETTYPE(lphc) == CBS_DROPDOWNLIST )
1222 SendMessageW(lphc->hWndLBox, LB_CARETON, 0, 0);
1224 /* This is wrong. Message sequences seem to indicate that this
1225 is set *after* the notify. */
1226 /* lphc->wState |= CBF_FOCUSED; */
1228 if( !(lphc->wState & CBF_EDIT) )
1229 InvalidateRect(lphc->self, &lphc->textRect, TRUE);
1231 CB_NOTIFY( lphc, CBN_SETFOCUS );
1232 lphc->wState |= CBF_FOCUSED;
1236 /***********************************************************************
1239 static void COMBO_KillFocus( LPHEADCOMBO lphc )
1241 HWND hWnd = lphc->self;
1243 if( lphc->wState & CBF_FOCUSED )
1245 CBRollUp( lphc, FALSE, TRUE );
1246 if( IsWindow( hWnd ) )
1248 if( CB_GETTYPE(lphc) == CBS_DROPDOWNLIST )
1249 SendMessageW(lphc->hWndLBox, LB_CARETOFF, 0, 0);
1251 lphc->wState &= ~CBF_FOCUSED;
1254 if( !(lphc->wState & CBF_EDIT) )
1255 InvalidateRect(lphc->self, &lphc->textRect, TRUE);
1257 CB_NOTIFY( lphc, CBN_KILLFOCUS );
1262 /***********************************************************************
1265 static LRESULT COMBO_Command( LPHEADCOMBO lphc, WPARAM wParam, HWND hWnd )
1267 if ( lphc->wState & CBF_EDIT && lphc->hWndEdit == hWnd )
1269 /* ">> 8" makes gcc generate jump-table instead of cmp ladder */
1271 switch( HIWORD(wParam) >> 8 )
1273 case (EN_SETFOCUS >> 8):
1275 TRACE("[%p]: edit [%p] got focus\n", lphc->self, lphc->hWndEdit );
1277 COMBO_SetFocus( lphc );
1280 case (EN_KILLFOCUS >> 8):
1282 TRACE("[%p]: edit [%p] lost focus\n", lphc->self, lphc->hWndEdit );
1284 /* NOTE: it seems that Windows' edit control sends an
1285 * undocumented message WM_USER + 0x1B instead of this
1286 * notification (only when it happens to be a part of
1287 * the combo). ?? - AK.
1290 COMBO_KillFocus( lphc );
1294 case (EN_CHANGE >> 8):
1296 * In some circumstances (when the selection of the combobox
1297 * is changed for example) we don't want the EN_CHANGE notification
1298 * to be forwarded to the parent of the combobox. This code
1299 * checks a flag that is set in these occasions and ignores the
1302 if (lphc->wState & CBF_NOLBSELECT)
1304 lphc->wState &= ~CBF_NOLBSELECT;
1308 CBUpdateLBox( lphc, lphc->wState & CBF_DROPPED );
1311 if (!(lphc->wState & CBF_NOEDITNOTIFY))
1312 CB_NOTIFY( lphc, CBN_EDITCHANGE );
1315 case (EN_UPDATE >> 8):
1316 if (!(lphc->wState & CBF_NOEDITNOTIFY))
1317 CB_NOTIFY( lphc, CBN_EDITUPDATE );
1320 case (EN_ERRSPACE >> 8):
1321 CB_NOTIFY( lphc, CBN_ERRSPACE );
1324 else if( lphc->hWndLBox == hWnd )
1326 switch( (short)HIWORD(wParam) )
1329 CB_NOTIFY( lphc, CBN_ERRSPACE );
1333 CB_NOTIFY( lphc, CBN_DBLCLK );
1339 TRACE("[%p]: lbox selection change [%x]\n", lphc->self, lphc->wState );
1341 /* do not roll up if selection is being tracked
1342 * by arrow keys in the dropdown listbox */
1343 if (!(lphc->wState & CBF_NOROLLUP))
1345 CBRollUp( lphc, (HIWORD(wParam) == LBN_SELCHANGE), TRUE );
1347 else lphc->wState &= ~CBF_NOROLLUP;
1349 CB_NOTIFY( lphc, CBN_SELCHANGE );
1351 if( HIWORD(wParam) == LBN_SELCHANGE)
1353 if( lphc->wState & CBF_EDIT )
1355 INT index = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
1356 lphc->wState |= CBF_NOLBSELECT;
1357 CBUpdateEdit( lphc, index );
1358 /* select text in edit, as Windows does */
1359 SendMessageW(lphc->hWndEdit, EM_SETSEL, 0, (LPARAM)(-1));
1363 InvalidateRect(lphc->self, &lphc->textRect, TRUE);
1364 UpdateWindow(lphc->self);
1371 /* nothing to do here since ComboLBox always resets the focus to its
1372 * combo/edit counterpart */
1379 /***********************************************************************
1382 * Fixup an ownerdrawn item operation and pass it up to the combobox owner.
1384 static LRESULT COMBO_ItemOp( LPHEADCOMBO lphc, UINT msg, LPARAM lParam )
1386 HWND hWnd = lphc->self;
1387 UINT id = (UINT)GetWindowLongPtrW( hWnd, GWLP_ID );
1389 TRACE("[%p]: ownerdraw op %04x\n", lphc->self, msg );
1395 DELETEITEMSTRUCT *lpIS = (DELETEITEMSTRUCT *)lParam;
1396 lpIS->CtlType = ODT_COMBOBOX;
1398 lpIS->hwndItem = hWnd;
1403 DRAWITEMSTRUCT *lpIS = (DRAWITEMSTRUCT *)lParam;
1404 lpIS->CtlType = ODT_COMBOBOX;
1406 lpIS->hwndItem = hWnd;
1409 case WM_COMPAREITEM:
1411 COMPAREITEMSTRUCT *lpIS = (COMPAREITEMSTRUCT *)lParam;
1412 lpIS->CtlType = ODT_COMBOBOX;
1414 lpIS->hwndItem = hWnd;
1417 case WM_MEASUREITEM:
1419 MEASUREITEMSTRUCT *lpIS = (MEASUREITEMSTRUCT *)lParam;
1420 lpIS->CtlType = ODT_COMBOBOX;
1425 return SendMessageW(lphc->owner, msg, id, lParam);
1429 /***********************************************************************
1432 static LRESULT COMBO_GetTextW( LPHEADCOMBO lphc, INT count, LPWSTR buf )
1436 if( lphc->wState & CBF_EDIT )
1437 return SendMessageW( lphc->hWndEdit, WM_GETTEXT, count, (LPARAM)buf );
1439 /* get it from the listbox */
1441 if (!count || !buf) return 0;
1442 if( lphc->hWndLBox )
1444 INT idx = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
1445 if (idx == LB_ERR) goto error;
1446 length = SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, idx, 0 );
1447 if (length == LB_ERR) goto error;
1449 /* 'length' is without the terminating character */
1450 if (length >= count)
1452 LPWSTR lpBuffer = HeapAlloc(GetProcessHeap(), 0, (length + 1) * sizeof(WCHAR));
1453 if (!lpBuffer) goto error;
1454 length = SendMessageW(lphc->hWndLBox, LB_GETTEXT, idx, (LPARAM)lpBuffer);
1456 /* truncate if buffer is too short */
1457 if (length != LB_ERR)
1459 lstrcpynW( buf, lpBuffer, count );
1462 HeapFree( GetProcessHeap(), 0, lpBuffer );
1464 else length = SendMessageW(lphc->hWndLBox, LB_GETTEXT, idx, (LPARAM)buf);
1466 if (length == LB_ERR) return 0;
1470 error: /* error - truncate string, return zero */
1476 /***********************************************************************
1479 * NOTE! LB_GETTEXT does not count terminating \0, WM_GETTEXT does.
1480 * also LB_GETTEXT might return values < 0, WM_GETTEXT doesn't.
1482 static LRESULT COMBO_GetTextA( LPHEADCOMBO lphc, INT count, LPSTR buf )
1486 if( lphc->wState & CBF_EDIT )
1487 return SendMessageA( lphc->hWndEdit, WM_GETTEXT, count, (LPARAM)buf );
1489 /* get it from the listbox */
1491 if (!count || !buf) return 0;
1492 if( lphc->hWndLBox )
1494 INT idx = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
1495 if (idx == LB_ERR) goto error;
1496 length = SendMessageA(lphc->hWndLBox, LB_GETTEXTLEN, idx, 0 );
1497 if (length == LB_ERR) goto error;
1499 /* 'length' is without the terminating character */
1500 if (length >= count)
1502 LPSTR lpBuffer = HeapAlloc(GetProcessHeap(), 0, (length + 1) );
1503 if (!lpBuffer) goto error;
1504 length = SendMessageA(lphc->hWndLBox, LB_GETTEXT, idx, (LPARAM)lpBuffer);
1506 /* truncate if buffer is too short */
1507 if (length != LB_ERR)
1509 lstrcpynA( buf, lpBuffer, count );
1512 HeapFree( GetProcessHeap(), 0, lpBuffer );
1514 else length = SendMessageA(lphc->hWndLBox, LB_GETTEXT, idx, (LPARAM)buf);
1516 if (length == LB_ERR) return 0;
1520 error: /* error - truncate string, return zero */
1526 /***********************************************************************
1529 * This function sets window positions according to the updated
1530 * component placement struct.
1532 static void CBResetPos(
1534 const RECT *rectEdit,
1538 BOOL bDrop = (CB_GETTYPE(lphc) != CBS_SIMPLE);
1540 /* NOTE: logs sometimes have WM_LBUTTONUP before a cascade of
1541 * sizing messages */
1543 if( lphc->wState & CBF_EDIT )
1544 SetWindowPos( lphc->hWndEdit, 0,
1545 rectEdit->left, rectEdit->top,
1546 rectEdit->right - rectEdit->left,
1547 rectEdit->bottom - rectEdit->top,
1548 SWP_NOZORDER | SWP_NOACTIVATE | ((bDrop) ? SWP_NOREDRAW : 0) );
1550 SetWindowPos( lphc->hWndLBox, 0,
1551 rectLB->left, rectLB->top,
1552 rectLB->right - rectLB->left,
1553 rectLB->bottom - rectLB->top,
1554 SWP_NOACTIVATE | SWP_NOZORDER | ((bDrop) ? SWP_NOREDRAW : 0) );
1558 if( lphc->wState & CBF_DROPPED )
1560 lphc->wState &= ~CBF_DROPPED;
1561 ShowWindow( lphc->hWndLBox, SW_HIDE );
1564 if( bRedraw && !(lphc->wState & CBF_NOREDRAW) )
1565 RedrawWindow( lphc->self, NULL, 0,
1566 RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW );
1571 /***********************************************************************
1574 static void COMBO_Size( LPHEADCOMBO lphc, BOOL bRedraw )
1576 CBCalcPlacement(lphc->self,
1580 &lphc->droppedRect);
1582 CBResetPos( lphc, &lphc->textRect, &lphc->droppedRect, bRedraw );
1586 /***********************************************************************
1589 static void COMBO_Font( LPHEADCOMBO lphc, HFONT hFont, BOOL bRedraw )
1594 lphc->hFont = hFont;
1597 * Propagate to owned windows.
1599 if( lphc->wState & CBF_EDIT )
1600 SendMessageW(lphc->hWndEdit, WM_SETFONT, (WPARAM)hFont, bRedraw);
1601 SendMessageW(lphc->hWndLBox, WM_SETFONT, (WPARAM)hFont, bRedraw);
1604 * Redo the layout of the control.
1606 if ( CB_GETTYPE(lphc) == CBS_SIMPLE)
1608 CBCalcPlacement(lphc->self,
1612 &lphc->droppedRect);
1614 CBResetPos( lphc, &lphc->textRect, &lphc->droppedRect, TRUE );
1618 CBForceDummyResize(lphc);
1623 /***********************************************************************
1624 * COMBO_SetItemHeight
1626 static LRESULT COMBO_SetItemHeight( LPHEADCOMBO lphc, INT index, INT height )
1628 LRESULT lRet = CB_ERR;
1630 if( index == -1 ) /* set text field height */
1632 if( height < 32768 )
1634 lphc->editHeight = height + 2; /* Is the 2 for 2*EDIT_CONTROL_PADDING? */
1637 * Redo the layout of the control.
1639 if ( CB_GETTYPE(lphc) == CBS_SIMPLE)
1641 CBCalcPlacement(lphc->self,
1645 &lphc->droppedRect);
1647 CBResetPos( lphc, &lphc->textRect, &lphc->droppedRect, TRUE );
1651 CBForceDummyResize(lphc);
1657 else if ( CB_OWNERDRAWN(lphc) ) /* set listbox item height */
1658 lRet = SendMessageW(lphc->hWndLBox, LB_SETITEMHEIGHT,
1659 (WPARAM)index, (LPARAM)height );
1663 /***********************************************************************
1664 * COMBO_SelectString
1666 static LRESULT COMBO_SelectString( LPHEADCOMBO lphc, INT start, LPARAM pText, BOOL unicode )
1668 INT index = unicode ? SendMessageW(lphc->hWndLBox, LB_SELECTSTRING, (WPARAM)start, pText) :
1669 SendMessageA(lphc->hWndLBox, LB_SELECTSTRING, (WPARAM)start, pText);
1672 if( lphc->wState & CBF_EDIT )
1673 CBUpdateEdit( lphc, index );
1676 InvalidateRect(lphc->self, &lphc->textRect, TRUE);
1679 return (LRESULT)index;
1682 /***********************************************************************
1685 static void COMBO_LButtonDown( LPHEADCOMBO lphc, LPARAM lParam )
1689 HWND hWnd = lphc->self;
1691 pt.x = (short)LOWORD(lParam);
1692 pt.y = (short)HIWORD(lParam);
1693 bButton = PtInRect(&lphc->buttonRect, pt);
1695 if( (CB_GETTYPE(lphc) == CBS_DROPDOWNLIST) ||
1696 (bButton && (CB_GETTYPE(lphc) == CBS_DROPDOWN)) )
1698 lphc->wState |= CBF_BUTTONDOWN;
1699 if( lphc->wState & CBF_DROPPED )
1701 /* got a click to cancel selection */
1703 lphc->wState &= ~CBF_BUTTONDOWN;
1704 CBRollUp( lphc, TRUE, FALSE );
1705 if( !IsWindow( hWnd ) ) return;
1707 if( lphc->wState & CBF_CAPTURE )
1709 lphc->wState &= ~CBF_CAPTURE;
1715 /* drop down the listbox and start tracking */
1717 lphc->wState |= CBF_CAPTURE;
1721 if( bButton ) CBRepaintButton( lphc );
1725 /***********************************************************************
1728 * Release capture and stop tracking if needed.
1730 static void COMBO_LButtonUp( LPHEADCOMBO lphc )
1732 if( lphc->wState & CBF_CAPTURE )
1734 lphc->wState &= ~CBF_CAPTURE;
1735 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
1737 INT index = CBUpdateLBox( lphc, TRUE );
1738 /* Update edit only if item is in the list */
1741 lphc->wState |= CBF_NOLBSELECT;
1742 CBUpdateEdit( lphc, index );
1743 lphc->wState &= ~CBF_NOLBSELECT;
1747 SetCapture(lphc->hWndLBox);
1750 if( lphc->wState & CBF_BUTTONDOWN )
1752 lphc->wState &= ~CBF_BUTTONDOWN;
1753 CBRepaintButton( lphc );
1757 /***********************************************************************
1760 * Two things to do - track combo button and release capture when
1761 * pointer goes into the listbox.
1763 static void COMBO_MouseMove( LPHEADCOMBO lphc, WPARAM wParam, LPARAM lParam )
1768 pt.x = (short)LOWORD(lParam);
1769 pt.y = (short)HIWORD(lParam);
1771 if( lphc->wState & CBF_BUTTONDOWN )
1775 bButton = PtInRect(&lphc->buttonRect, pt);
1779 lphc->wState &= ~CBF_BUTTONDOWN;
1780 CBRepaintButton( lphc );
1784 GetClientRect( lphc->hWndLBox, &lbRect );
1785 MapWindowPoints( lphc->self, lphc->hWndLBox, &pt, 1 );
1786 if( PtInRect(&lbRect, pt) )
1788 lphc->wState &= ~CBF_CAPTURE;
1790 if( CB_GETTYPE(lphc) == CBS_DROPDOWN ) CBUpdateLBox( lphc, TRUE );
1792 /* hand over pointer tracking */
1793 SendMessageW(lphc->hWndLBox, WM_LBUTTONDOWN, wParam, lParam);
1797 static LRESULT COMBO_GetComboBoxInfo(const HEADCOMBO *lphc, COMBOBOXINFO *pcbi)
1799 if (!pcbi || (pcbi->cbSize < sizeof(COMBOBOXINFO)))
1802 pcbi->rcItem = lphc->textRect;
1803 pcbi->rcButton = lphc->buttonRect;
1804 pcbi->stateButton = 0;
1805 if (lphc->wState & CBF_BUTTONDOWN)
1806 pcbi->stateButton |= STATE_SYSTEM_PRESSED;
1807 if (IsRectEmpty(&lphc->buttonRect))
1808 pcbi->stateButton |= STATE_SYSTEM_INVISIBLE;
1809 pcbi->hwndCombo = lphc->self;
1810 pcbi->hwndItem = lphc->hWndEdit;
1811 pcbi->hwndList = lphc->hWndLBox;
1815 static char *strdupA(LPCSTR str)
1820 if(!str) return NULL;
1823 ret = HeapAlloc(GetProcessHeap(), 0, len + 1);
1824 memcpy(ret, str, len + 1);
1828 /***********************************************************************
1829 * ComboWndProc_common
1831 LRESULT ComboWndProc_common( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam, BOOL unicode )
1833 LPHEADCOMBO lphc = (LPHEADCOMBO)GetWindowLongPtrW( hwnd, 0 );
1835 TRACE("[%p]: msg %s wp %08lx lp %08lx\n",
1836 hwnd, SPY_GetMsgName(message, hwnd), wParam, lParam );
1838 if (!IsWindow(hwnd)) return 0;
1840 if( lphc || message == WM_NCCREATE )
1844 /* System messages */
1848 LONG style = unicode ? ((LPCREATESTRUCTW)lParam)->style :
1849 ((LPCREATESTRUCTA)lParam)->style;
1850 return COMBO_NCCreate(hwnd, style);
1853 COMBO_NCDestroy(lphc);
1854 break;/* -> DefWindowProc */
1862 hwndParent = ((LPCREATESTRUCTW)lParam)->hwndParent;
1863 style = ((LPCREATESTRUCTW)lParam)->style;
1867 hwndParent = ((LPCREATESTRUCTA)lParam)->hwndParent;
1868 style = ((LPCREATESTRUCTA)lParam)->style;
1870 return COMBO_Create(hwnd, lphc, hwndParent, style, unicode);
1873 case WM_PRINTCLIENT:
1876 /* wParam may contain a valid HDC! */
1877 return COMBO_Paint(lphc, (HDC)wParam);
1880 /* do all painting in WM_PAINT like Windows does */
1885 LRESULT result = DLGC_WANTARROWS | DLGC_WANTCHARS;
1886 if (lParam && (((LPMSG)lParam)->message == WM_KEYDOWN))
1888 int vk = (int)((LPMSG)lParam)->wParam;
1890 if ((vk == VK_RETURN || vk == VK_ESCAPE) && (lphc->wState & CBF_DROPPED))
1891 result |= DLGC_WANTMESSAGE;
1895 case WM_WINDOWPOSCHANGING:
1896 return COMBO_WindowPosChanging(hwnd, lphc, (LPWINDOWPOS)lParam);
1897 case WM_WINDOWPOSCHANGED:
1898 /* SetWindowPos can be called on a Combobox to resize its Listbox.
1899 * In that case, the Combobox itself will not be resized, so we won't
1900 * get a WM_SIZE. Since we still want to update the Listbox, we have to
1903 /* we should not force repainting on WM_WINDOWPOSCHANGED, it breaks
1904 * Z-order based painting.
1908 if( lphc->hWndLBox &&
1909 !(lphc->wState & CBF_NORESIZE) ) COMBO_Size( lphc, message == WM_SIZE );
1912 COMBO_Font( lphc, (HFONT)wParam, (BOOL)lParam );
1915 return (LRESULT)lphc->hFont;
1917 if( lphc->wState & CBF_EDIT )
1918 SetFocus( lphc->hWndEdit );
1920 COMBO_SetFocus( lphc );
1924 HWND hwndFocus = WIN_GetFullHandle( (HWND)wParam );
1926 (hwndFocus != lphc->hWndEdit && hwndFocus != lphc->hWndLBox ))
1927 COMBO_KillFocus( lphc );
1931 return COMBO_Command( lphc, wParam, WIN_GetFullHandle( (HWND)lParam ) );
1933 return unicode ? COMBO_GetTextW( lphc, wParam, (LPWSTR)lParam )
1934 : COMBO_GetTextA( lphc, wParam, (LPSTR)lParam );
1936 case WM_GETTEXTLENGTH:
1938 if ((message == WM_GETTEXTLENGTH) && !ISWIN31 && !(lphc->wState & CBF_EDIT))
1940 int j = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
1941 if (j == -1) return 0;
1942 return unicode ? SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, j, 0) :
1943 SendMessageA(lphc->hWndLBox, LB_GETTEXTLEN, j, 0);
1945 else if( lphc->wState & CBF_EDIT )
1948 lphc->wState |= CBF_NOEDITNOTIFY;
1949 ret = unicode ? SendMessageW(lphc->hWndEdit, message, wParam, lParam) :
1950 SendMessageA(lphc->hWndEdit, message, wParam, lParam);
1951 lphc->wState &= ~CBF_NOEDITNOTIFY;
1958 if( lphc->wState & CBF_EDIT )
1960 return unicode ? SendMessageW(lphc->hWndEdit, message, wParam, lParam) :
1961 SendMessageA(lphc->hWndEdit, message, wParam, lParam);
1967 case WM_COMPAREITEM:
1968 case WM_MEASUREITEM:
1969 return COMBO_ItemOp(lphc, message, lParam);
1971 if( lphc->wState & CBF_EDIT )
1972 EnableWindow( lphc->hWndEdit, (BOOL)wParam );
1973 EnableWindow( lphc->hWndLBox, (BOOL)wParam );
1975 /* Force the control to repaint when the enabled state changes. */
1976 InvalidateRect(lphc->self, NULL, TRUE);
1980 lphc->wState &= ~CBF_NOREDRAW;
1982 lphc->wState |= CBF_NOREDRAW;
1984 if( lphc->wState & CBF_EDIT )
1985 SendMessageW(lphc->hWndEdit, message, wParam, lParam);
1986 SendMessageW(lphc->hWndLBox, message, wParam, lParam);
1989 if( KEYDATA_ALT & HIWORD(lParam) )
1990 if( wParam == VK_UP || wParam == VK_DOWN )
1991 COMBO_FlipListbox( lphc, FALSE, FALSE );
2000 if ((wParam == VK_RETURN || wParam == VK_ESCAPE) &&
2001 (lphc->wState & CBF_DROPPED))
2003 CBRollUp( lphc, wParam == VK_RETURN, FALSE );
2006 else if ((wParam == VK_F4) && !(lphc->wState & CBF_EUI))
2008 COMBO_FlipListbox( lphc, FALSE, FALSE );
2012 if( lphc->wState & CBF_EDIT )
2013 hwndTarget = lphc->hWndEdit;
2015 hwndTarget = lphc->hWndLBox;
2017 return unicode ? SendMessageW(hwndTarget, message, wParam, lParam) :
2018 SendMessageA(hwndTarget, message, wParam, lParam);
2020 case WM_LBUTTONDOWN:
2021 if( !(lphc->wState & CBF_FOCUSED) ) SetFocus( lphc->self );
2022 if( lphc->wState & CBF_FOCUSED ) COMBO_LButtonDown( lphc, lParam );
2025 COMBO_LButtonUp( lphc );
2028 if( lphc->wState & CBF_CAPTURE )
2029 COMBO_MouseMove( lphc, wParam, lParam );
2033 if (wParam & (MK_SHIFT | MK_CONTROL))
2034 return unicode ? DefWindowProcW(hwnd, message, wParam, lParam) :
2035 DefWindowProcA(hwnd, message, wParam, lParam);
2037 if (GET_WHEEL_DELTA_WPARAM(wParam) > 0) return SendMessageW(hwnd, WM_KEYDOWN, VK_UP, 0);
2038 if (GET_WHEEL_DELTA_WPARAM(wParam) < 0) return SendMessageW(hwnd, WM_KEYDOWN, VK_DOWN, 0);
2041 /* Combo messages */
2046 if( lphc->dwStyle & CBS_LOWERCASE )
2047 CharLowerW((LPWSTR)lParam);
2048 else if( lphc->dwStyle & CBS_UPPERCASE )
2049 CharUpperW((LPWSTR)lParam);
2050 return SendMessageW(lphc->hWndLBox, LB_ADDSTRING, 0, lParam);
2052 else /* unlike the unicode version, the ansi version does not overwrite
2053 the string if converting case */
2055 char *string = NULL;
2057 if( lphc->dwStyle & CBS_LOWERCASE )
2059 string = strdupA((LPSTR)lParam);
2063 else if( lphc->dwStyle & CBS_UPPERCASE )
2065 string = strdupA((LPSTR)lParam);
2069 ret = SendMessageA(lphc->hWndLBox, LB_ADDSTRING, 0, string ? (LPARAM)string : lParam);
2070 HeapFree(GetProcessHeap(), 0, string);
2073 case CB_INSERTSTRING:
2076 if( lphc->dwStyle & CBS_LOWERCASE )
2077 CharLowerW((LPWSTR)lParam);
2078 else if( lphc->dwStyle & CBS_UPPERCASE )
2079 CharUpperW((LPWSTR)lParam);
2080 return SendMessageW(lphc->hWndLBox, LB_INSERTSTRING, wParam, lParam);
2084 if( lphc->dwStyle & CBS_LOWERCASE )
2085 CharLowerA((LPSTR)lParam);
2086 else if( lphc->dwStyle & CBS_UPPERCASE )
2087 CharUpperA((LPSTR)lParam);
2089 return SendMessageA(lphc->hWndLBox, LB_INSERTSTRING, wParam, lParam);
2091 case CB_DELETESTRING:
2092 return unicode ? SendMessageW(lphc->hWndLBox, LB_DELETESTRING, wParam, 0) :
2093 SendMessageA(lphc->hWndLBox, LB_DELETESTRING, wParam, 0);
2094 case CB_SELECTSTRING:
2095 return COMBO_SelectString(lphc, (INT)wParam, lParam, unicode);
2097 return unicode ? SendMessageW(lphc->hWndLBox, LB_FINDSTRING, wParam, lParam) :
2098 SendMessageA(lphc->hWndLBox, LB_FINDSTRING, wParam, lParam);
2099 case CB_FINDSTRINGEXACT:
2100 return unicode ? SendMessageW(lphc->hWndLBox, LB_FINDSTRINGEXACT, wParam, lParam) :
2101 SendMessageA(lphc->hWndLBox, LB_FINDSTRINGEXACT, wParam, lParam);
2102 case CB_SETITEMHEIGHT:
2103 return COMBO_SetItemHeight( lphc, (INT)wParam, (INT)lParam);
2104 case CB_GETITEMHEIGHT:
2105 if( (INT)wParam >= 0 ) /* listbox item */
2106 return SendMessageW(lphc->hWndLBox, LB_GETITEMHEIGHT, wParam, 0);
2107 return CBGetTextAreaHeight(hwnd, lphc);
2108 case CB_RESETCONTENT:
2109 SendMessageW(lphc->hWndLBox, LB_RESETCONTENT, 0, 0);
2110 if( (lphc->wState & CBF_EDIT) && CB_HASSTRINGS(lphc) )
2112 static const WCHAR empty_stringW[] = { 0 };
2113 SendMessageW(lphc->hWndEdit, WM_SETTEXT, 0, (LPARAM)empty_stringW);
2116 InvalidateRect(lphc->self, NULL, TRUE);
2118 case CB_INITSTORAGE:
2119 return SendMessageW(lphc->hWndLBox, LB_INITSTORAGE, wParam, lParam);
2120 case CB_GETHORIZONTALEXTENT:
2121 return SendMessageW(lphc->hWndLBox, LB_GETHORIZONTALEXTENT, 0, 0);
2122 case CB_SETHORIZONTALEXTENT:
2123 return SendMessageW(lphc->hWndLBox, LB_SETHORIZONTALEXTENT, wParam, 0);
2124 case CB_GETTOPINDEX:
2125 return SendMessageW(lphc->hWndLBox, LB_GETTOPINDEX, 0, 0);
2127 return SendMessageW(lphc->hWndLBox, LB_GETLOCALE, 0, 0);
2129 return SendMessageW(lphc->hWndLBox, LB_SETLOCALE, wParam, 0);
2130 case CB_GETDROPPEDWIDTH:
2131 if( lphc->droppedWidth )
2132 return lphc->droppedWidth;
2133 return lphc->droppedRect.right - lphc->droppedRect.left;
2134 case CB_SETDROPPEDWIDTH:
2135 if( (CB_GETTYPE(lphc) != CBS_SIMPLE) &&
2136 (INT)wParam < 32768 ) lphc->droppedWidth = (INT)wParam;
2138 case CB_GETDROPPEDCONTROLRECT:
2139 if( lParam ) CBGetDroppedControlRect(lphc, (LPRECT)lParam );
2141 case CB_GETDROPPEDSTATE:
2142 return (lphc->wState & CBF_DROPPED) ? TRUE : FALSE;
2144 return unicode ? SendMessageW(lphc->hWndLBox, LB_DIR, wParam, lParam) :
2145 SendMessageA(lphc->hWndLBox, LB_DIR, wParam, lParam);
2147 case CB_SHOWDROPDOWN:
2148 if( CB_GETTYPE(lphc) != CBS_SIMPLE )
2152 if( !(lphc->wState & CBF_DROPPED) )
2156 if( lphc->wState & CBF_DROPPED )
2157 CBRollUp( lphc, FALSE, TRUE );
2161 return SendMessageW(lphc->hWndLBox, LB_GETCOUNT, 0, 0);
2163 return SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
2165 lParam = SendMessageW(lphc->hWndLBox, LB_SETCURSEL, wParam, 0);
2167 SendMessageW(lphc->hWndLBox, LB_SETTOPINDEX, wParam, 0);
2169 /* no LBN_SELCHANGE in this case, update manually */
2170 if( lphc->wState & CBF_EDIT )
2171 CBUpdateEdit( lphc, (INT)wParam );
2173 InvalidateRect(lphc->self, &lphc->textRect, TRUE);
2174 lphc->wState &= ~CBF_SELCHANGE;
2177 return unicode ? SendMessageW(lphc->hWndLBox, LB_GETTEXT, wParam, lParam) :
2178 SendMessageA(lphc->hWndLBox, LB_GETTEXT, wParam, lParam);
2179 case CB_GETLBTEXTLEN:
2180 return unicode ? SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, wParam, 0) :
2181 SendMessageA(lphc->hWndLBox, LB_GETTEXTLEN, wParam, 0);
2182 case CB_GETITEMDATA:
2183 return SendMessageW(lphc->hWndLBox, LB_GETITEMDATA, wParam, 0);
2184 case CB_SETITEMDATA:
2185 return SendMessageW(lphc->hWndLBox, LB_SETITEMDATA, wParam, lParam);
2187 /* Edit checks passed parameters itself */
2188 if( lphc->wState & CBF_EDIT )
2189 return SendMessageW(lphc->hWndEdit, EM_GETSEL, wParam, lParam);
2192 if( lphc->wState & CBF_EDIT )
2193 return SendMessageW(lphc->hWndEdit, EM_SETSEL,
2194 (INT)(SHORT)LOWORD(lParam), (INT)(SHORT)HIWORD(lParam) );
2196 case CB_SETEXTENDEDUI:
2197 if( CB_GETTYPE(lphc) == CBS_SIMPLE )
2200 lphc->wState |= CBF_EUI;
2201 else lphc->wState &= ~CBF_EUI;
2203 case CB_GETEXTENDEDUI:
2204 return (lphc->wState & CBF_EUI) ? TRUE : FALSE;
2205 case CB_GETCOMBOBOXINFO:
2206 return COMBO_GetComboBoxInfo(lphc, (COMBOBOXINFO *)lParam);
2208 if( lphc->wState & CBF_EDIT )
2209 return SendMessageW(lphc->hWndEdit, EM_LIMITTEXT, wParam, lParam);
2211 if (message >= WM_USER)
2212 WARN("unknown msg WM_USER+%04x wp=%04lx lp=%08lx\n",
2213 message - WM_USER, wParam, lParam );
2216 return unicode ? DefWindowProcW(hwnd, message, wParam, lParam) :
2217 DefWindowProcA(hwnd, message, wParam, lParam);
2220 /*************************************************************************
2221 * GetComboBoxInfo (USER32.@)
2223 BOOL WINAPI GetComboBoxInfo(HWND hwndCombo, /* [in] handle to combo box */
2224 PCOMBOBOXINFO pcbi /* [in/out] combo box information */)
2226 TRACE("(%p, %p)\n", hwndCombo, pcbi);
2227 return SendMessageW(hwndCombo, CB_GETCOMBOBOXINFO, 0, (LPARAM)pcbi);