?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
comctl32: Introduce ListBox control.
[wine.git] / dlls / comctl32 / combo.c
blob43b4cb40f1ab11ab22953f34538dbdc20d216440
1 /*
2 * Combo controls
3 *
4 * Copyright 1997 Alex Korobka
5 * Copyright (c) 2005 by Frank Richter
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 *
21 * TODO:
22 * - ComboBox_[GS]etMinVisible()
23 * - CB_GETMINVISIBLE, CB_SETMINVISIBLE
24 * - CB_SETTOPINDEX
25 */
26
27 #include <stdarg.h>
28 #include <string.h>
29
30 #define OEMRESOURCE
31
32 #include "windef.h"
33 #include "winbase.h"
34 #include "wingdi.h"
35 #include "winuser.h"
36 #include "uxtheme.h"
37 #include "vssym32.h"
38 #include "commctrl.h"
39 #include "wine/unicode.h"
40 #include "wine/debug.h"
41
42 #include "comctl32.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(combo);
45
46 /* bits in the dwKeyData */
47 #define KEYDATA_ALT 0x2000
48 #define KEYDATA_PREVSTATE 0x4000
49
50 /*
51 * Additional combo box definitions
52 */
53
54 #define CB_NOTIFY( lphc, code ) \
55 (SendMessageW((lphc)->owner, WM_COMMAND, \
56 MAKEWPARAM(GetWindowLongPtrW((lphc)->self,GWLP_ID), (code)), (LPARAM)(lphc)->self))
57
58 #define CB_DISABLED( lphc ) (!IsWindowEnabled((lphc)->self))
59 #define CB_OWNERDRAWN( lphc ) ((lphc)->dwStyle & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE))
60 #define CB_HASSTRINGS( lphc ) ((lphc)->dwStyle & CBS_HASSTRINGS)
61 #define CB_HWND( lphc ) ((lphc)->self)
62 #define CB_GETTYPE( lphc ) ((lphc)->dwStyle & (CBS_DROPDOWNLIST))
63
64 #define ISWIN31 (LOWORD(GetVersion()) == 0x0a03)
65
66 /*
67 * Drawing globals
68 */
69 static HBITMAP hComboBmp = 0;
70 static UINT CBitHeight, CBitWidth;
71
72 /*
73 * Look and feel dependent "constants"
74 */
75
76 #define COMBO_YBORDERGAP 5
77 #define COMBO_XBORDERSIZE() 2
78 #define COMBO_YBORDERSIZE() 2
79 #define COMBO_EDITBUTTONSPACE() 0
80 #define EDIT_CONTROL_PADDING() 1
81
82 #define ID_CB_LISTBOX 1000
83 #define ID_CB_EDIT 1001
84
85 /***********************************************************************
86 * COMBO_Init
87 *
88 * Load combo button bitmap.
89 */
90 static BOOL COMBO_Init(void)
91 {
92 HDC hDC;
93
94 if( hComboBmp ) return TRUE;
95 if( (hDC = CreateCompatibleDC(0)) )
96 {
97 BOOL bRet = FALSE;
98 if( (hComboBmp = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_COMBO))) )
99 {
100 BITMAP bm;
101 HBITMAP hPrevB;
102 RECT r;
103
104 GetObjectW( hComboBmp, sizeof(bm), &bm );
105 CBitHeight = bm.bmHeight;
106 CBitWidth = bm.bmWidth;
107
108 TRACE("combo bitmap [%i,%i]\n", CBitWidth, CBitHeight );
109
110 hPrevB = SelectObject( hDC, hComboBmp);
111 SetRect( &r, 0, 0, CBitWidth, CBitHeight );
112 InvertRect( hDC, &r );
113 SelectObject( hDC, hPrevB );
114 bRet = TRUE;
115 }
116 DeleteDC( hDC );
117 return bRet;
118 }
119 return FALSE;
120 }
121
122 /***********************************************************************
123 * COMBO_NCCreate
124 */
125 static LRESULT COMBO_NCCreate(HWND hwnd, LONG style)
126 {
127 LPHEADCOMBO lphc;
128
129 if (COMBO_Init() && (lphc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HEADCOMBO))) )
130 {
131 lphc->self = hwnd;
132 SetWindowLongPtrW( hwnd, 0, (LONG_PTR)lphc );
133
134 /* some braindead apps do try to use scrollbar/border flags */
135
136 lphc->dwStyle = style & ~(WS_BORDER | WS_HSCROLL | WS_VSCROLL);
137 SetWindowLongW( hwnd, GWL_STYLE, style & ~(WS_BORDER | WS_HSCROLL | WS_VSCROLL) );
138
139 /*
140 * We also have to remove the client edge style to make sure
141 * we don't end-up with a non client area.
142 */
143 SetWindowLongW( hwnd, GWL_EXSTYLE,
144 GetWindowLongW( hwnd, GWL_EXSTYLE ) & ~WS_EX_CLIENTEDGE );
145
146 if( !(style & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) )
147 lphc->dwStyle |= CBS_HASSTRINGS;
148 if( !(GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_NOPARENTNOTIFY) )
149 lphc->wState |= CBF_NOTIFY;
150
151 TRACE("[%p], style = %08x\n", lphc, lphc->dwStyle );
152 return TRUE;
153 }
154 return FALSE;
155 }
156
157 /***********************************************************************
158 * COMBO_NCDestroy
159 */
160 static LRESULT COMBO_NCDestroy( LPHEADCOMBO lphc )
161 {
162
163 if( lphc )
164 {
165 TRACE("[%p]: freeing storage\n", lphc->self);
166
167 if( (CB_GETTYPE(lphc) != CBS_SIMPLE) && lphc->hWndLBox )
168 DestroyWindow( lphc->hWndLBox );
169
170 SetWindowLongPtrW( lphc->self, 0, 0 );
171 HeapFree( GetProcessHeap(), 0, lphc );
172 }
173 return 0;
174 }
175
176 /***********************************************************************
177 * CBGetTextAreaHeight
178 *
179 * This method will calculate the height of the text area of the
180 * combobox.
181 * The height of the text area is set in two ways.
182 * It can be set explicitly through a combobox message or through a
183 * WM_MEASUREITEM callback.
184 * If this is not the case, the height is set to font height + 4px
185 * This height was determined through experimentation.
186 * CBCalcPlacement will add 2*COMBO_YBORDERSIZE pixels for the border
187 */
188 static INT CBGetTextAreaHeight(
189 HWND hwnd,
190 LPHEADCOMBO lphc)
191 {
192 INT iTextItemHeight;
193
194 if( lphc->editHeight ) /* explicitly set height */
195 {
196 iTextItemHeight = lphc->editHeight;
197 }
198 else
199 {
200 TEXTMETRICW tm;
201 HDC hDC = GetDC(hwnd);
202 HFONT hPrevFont = 0;
203 INT baseUnitY;
204
205 if (lphc->hFont)
206 hPrevFont = SelectObject( hDC, lphc->hFont );
207
208 GetTextMetricsW(hDC, &tm);
209
210 baseUnitY = tm.tmHeight;
211
212 if( hPrevFont )
213 SelectObject( hDC, hPrevFont );
214
215 ReleaseDC(hwnd, hDC);
216
217 iTextItemHeight = baseUnitY + 4;
218 }
219
220 /*
221 * Check the ownerdraw case if we haven't asked the parent the size
222 * of the item yet.
223 */
224 if ( CB_OWNERDRAWN(lphc) &&
225 (lphc->wState & CBF_MEASUREITEM) )
226 {
227 MEASUREITEMSTRUCT measureItem;
228 RECT clientRect;
229 INT originalItemHeight = iTextItemHeight;
230 UINT id = (UINT)GetWindowLongPtrW( lphc->self, GWLP_ID );
231
232 /*
233 * We use the client rect for the width of the item.
234 */
235 GetClientRect(hwnd, &clientRect);
236
237 lphc->wState &= ~CBF_MEASUREITEM;
238
239 /*
240 * Send a first one to measure the size of the text area
241 */
242 measureItem.CtlType = ODT_COMBOBOX;
243 measureItem.CtlID = id;
244 measureItem.itemID = -1;
245 measureItem.itemWidth = clientRect.right;
246 measureItem.itemHeight = iTextItemHeight - 6; /* ownerdrawn cb is taller */
247 measureItem.itemData = 0;
248 SendMessageW(lphc->owner, WM_MEASUREITEM, id, (LPARAM)&measureItem);
249 iTextItemHeight = 6 + measureItem.itemHeight;
250
251 /*
252 * Send a second one in the case of a fixed ownerdraw list to calculate the
253 * size of the list items. (we basically do this on behalf of the listbox)
254 */
255 if (lphc->dwStyle & CBS_OWNERDRAWFIXED)
256 {
257 measureItem.CtlType = ODT_COMBOBOX;
258 measureItem.CtlID = id;
259 measureItem.itemID = 0;
260 measureItem.itemWidth = clientRect.right;
261 measureItem.itemHeight = originalItemHeight;
262 measureItem.itemData = 0;
263 SendMessageW(lphc->owner, WM_MEASUREITEM, id, (LPARAM)&measureItem);
264 lphc->fixedOwnerDrawHeight = measureItem.itemHeight;
265 }
266
267 /*
268 * Keep the size for the next time
269 */
270 lphc->editHeight = iTextItemHeight;
271 }
272
273 return iTextItemHeight;
274 }
275
276 /***********************************************************************
277 * CBForceDummyResize
278 *
279 * The dummy resize is used for listboxes that have a popup to trigger
280 * a re-arranging of the contents of the combobox and the recalculation
281 * of the size of the "real" control window.
282 */
283 static void CBForceDummyResize(
284 LPHEADCOMBO lphc)
285 {
286 RECT windowRect;
287 int newComboHeight;
288
289 newComboHeight = CBGetTextAreaHeight(lphc->self,lphc) + 2*COMBO_YBORDERSIZE();
290
291 GetWindowRect(lphc->self, &windowRect);
292
293 /*
294 * We have to be careful, resizing a combobox also has the meaning that the
295 * dropped rect will be resized. In this case, we want to trigger a resize
296 * to recalculate layout but we don't want to change the dropped rectangle
297 * So, we pass the height of text area of control as the height.
298 * this will cancel-out in the processing of the WM_WINDOWPOSCHANGING
299 * message.
300 */
301 SetWindowPos( lphc->self,
302 NULL,
303 0, 0,
304 windowRect.right - windowRect.left,
305 newComboHeight,
306 SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE );
307 }
308
309 /***********************************************************************
310 * CBCalcPlacement
311 *
312 * Set up component coordinates given valid lphc->RectCombo.
313 */
314 static void CBCalcPlacement(
315 HWND hwnd,
316 LPHEADCOMBO lphc,
317 LPRECT lprEdit,
318 LPRECT lprButton,
319 LPRECT lprLB)
320 {
321 /*
322 * Again, start with the client rectangle.
323 */
324 GetClientRect(hwnd, lprEdit);
325
326 /*
327 * Remove the borders
328 */
329 InflateRect(lprEdit, -COMBO_XBORDERSIZE(), -COMBO_YBORDERSIZE());
330
331 /*
332 * Chop off the bottom part to fit with the height of the text area.
333 */
334 lprEdit->bottom = lprEdit->top + CBGetTextAreaHeight(hwnd, lphc);
335
336 /*
337 * The button starts the same vertical position as the text area.
338 */
339 CopyRect(lprButton, lprEdit);
340
341 /*
342 * If the combobox is "simple" there is no button.
343 */
344 if( CB_GETTYPE(lphc) == CBS_SIMPLE )
345 lprButton->left = lprButton->right = lprButton->bottom = 0;
346 else
347 {
348 /*
349 * Let's assume the combobox button is the same width as the
350 * scrollbar button.
351 * size the button horizontally and cut-off the text area.
352 */
353 lprButton->left = lprButton->right - GetSystemMetrics(SM_CXVSCROLL);
354 lprEdit->right = lprButton->left;
355 }
356
357 /*
358 * In the case of a dropdown, there is an additional spacing between the
359 * text area and the button.
360 */
361 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
362 {
363 lprEdit->right -= COMBO_EDITBUTTONSPACE();
364 }
365
366 /*
367 * If we have an edit control, we space it away from the borders slightly.
368 */
369 if (CB_GETTYPE(lphc) != CBS_DROPDOWNLIST)
370 {
371 InflateRect(lprEdit, -EDIT_CONTROL_PADDING(), -EDIT_CONTROL_PADDING());
372 }
373
374 /*
375 * Adjust the size of the listbox popup.
376 */
377 if( CB_GETTYPE(lphc) == CBS_SIMPLE )
378 {
379 /*
380 * Use the client rectangle to initialize the listbox rectangle
381 */
382 GetClientRect(hwnd, lprLB);
383
384 /*
385 * Then, chop-off the top part.
386 */
387 lprLB->top = lprEdit->bottom + COMBO_YBORDERSIZE();
388 }
389 else
390 {
391 /*
392 * Make sure the dropped width is as large as the combobox itself.
393 */
394 if (lphc->droppedWidth < (lprButton->right + COMBO_XBORDERSIZE()))
395 {
396 lprLB->right = lprLB->left + (lprButton->right + COMBO_XBORDERSIZE());
397
398 /*
399 * In the case of a dropdown, the popup listbox is offset to the right.
400 * so, we want to make sure it's flush with the right side of the
401 * combobox
402 */
403 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
404 lprLB->right -= COMBO_EDITBUTTONSPACE();
405 }
406 else
407 lprLB->right = lprLB->left + lphc->droppedWidth;
408 }
409
410 /* don't allow negative window width */
411 if (lprEdit->right < lprEdit->left)
412 lprEdit->right = lprEdit->left;
413
414 TRACE("\ttext\t= (%s)\n", wine_dbgstr_rect(lprEdit));
415
416 TRACE("\tbutton\t= (%s)\n", wine_dbgstr_rect(lprButton));
417
418 TRACE("\tlbox\t= (%s)\n", wine_dbgstr_rect(lprLB));
419 }
420
421 /***********************************************************************
422 * CBGetDroppedControlRect
423 */
424 static void CBGetDroppedControlRect( LPHEADCOMBO lphc, LPRECT lpRect)
425 {
426 /* In windows, CB_GETDROPPEDCONTROLRECT returns the upper left corner
427 of the combo box and the lower right corner of the listbox */
428
429 GetWindowRect(lphc->self, lpRect);
430
431 lpRect->right = lpRect->left + lphc->droppedRect.right - lphc->droppedRect.left;
432 lpRect->bottom = lpRect->top + lphc->droppedRect.bottom - lphc->droppedRect.top;
433
434 }
435
436 /***********************************************************************
437 * COMBO_Create
438 */
439 static LRESULT COMBO_Create( HWND hwnd, LPHEADCOMBO lphc, HWND hwndParent, LONG style )
440 {
441 static const WCHAR clbName[] = {'C','o','m','b','o','L','B','o','x',0};
442 static const WCHAR editName[] = {'E','d','i','t',0};
443
444 OpenThemeData( hwnd, WC_COMBOBOXW );
445 if( !CB_GETTYPE(lphc) ) lphc->dwStyle |= CBS_SIMPLE;
446 if( CB_GETTYPE(lphc) != CBS_DROPDOWNLIST ) lphc->wState |= CBF_EDIT;
447
448 lphc->owner = hwndParent;
449
450 /*
451 * The item height and dropped width are not set when the control
452 * is created.
453 */
454 lphc->droppedWidth = lphc->editHeight = 0;
455
456 /*
457 * The first time we go through, we want to measure the ownerdraw item
458 */
459 lphc->wState |= CBF_MEASUREITEM;
460
461 /* M$ IE 3.01 actually creates (and rapidly destroys) an ownerless combobox */
462
463 if( lphc->owner || !(style & WS_VISIBLE) )
464 {
465 UINT lbeStyle = 0;
466 UINT lbeExStyle = 0;
467
468 /*
469 * Initialize the dropped rect to the size of the client area of the
470 * control and then, force all the areas of the combobox to be
471 * recalculated.
472 */
473 GetClientRect( hwnd, &lphc->droppedRect );
474 CBCalcPlacement(hwnd, lphc, &lphc->textRect, &lphc->buttonRect, &lphc->droppedRect );
475
476 /*
477 * Adjust the position of the popup listbox if it's necessary
478 */
479 if ( CB_GETTYPE(lphc) != CBS_SIMPLE )
480 {
481 lphc->droppedRect.top = lphc->textRect.bottom + COMBO_YBORDERSIZE();
482
483 /*
484 * If it's a dropdown, the listbox is offset
485 */
486 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
487 lphc->droppedRect.left += COMBO_EDITBUTTONSPACE();
488
489 if (lphc->droppedRect.bottom < lphc->droppedRect.top)
490 lphc->droppedRect.bottom = lphc->droppedRect.top;
491 if (lphc->droppedRect.right < lphc->droppedRect.left)
492 lphc->droppedRect.right = lphc->droppedRect.left;
493 MapWindowPoints( hwnd, 0, (LPPOINT)&lphc->droppedRect, 2 );
494 }
495
496 /* create listbox popup */
497
498 lbeStyle = (LBS_NOTIFY | LBS_COMBOBOX | WS_BORDER | WS_CLIPSIBLINGS | WS_CHILD) |
499 (style & (WS_VSCROLL | CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE));
500
501 if( lphc->dwStyle & CBS_SORT )
502 lbeStyle |= LBS_SORT;
503 if( lphc->dwStyle & CBS_HASSTRINGS )
504 lbeStyle |= LBS_HASSTRINGS;
505 if( lphc->dwStyle & CBS_NOINTEGRALHEIGHT )
506 lbeStyle |= LBS_NOINTEGRALHEIGHT;
507 if( lphc->dwStyle & CBS_DISABLENOSCROLL )
508 lbeStyle |= LBS_DISABLENOSCROLL;
509
510 if( CB_GETTYPE(lphc) == CBS_SIMPLE ) /* child listbox */
511 {
512 lbeStyle |= WS_VISIBLE;
513
514 /*
515 * In win 95 look n feel, the listbox in the simple combobox has
516 * the WS_EXCLIENTEDGE style instead of the WS_BORDER style.
517 */
518 lbeStyle &= ~WS_BORDER;
519 lbeExStyle |= WS_EX_CLIENTEDGE;
520 }
521 else
522 {
523 lbeExStyle |= (WS_EX_TOPMOST | WS_EX_TOOLWINDOW);
524 }
525
526 lphc->hWndLBox = CreateWindowExW(lbeExStyle, clbName, NULL, lbeStyle,
527 lphc->droppedRect.left, lphc->droppedRect.top, lphc->droppedRect.right - lphc->droppedRect.left,
528 lphc->droppedRect.bottom - lphc->droppedRect.top, hwnd, (HMENU)ID_CB_LISTBOX,
529 (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE ), lphc );
530 if( lphc->hWndLBox )
531 {
532 BOOL bEdit = TRUE;
533 lbeStyle = WS_CHILD | WS_VISIBLE | ES_NOHIDESEL | ES_LEFT | ES_COMBO;
534
535 if( lphc->wState & CBF_EDIT )
536 {
537 if( lphc->dwStyle & CBS_OEMCONVERT )
538 lbeStyle |= ES_OEMCONVERT;
539 if( lphc->dwStyle & CBS_AUTOHSCROLL )
540 lbeStyle |= ES_AUTOHSCROLL;
541 if( lphc->dwStyle & CBS_LOWERCASE )
542 lbeStyle |= ES_LOWERCASE;
543 else if( lphc->dwStyle & CBS_UPPERCASE )
544 lbeStyle |= ES_UPPERCASE;
545
546 if (!IsWindowEnabled(hwnd)) lbeStyle |= WS_DISABLED;
547
548 lphc->hWndEdit = CreateWindowExW(0, editName, NULL, lbeStyle,
549 lphc->textRect.left, lphc->textRect.top,
550 lphc->textRect.right - lphc->textRect.left,
551 lphc->textRect.bottom - lphc->textRect.top,
552 hwnd, (HMENU)ID_CB_EDIT,
553 (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE ), NULL );
554 if( !lphc->hWndEdit )
555 bEdit = FALSE;
556 }
557
558 if( bEdit )
559 {
560 if( CB_GETTYPE(lphc) != CBS_SIMPLE )
561 {
562 /* Now do the trick with parent */
563 SetParent(lphc->hWndLBox, HWND_DESKTOP);
564 /*
565 * If the combo is a dropdown, we must resize the control
566 * to fit only the text area and button. To do this,
567 * we send a dummy resize and the WM_WINDOWPOSCHANGING message
568 * will take care of setting the height for us.
569 */
570 CBForceDummyResize(lphc);
571 }
572
573 TRACE("init done\n");
574 return 0;
575 }
576 ERR("edit control failure.\n");
577 } else ERR("listbox failure.\n");
578 } else ERR("no owner for visible combo.\n");
579
580 /* CreateWindow() will send WM_NCDESTROY to cleanup */
581
582 return -1;
583 }
584
585 /***********************************************************************
586 * CBPaintButton
587 *
588 * Paint combo button (normal, pressed, and disabled states).
589 */
590 static void CBPaintButton( LPHEADCOMBO lphc, HDC hdc, RECT rectButton)
591 {
592 UINT buttonState = DFCS_SCROLLCOMBOBOX;
593
594 if( lphc->wState & CBF_NOREDRAW )
595 return;
596
597
598 if (lphc->wState & CBF_BUTTONDOWN)
599 buttonState |= DFCS_PUSHED;
600
601 if (CB_DISABLED(lphc))
602 buttonState |= DFCS_INACTIVE;
603
604 DrawFrameControl(hdc, &rectButton, DFC_SCROLL, buttonState);
605 }
606
607 /***********************************************************************
608 * COMBO_PrepareColors
609 *
610 * This method will sent the appropriate WM_CTLCOLOR message to
611 * prepare and setup the colors for the combo's DC.
612 *
613 * It also returns the brush to use for the background.
614 */
615 static HBRUSH COMBO_PrepareColors(
616 LPHEADCOMBO lphc,
617 HDC hDC)
618 {
619 HBRUSH hBkgBrush;
620
621 /*
622 * Get the background brush for this control.
623 */
624 if (CB_DISABLED(lphc))
625 {
626 hBkgBrush = (HBRUSH)SendMessageW(lphc->owner, WM_CTLCOLORSTATIC,
627 (WPARAM)hDC, (LPARAM)lphc->self );
628
629 /*
630 * We have to change the text color since WM_CTLCOLORSTATIC will
631 * set it to the "enabled" color. This is the same behavior as the
632 * edit control
633 */
634 SetTextColor(hDC, GetSysColor(COLOR_GRAYTEXT));
635 }
636 else
637 {
638 /* FIXME: In which cases WM_CTLCOLORLISTBOX should be sent? */
639 hBkgBrush = (HBRUSH)SendMessageW(lphc->owner, WM_CTLCOLOREDIT,
640 (WPARAM)hDC, (LPARAM)lphc->self );
641 }
642
643 /*
644 * Catch errors.
645 */
646 if( !hBkgBrush )
647 hBkgBrush = GetSysColorBrush(COLOR_WINDOW);
648
649 return hBkgBrush;
650 }
651
652 /***********************************************************************
653 * CBPaintText
654 *
655 * Paint CBS_DROPDOWNLIST text field / update edit control contents.
656 */
657 static void CBPaintText(HEADCOMBO *lphc, HDC hdc_paint)
658 {
659 RECT rectEdit = lphc->textRect;
660 INT id, size = 0;
661 LPWSTR pText = NULL;
662
663 TRACE("\n");
664
665 /* follow Windows combobox that sends a bunch of text
666 * inquiries to its listbox while processing WM_PAINT. */
667
668 if( (id = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0) ) != LB_ERR )
669 {
670 size = SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, id, 0);
671 if (size == LB_ERR)
672 FIXME("LB_ERR probably not handled yet\n");
673 if( (pText = HeapAlloc( GetProcessHeap(), 0, (size + 1) * sizeof(WCHAR))) )
674 {
675 /* size from LB_GETTEXTLEN may be too large, from LB_GETTEXT is accurate */
676 size=SendMessageW(lphc->hWndLBox, LB_GETTEXT, id, (LPARAM)pText);
677 pText[size] = '\0'; /* just in case */
678 } else return;
679 }
680
681 if( lphc->wState & CBF_EDIT )
682 {
683 static const WCHAR empty_stringW[] = { 0 };
684 if( CB_HASSTRINGS(lphc) ) SetWindowTextW( lphc->hWndEdit, pText ? pText : empty_stringW );
685 if( lphc->wState & CBF_FOCUSED )
686 SendMessageW(lphc->hWndEdit, EM_SETSEL, 0, MAXLONG);
687 }
688 else if(!(lphc->wState & CBF_NOREDRAW) && IsWindowVisible( lphc->self ))
689 {
690 /* paint text field ourselves */
691 HDC hdc = hdc_paint ? hdc_paint : GetDC(lphc->self);
692 UINT itemState = ODS_COMBOBOXEDIT;
693 HFONT hPrevFont = (lphc->hFont) ? SelectObject(hdc, lphc->hFont) : 0;
694 HBRUSH hPrevBrush, hBkgBrush;
695
696 /*
697 * Give ourselves some space.
698 */
699 InflateRect( &rectEdit, -1, -1 );
700
701 hBkgBrush = COMBO_PrepareColors( lphc, hdc );
702 hPrevBrush = SelectObject( hdc, hBkgBrush );
703 FillRect( hdc, &rectEdit, hBkgBrush );
704
705 if( CB_OWNERDRAWN(lphc) )
706 {
707 DRAWITEMSTRUCT dis;
708 HRGN clipRegion;
709 UINT ctlid = (UINT)GetWindowLongPtrW( lphc->self, GWLP_ID );
710
711 /* setup state for DRAWITEM message. Owner will highlight */
712 if ( (lphc->wState & CBF_FOCUSED) &&
713 !(lphc->wState & CBF_DROPPED) )
714 itemState |= ODS_SELECTED | ODS_FOCUS;
715
716 if (!IsWindowEnabled(lphc->self)) itemState |= ODS_DISABLED;
717
718 dis.CtlType = ODT_COMBOBOX;
719 dis.CtlID = ctlid;
720 dis.hwndItem = lphc->self;
721 dis.itemAction = ODA_DRAWENTIRE;
722 dis.itemID = id;
723 dis.itemState = itemState;
724 dis.hDC = hdc;
725 dis.rcItem = rectEdit;
726 dis.itemData = SendMessageW(lphc->hWndLBox, LB_GETITEMDATA, id, 0);
727
728 /*
729 * Clip the DC and have the parent draw the item.
730 */
731 clipRegion = set_control_clipping( hdc, &rectEdit );
732
733 SendMessageW(lphc->owner, WM_DRAWITEM, ctlid, (LPARAM)&dis );
734
735 SelectClipRgn( hdc, clipRegion );
736 if (clipRegion) DeleteObject( clipRegion );
737 }
738 else
739 {
740 static const WCHAR empty_stringW[] = { 0 };
741
742 if ( (lphc->wState & CBF_FOCUSED) &&
743 !(lphc->wState & CBF_DROPPED) ) {
744
745 /* highlight */
746 FillRect( hdc, &rectEdit, GetSysColorBrush(COLOR_HIGHLIGHT) );
747 SetBkColor( hdc, GetSysColor( COLOR_HIGHLIGHT ) );
748 SetTextColor( hdc, GetSysColor( COLOR_HIGHLIGHTTEXT ) );
749 }
750
751 ExtTextOutW( hdc,
752 rectEdit.left + 1,
753 rectEdit.top + 1,
754 ETO_OPAQUE | ETO_CLIPPED,
755 &rectEdit,
756 pText ? pText : empty_stringW , size, NULL );
757
758 if(lphc->wState & CBF_FOCUSED && !(lphc->wState & CBF_DROPPED))
759 DrawFocusRect( hdc, &rectEdit );
760 }
761
762 if( hPrevFont )
763 SelectObject(hdc, hPrevFont );
764
765 if( hPrevBrush )
766 SelectObject( hdc, hPrevBrush );
767
768 if( !hdc_paint )
769 ReleaseDC( lphc->self, hdc );
770 }
771 HeapFree( GetProcessHeap(), 0, pText );
772 }
773
774 /***********************************************************************
775 * CBPaintBorder
776 */
777 static void CBPaintBorder(
778 HWND hwnd,
779 const HEADCOMBO *lphc,
780 HDC hdc)
781 {
782 RECT clientRect;
783
784 if (CB_GETTYPE(lphc) != CBS_SIMPLE)
785 {
786 GetClientRect(hwnd, &clientRect);
787 }
788 else
789 {
790 clientRect = lphc->textRect;
791
792 InflateRect(&clientRect, EDIT_CONTROL_PADDING(), EDIT_CONTROL_PADDING());
793 InflateRect(&clientRect, COMBO_XBORDERSIZE(), COMBO_YBORDERSIZE());
794 }
795
796 DrawEdge(hdc, &clientRect, EDGE_SUNKEN, BF_RECT);
797 }
798
799 static LRESULT COMBO_ThemedPaint(HTHEME theme, HEADCOMBO *lphc, HDC hdc)
800 {
801 int button_state;
802 RECT frame;
803
804 /* paint border */
805 if (CB_GETTYPE(lphc) != CBS_SIMPLE)
806 GetClientRect(lphc->self, &frame);
807 else
808 {
809 frame = lphc->textRect;
810 InflateRect(&frame, EDIT_CONTROL_PADDING(), EDIT_CONTROL_PADDING());
811 InflateRect(&frame, COMBO_XBORDERSIZE(), COMBO_YBORDERSIZE());
812 }
813
814 DrawThemeBackground(theme, hdc, 0, IsWindowEnabled(lphc->self) ? CBXS_NORMAL : CBXS_DISABLED, &frame, NULL);
815
816 /* Paint button */
817 if (!IsRectEmpty(&lphc->buttonRect))
818 {
819 if (!IsWindowEnabled(lphc->self))
820 button_state = CBXS_DISABLED;
821 else if (lphc->wState & CBF_BUTTONDOWN)
822 button_state = CBXS_PRESSED;
823 else if (lphc->wState & CBF_HOT)
824 button_state = CBXS_HOT;
825 else
826 button_state = CBXS_NORMAL;
827 DrawThemeBackground(theme, hdc, CP_DROPDOWNBUTTON, button_state, &lphc->buttonRect, NULL);
828 }
829
830 if ((lphc->dwStyle & CBS_DROPDOWNLIST) == CBS_DROPDOWNLIST)
831 CBPaintText(lphc, hdc);
832
833 return 0;
834 }
835
836 /***********************************************************************
837 * COMBO_Paint
838 */
839 static LRESULT COMBO_Paint(HEADCOMBO *lphc, HDC hdc)
840 {
841 HBRUSH hPrevBrush, hBkgBrush;
842
843 TRACE("hdc=%p\n", hdc);
844
845 /*
846 * Retrieve the background brush and select it in the
847 * DC.
848 */
849 hBkgBrush = COMBO_PrepareColors(lphc, hdc);
850 hPrevBrush = SelectObject(hdc, hBkgBrush);
851 if (!(lphc->wState & CBF_EDIT))
852 FillRect(hdc, &lphc->textRect, hBkgBrush);
853
854 /*
855 * In non 3.1 look, there is a sunken border on the combobox
856 */
857 CBPaintBorder(lphc->self, lphc, hdc);
858
859 if (!IsRectEmpty(&lphc->buttonRect))
860 CBPaintButton(lphc, hdc, lphc->buttonRect);
861
862 /* paint the edit control padding area */
863 if (CB_GETTYPE(lphc) != CBS_DROPDOWNLIST)
864 {
865 RECT rPadEdit = lphc->textRect;
866
867 InflateRect(&rPadEdit, EDIT_CONTROL_PADDING(), EDIT_CONTROL_PADDING());
868
869 FrameRect(hdc, &rPadEdit, GetSysColorBrush(COLOR_WINDOW));
870 }
871
872 if (!(lphc->wState & CBF_EDIT))
873 CBPaintText( lphc, hdc );
874
875 if (hPrevBrush)
876 SelectObject( hdc, hPrevBrush );
877
878 return 0;
879 }
880
881 /***********************************************************************
882 * CBUpdateLBox
883 *
884 * Select listbox entry according to the contents of the edit control.
885 */
886 static INT CBUpdateLBox( LPHEADCOMBO lphc, BOOL bSelect )
887 {
888 INT length, idx;
889 LPWSTR pText = NULL;
890
891 idx = LB_ERR;
892 length = SendMessageW( lphc->hWndEdit, WM_GETTEXTLENGTH, 0, 0 );
893
894 if( length > 0 )
895 pText = HeapAlloc( GetProcessHeap(), 0, (length + 1) * sizeof(WCHAR));
896
897 TRACE("\t edit text length %i\n", length );
898
899 if( pText )
900 {
901 GetWindowTextW( lphc->hWndEdit, pText, length + 1);
902 idx = SendMessageW(lphc->hWndLBox, LB_FINDSTRING, -1, (LPARAM)pText);
903 HeapFree( GetProcessHeap(), 0, pText );
904 }
905
906 SendMessageW(lphc->hWndLBox, LB_SETCURSEL, bSelect ? idx : -1, 0);
907
908 /* probably superfluous but Windows sends this too */
909 SendMessageW(lphc->hWndLBox, LB_SETCARETINDEX, idx < 0 ? 0 : idx, 0);
910 SendMessageW(lphc->hWndLBox, LB_SETTOPINDEX, idx < 0 ? 0 : idx, 0);
911
912 return idx;
913 }
914
915 /***********************************************************************
916 * CBUpdateEdit
917 *
918 * Copy a listbox entry to the edit control.
919 */
920 static void CBUpdateEdit( LPHEADCOMBO lphc , INT index )
921 {
922 INT length;
923 LPWSTR pText = NULL;
924 static const WCHAR empty_stringW[] = { 0 };
925
926 TRACE("\t %i\n", index );
927
928 if( index >= 0 ) /* got an entry */
929 {
930 length = SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, index, 0);
931 if( length != LB_ERR)
932 {
933 if( (pText = HeapAlloc( GetProcessHeap(), 0, (length + 1) * sizeof(WCHAR))) )
934 {
935 SendMessageW(lphc->hWndLBox, LB_GETTEXT, index, (LPARAM)pText);
936 }
937 }
938 }
939
940 if( CB_HASSTRINGS(lphc) )
941 {
942 lphc->wState |= (CBF_NOEDITNOTIFY | CBF_NOLBSELECT);
943 SendMessageW(lphc->hWndEdit, WM_SETTEXT, 0, pText ? (LPARAM)pText : (LPARAM)empty_stringW);
944 lphc->wState &= ~(CBF_NOEDITNOTIFY | CBF_NOLBSELECT);
945 }
946
947 if( lphc->wState & CBF_FOCUSED )
948 SendMessageW(lphc->hWndEdit, EM_SETSEL, 0, -1);
949
950 HeapFree( GetProcessHeap(), 0, pText );
951 }
952
953 /***********************************************************************
954 * CBDropDown
955 *
956 * Show listbox popup.
957 */
958 static void CBDropDown( LPHEADCOMBO lphc )
959 {
960 HMONITOR monitor;
961 MONITORINFO mon_info;
962 RECT rect,r;
963 int nItems;
964 int nDroppedHeight;
965
966 TRACE("[%p]: drop down\n", lphc->self);
967
968 CB_NOTIFY( lphc, CBN_DROPDOWN );
969
970 /* set selection */
971
972 lphc->wState |= CBF_DROPPED;
973 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
974 {
975 lphc->droppedIndex = CBUpdateLBox( lphc, TRUE );
976
977 /* Update edit only if item is in the list */
978 if( !(lphc->wState & CBF_CAPTURE) && lphc->droppedIndex >= 0)
979 CBUpdateEdit( lphc, lphc->droppedIndex );
980 }
981 else
982 {
983 lphc->droppedIndex = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
984
985 SendMessageW(lphc->hWndLBox, LB_SETTOPINDEX,
986 lphc->droppedIndex == LB_ERR ? 0 : lphc->droppedIndex, 0);
987 SendMessageW(lphc->hWndLBox, LB_CARETON, 0, 0);
988 }
989
990 /* now set popup position */
991 GetWindowRect( lphc->self, &rect );
992
993 /*
994 * If it's a dropdown, the listbox is offset
995 */
996 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
997 rect.left += COMBO_EDITBUTTONSPACE();
998
999 /* if the dropped height is greater than the total height of the dropped
1000 items list, then force the drop down list height to be the total height
1001 of the items in the dropped list */
1002
1003 /* And Remove any extra space (Best Fit) */
1004 nDroppedHeight = lphc->droppedRect.bottom - lphc->droppedRect.top;
1005 /* if listbox length has been set directly by its handle */
1006 GetWindowRect(lphc->hWndLBox, &r);
1007 if (nDroppedHeight < r.bottom - r.top)
1008 nDroppedHeight = r.bottom - r.top;
1009 nItems = (int)SendMessageW(lphc->hWndLBox, LB_GETCOUNT, 0, 0);
1010
1011 if (nItems > 0)
1012 {
1013 int nHeight;
1014 int nIHeight;
1015
1016 nIHeight = (int)SendMessageW(lphc->hWndLBox, LB_GETITEMHEIGHT, 0, 0);
1017
1018 nHeight = nIHeight*nItems;
1019
1020 if (nHeight < nDroppedHeight - COMBO_YBORDERSIZE())
1021 nDroppedHeight = nHeight + COMBO_YBORDERSIZE();
1022
1023 if (nDroppedHeight < nHeight)
1024 {
1025 if (nItems < 5)
1026 nDroppedHeight = (nItems+1)*nIHeight;
1027 else if (nDroppedHeight < 6*nIHeight)
1028 nDroppedHeight = 6*nIHeight;
1029 }
1030 }
1031
1032 r.left = rect.left;
1033 r.top = rect.bottom;
1034 r.right = r.left + lphc->droppedRect.right - lphc->droppedRect.left;
1035 r.bottom = r.top + nDroppedHeight;
1036
1037 /*If height of dropped rectangle gets beyond a screen size it should go up, otherwise down.*/
1038 monitor = MonitorFromRect( &rect, MONITOR_DEFAULTTOPRIMARY );
1039 mon_info.cbSize = sizeof(mon_info);
1040 GetMonitorInfoW( monitor, &mon_info );
1041
1042 if (r.bottom > mon_info.rcWork.bottom)
1043 {
1044 r.top = max( rect.top - nDroppedHeight, mon_info.rcWork.top );
1045 r.bottom = min( r.top + nDroppedHeight, mon_info.rcWork.bottom );
1046 }
1047
1048 SetWindowPos( lphc->hWndLBox, HWND_TOPMOST, r.left, r.top, r.right - r.left, r.bottom - r.top,
1049 SWP_NOACTIVATE | SWP_SHOWWINDOW );
1050
1051
1052 if( !(lphc->wState & CBF_NOREDRAW) )
1053 RedrawWindow( lphc->self, NULL, 0, RDW_INVALIDATE |
1054 RDW_ERASE | RDW_UPDATENOW | RDW_NOCHILDREN );
1055
1056 EnableWindow( lphc->hWndLBox, TRUE );
1057 if (GetCapture() != lphc->self)
1058 SetCapture(lphc->hWndLBox);
1059 }
1060
1061 /***********************************************************************
1062 * CBRollUp
1063 *
1064 * Hide listbox popup.
1065 */
1066 static void CBRollUp( LPHEADCOMBO lphc, BOOL ok, BOOL bButton )
1067 {
1068 HWND hWnd = lphc->self;
1069
1070 TRACE("[%p]: sel ok? [%i] dropped? [%i]\n",
1071 lphc->self, ok, (INT)(lphc->wState & CBF_DROPPED));
1072
1073 CB_NOTIFY( lphc, (ok) ? CBN_SELENDOK : CBN_SELENDCANCEL );
1074
1075 if( IsWindow( hWnd ) && CB_GETTYPE(lphc) != CBS_SIMPLE )
1076 {
1077
1078 if( lphc->wState & CBF_DROPPED )
1079 {
1080 RECT rect;
1081
1082 lphc->wState &= ~CBF_DROPPED;
1083 ShowWindow( lphc->hWndLBox, SW_HIDE );
1084
1085 if(GetCapture() == lphc->hWndLBox)
1086 {
1087 ReleaseCapture();
1088 }
1089
1090 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
1091 {
1092 rect = lphc->buttonRect;
1093 }
1094 else
1095 {
1096 if( bButton )
1097 {
1098 UnionRect( &rect,
1099 &lphc->buttonRect,
1100 &lphc->textRect);
1101 }
1102 else
1103 rect = lphc->textRect;
1104
1105 bButton = TRUE;
1106 }
1107
1108 if( bButton && !(lphc->wState & CBF_NOREDRAW) )
1109 RedrawWindow( hWnd, &rect, 0, RDW_INVALIDATE |
1110 RDW_ERASE | RDW_UPDATENOW | RDW_NOCHILDREN );
1111 CB_NOTIFY( lphc, CBN_CLOSEUP );
1112 }
1113 }
1114 }
1115
1116 /***********************************************************************
1117 * COMBO_FlipListbox
1118 *
1119 * Used by the ComboLBox to show/hide itself in response to VK_F4, etc...
1120 */
1121 BOOL COMBO_FlipListbox( LPHEADCOMBO lphc, BOOL ok, BOOL bRedrawButton )
1122 {
1123 if( lphc->wState & CBF_DROPPED )
1124 {
1125 CBRollUp( lphc, ok, bRedrawButton );
1126 return FALSE;
1127 }
1128
1129 CBDropDown( lphc );
1130 return TRUE;
1131 }
1132
1133 /***********************************************************************
1134 * CBRepaintButton
1135 */
1136 static void CBRepaintButton( LPHEADCOMBO lphc )
1137 {
1138 InvalidateRect(lphc->self, &lphc->buttonRect, TRUE);
1139 UpdateWindow(lphc->self);
1140 }
1141
1142 /***********************************************************************
1143 * COMBO_SetFocus
1144 */
1145 static void COMBO_SetFocus( LPHEADCOMBO lphc )
1146 {
1147 if( !(lphc->wState & CBF_FOCUSED) )
1148 {
1149 if( CB_GETTYPE(lphc) == CBS_DROPDOWNLIST )
1150 SendMessageW(lphc->hWndLBox, LB_CARETON, 0, 0);
1151
1152 /* This is wrong. Message sequences seem to indicate that this
1153 is set *after* the notify. */
1154 /* lphc->wState |= CBF_FOCUSED; */
1155
1156 if( !(lphc->wState & CBF_EDIT) )
1157 InvalidateRect(lphc->self, &lphc->textRect, TRUE);
1158
1159 CB_NOTIFY( lphc, CBN_SETFOCUS );
1160 lphc->wState |= CBF_FOCUSED;
1161 }
1162 }
1163
1164 /***********************************************************************
1165 * COMBO_KillFocus
1166 */
1167 static void COMBO_KillFocus( LPHEADCOMBO lphc )
1168 {
1169 HWND hWnd = lphc->self;
1170
1171 if( lphc->wState & CBF_FOCUSED )
1172 {
1173 CBRollUp( lphc, FALSE, TRUE );
1174 if( IsWindow( hWnd ) )
1175 {
1176 if( CB_GETTYPE(lphc) == CBS_DROPDOWNLIST )
1177 SendMessageW(lphc->hWndLBox, LB_CARETOFF, 0, 0);
1178
1179 lphc->wState &= ~CBF_FOCUSED;
1180
1181 /* redraw text */
1182 if( !(lphc->wState & CBF_EDIT) )
1183 InvalidateRect(lphc->self, &lphc->textRect, TRUE);
1184
1185 CB_NOTIFY( lphc, CBN_KILLFOCUS );
1186 }
1187 }
1188 }
1189
1190 /***********************************************************************
1191 * COMBO_Command
1192 */
1193 static LRESULT COMBO_Command( LPHEADCOMBO lphc, WPARAM wParam, HWND hWnd )
1194 {
1195 if ( lphc->wState & CBF_EDIT && lphc->hWndEdit == hWnd )
1196 {
1197 /* ">> 8" makes gcc generate jump-table instead of cmp ladder */
1198
1199 switch( HIWORD(wParam) >> 8 )
1200 {
1201 case (EN_SETFOCUS >> 8):
1202
1203 TRACE("[%p]: edit [%p] got focus\n", lphc->self, lphc->hWndEdit );
1204
1205 COMBO_SetFocus( lphc );
1206 break;
1207
1208 case (EN_KILLFOCUS >> 8):
1209
1210 TRACE("[%p]: edit [%p] lost focus\n", lphc->self, lphc->hWndEdit );
1211
1212 /* NOTE: it seems that Windows' edit control sends an
1213 * undocumented message WM_USER + 0x1B instead of this
1214 * notification (only when it happens to be a part of
1215 * the combo). ?? - AK.
1216 */
1217
1218 COMBO_KillFocus( lphc );
1219 break;
1220
1221
1222 case (EN_CHANGE >> 8):
1223 /*
1224 * In some circumstances (when the selection of the combobox
1225 * is changed for example) we don't want the EN_CHANGE notification
1226 * to be forwarded to the parent of the combobox. This code
1227 * checks a flag that is set in these occasions and ignores the
1228 * notification.
1229 */
1230 if (lphc->wState & CBF_NOLBSELECT)
1231 {
1232 lphc->wState &= ~CBF_NOLBSELECT;
1233 }
1234 else
1235 {
1236 CBUpdateLBox( lphc, lphc->wState & CBF_DROPPED );
1237 }
1238
1239 if (!(lphc->wState & CBF_NOEDITNOTIFY))
1240 CB_NOTIFY( lphc, CBN_EDITCHANGE );
1241 break;
1242
1243 case (EN_UPDATE >> 8):
1244 if (!(lphc->wState & CBF_NOEDITNOTIFY))
1245 CB_NOTIFY( lphc, CBN_EDITUPDATE );
1246 break;
1247
1248 case (EN_ERRSPACE >> 8):
1249 CB_NOTIFY( lphc, CBN_ERRSPACE );
1250 }
1251 }
1252 else if( lphc->hWndLBox == hWnd )
1253 {
1254 switch( (short)HIWORD(wParam) )
1255 {
1256 case LBN_ERRSPACE:
1257 CB_NOTIFY( lphc, CBN_ERRSPACE );
1258 break;
1259
1260 case LBN_DBLCLK:
1261 CB_NOTIFY( lphc, CBN_DBLCLK );
1262 break;
1263
1264 case LBN_SELCHANGE:
1265 case LBN_SELCANCEL:
1266
1267 TRACE("[%p]: lbox selection change [%x]\n", lphc->self, lphc->wState );
1268
1269 /* do not roll up if selection is being tracked
1270 * by arrow keys in the dropdown listbox */
1271 if (!(lphc->wState & CBF_NOROLLUP))
1272 {
1273 CBRollUp( lphc, (HIWORD(wParam) == LBN_SELCHANGE), TRUE );
1274 }
1275 else lphc->wState &= ~CBF_NOROLLUP;
1276
1277 CB_NOTIFY( lphc, CBN_SELCHANGE );
1278
1279 if( HIWORD(wParam) == LBN_SELCHANGE)
1280 {
1281 if( lphc->wState & CBF_EDIT )
1282 lphc->wState |= CBF_NOLBSELECT;
1283 CBPaintText( lphc, NULL );
1284 }
1285 break;
1286
1287 case LBN_SETFOCUS:
1288 case LBN_KILLFOCUS:
1289 /* nothing to do here since ComboLBox always resets the focus to its
1290 * combo/edit counterpart */
1291 break;
1292 }
1293 }
1294 return 0;
1295 }
1296
1297 /***********************************************************************
1298 * COMBO_ItemOp
1299 *
1300 * Fixup an ownerdrawn item operation and pass it up to the combobox owner.
1301 */
1302 static LRESULT COMBO_ItemOp( LPHEADCOMBO lphc, UINT msg, LPARAM lParam )
1303 {
1304 HWND hWnd = lphc->self;
1305 UINT id = (UINT)GetWindowLongPtrW( hWnd, GWLP_ID );
1306
1307 TRACE("[%p]: ownerdraw op %04x\n", lphc->self, msg );
1308
1309 switch( msg )
1310 {
1311 case WM_DELETEITEM:
1312 {
1313 DELETEITEMSTRUCT *lpIS = (DELETEITEMSTRUCT *)lParam;
1314 lpIS->CtlType = ODT_COMBOBOX;
1315 lpIS->CtlID = id;
1316 lpIS->hwndItem = hWnd;
1317 break;
1318 }
1319 case WM_DRAWITEM:
1320 {
1321 DRAWITEMSTRUCT *lpIS = (DRAWITEMSTRUCT *)lParam;
1322 lpIS->CtlType = ODT_COMBOBOX;
1323 lpIS->CtlID = id;
1324 lpIS->hwndItem = hWnd;
1325 break;
1326 }
1327 case WM_COMPAREITEM:
1328 {
1329 COMPAREITEMSTRUCT *lpIS = (COMPAREITEMSTRUCT *)lParam;
1330 lpIS->CtlType = ODT_COMBOBOX;
1331 lpIS->CtlID = id;
1332 lpIS->hwndItem = hWnd;
1333 break;
1334 }
1335 case WM_MEASUREITEM:
1336 {
1337 MEASUREITEMSTRUCT *lpIS = (MEASUREITEMSTRUCT *)lParam;
1338 lpIS->CtlType = ODT_COMBOBOX;
1339 lpIS->CtlID = id;
1340 break;
1341 }
1342 }
1343 return SendMessageW(lphc->owner, msg, id, lParam);
1344 }
1345
1346
1347 /***********************************************************************
1348 * COMBO_GetTextW
1349 */
1350 static LRESULT COMBO_GetText( HEADCOMBO *lphc, INT count, LPWSTR buf )
1351 {
1352 INT length;
1353
1354 if( lphc->wState & CBF_EDIT )
1355 return SendMessageW( lphc->hWndEdit, WM_GETTEXT, count, (LPARAM)buf );
1356
1357 /* get it from the listbox */
1358
1359 if (!count || !buf) return 0;
1360 if( lphc->hWndLBox )
1361 {
1362 INT idx = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
1363 if (idx == LB_ERR) goto error;
1364 length = SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, idx, 0 );
1365 if (length == LB_ERR) goto error;
1366
1367 /* 'length' is without the terminating character */
1368 if (length >= count)
1369 {
1370 LPWSTR lpBuffer = HeapAlloc(GetProcessHeap(), 0, (length + 1) * sizeof(WCHAR));
1371 if (!lpBuffer) goto error;
1372 length = SendMessageW(lphc->hWndLBox, LB_GETTEXT, idx, (LPARAM)lpBuffer);
1373
1374 /* truncate if buffer is too short */
1375 if (length != LB_ERR)
1376 {
1377 lstrcpynW( buf, lpBuffer, count );
1378 length = count;
1379 }
1380 HeapFree( GetProcessHeap(), 0, lpBuffer );
1381 }
1382 else length = SendMessageW(lphc->hWndLBox, LB_GETTEXT, idx, (LPARAM)buf);
1383
1384 if (length == LB_ERR) return 0;
1385 return length;
1386 }
1387
1388 error: /* error - truncate string, return zero */
1389 buf[0] = 0;
1390 return 0;
1391 }
1392
1393 /***********************************************************************
1394 * CBResetPos
1395 *
1396 * This function sets window positions according to the updated
1397 * component placement struct.
1398 */
1399 static void CBResetPos(
1400 LPHEADCOMBO lphc,
1401 const RECT *rectEdit,
1402 const RECT *rectLB,
1403 BOOL bRedraw)
1404 {
1405 BOOL bDrop = (CB_GETTYPE(lphc) != CBS_SIMPLE);
1406
1407 /* NOTE: logs sometimes have WM_LBUTTONUP before a cascade of
1408 * sizing messages */
1409
1410 if( lphc->wState & CBF_EDIT )
1411 SetWindowPos( lphc->hWndEdit, 0,
1412 rectEdit->left, rectEdit->top,
1413 rectEdit->right - rectEdit->left,
1414 rectEdit->bottom - rectEdit->top,
1415 SWP_NOZORDER | SWP_NOACTIVATE | ((bDrop) ? SWP_NOREDRAW : 0) );
1416
1417 SetWindowPos( lphc->hWndLBox, 0,
1418 rectLB->left, rectLB->top,
1419 rectLB->right - rectLB->left,
1420 rectLB->bottom - rectLB->top,
1421 SWP_NOACTIVATE | SWP_NOZORDER | ((bDrop) ? SWP_NOREDRAW : 0) );
1422
1423 if( bDrop )
1424 {
1425 if( lphc->wState & CBF_DROPPED )
1426 {
1427 lphc->wState &= ~CBF_DROPPED;
1428 ShowWindow( lphc->hWndLBox, SW_HIDE );
1429 }
1430
1431 if( bRedraw && !(lphc->wState & CBF_NOREDRAW) )
1432 RedrawWindow( lphc->self, NULL, 0,
1433 RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW );
1434 }
1435 }
1436
1437
1438 /***********************************************************************
1439 * COMBO_Size
1440 */
1441 static void COMBO_Size( LPHEADCOMBO lphc )
1442 {
1443 /*
1444 * Those controls are always the same height. So we have to make sure
1445 * they are not resized to another value.
1446 */
1447 if( CB_GETTYPE(lphc) != CBS_SIMPLE )
1448 {
1449 int newComboHeight, curComboHeight, curComboWidth;
1450 RECT rc;
1451
1452 GetWindowRect(lphc->self, &rc);
1453 curComboHeight = rc.bottom - rc.top;
1454 curComboWidth = rc.right - rc.left;
1455 newComboHeight = CBGetTextAreaHeight(lphc->self, lphc) + 2*COMBO_YBORDERSIZE();
1456
1457 /*
1458 * Resizing a combobox has another side effect, it resizes the dropped
1459 * rectangle as well. However, it does it only if the new height for the
1460 * combobox is more than the height it should have. In other words,
1461 * if the application resizing the combobox only had the intention to resize
1462 * the actual control, for example, to do the layout of a dialog that is
1463 * resized, the height of the dropdown is not changed.
1464 */
1465 if( curComboHeight > newComboHeight )
1466 {
1467 TRACE("oldComboHeight=%d, newComboHeight=%d, oldDropBottom=%d, oldDropTop=%d\n",
1468 curComboHeight, newComboHeight, lphc->droppedRect.bottom,
1469 lphc->droppedRect.top);
1470 lphc->droppedRect.bottom = lphc->droppedRect.top + curComboHeight - newComboHeight;
1471 }
1472 /*
1473 * Restore original height
1474 */
1475 if( curComboHeight != newComboHeight )
1476 SetWindowPos(lphc->self, 0, 0, 0, curComboWidth, newComboHeight,
1477 SWP_NOZORDER|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOREDRAW);
1478 }
1479
1480 CBCalcPlacement(lphc->self,
1481 lphc,
1482 &lphc->textRect,
1483 &lphc->buttonRect,
1484 &lphc->droppedRect);
1485
1486 CBResetPos( lphc, &lphc->textRect, &lphc->droppedRect, TRUE );
1487 }
1488
1489
1490 /***********************************************************************
1491 * COMBO_Font
1492 */
1493 static void COMBO_Font( LPHEADCOMBO lphc, HFONT hFont, BOOL bRedraw )
1494 {
1495 /*
1496 * Set the font
1497 */
1498 lphc->hFont = hFont;
1499
1500 /*
1501 * Propagate to owned windows.
1502 */
1503 if( lphc->wState & CBF_EDIT )
1504 SendMessageW(lphc->hWndEdit, WM_SETFONT, (WPARAM)hFont, bRedraw);
1505 SendMessageW(lphc->hWndLBox, WM_SETFONT, (WPARAM)hFont, bRedraw);
1506
1507 /*
1508 * Redo the layout of the control.
1509 */
1510 if ( CB_GETTYPE(lphc) == CBS_SIMPLE)
1511 {
1512 CBCalcPlacement(lphc->self,
1513 lphc,
1514 &lphc->textRect,
1515 &lphc->buttonRect,
1516 &lphc->droppedRect);
1517
1518 CBResetPos( lphc, &lphc->textRect, &lphc->droppedRect, TRUE );
1519 }
1520 else
1521 {
1522 CBForceDummyResize(lphc);
1523 }
1524 }
1525
1526
1527 /***********************************************************************
1528 * COMBO_SetItemHeight
1529 */
1530 static LRESULT COMBO_SetItemHeight( LPHEADCOMBO lphc, INT index, INT height )
1531 {
1532 LRESULT lRet = CB_ERR;
1533
1534 if( index == -1 ) /* set text field height */
1535 {
1536 if( height < 32768 )
1537 {
1538 lphc->editHeight = height + 2; /* Is the 2 for 2*EDIT_CONTROL_PADDING? */
1539
1540 /*
1541 * Redo the layout of the control.
1542 */
1543 if ( CB_GETTYPE(lphc) == CBS_SIMPLE)
1544 {
1545 CBCalcPlacement(lphc->self,
1546 lphc,
1547 &lphc->textRect,
1548 &lphc->buttonRect,
1549 &lphc->droppedRect);
1550
1551 CBResetPos( lphc, &lphc->textRect, &lphc->droppedRect, TRUE );
1552 }
1553 else
1554 {
1555 CBForceDummyResize(lphc);
1556 }
1557
1558 lRet = height;
1559 }
1560 }
1561 else if ( CB_OWNERDRAWN(lphc) ) /* set listbox item height */
1562 lRet = SendMessageW(lphc->hWndLBox, LB_SETITEMHEIGHT, index, height);
1563 return lRet;
1564 }
1565
1566 /***********************************************************************
1567 * COMBO_SelectString
1568 */
1569 static LRESULT COMBO_SelectString( LPHEADCOMBO lphc, INT start, LPARAM pText)
1570 {
1571 INT index = SendMessageW(lphc->hWndLBox, LB_SELECTSTRING, start, pText);
1572 if( index >= 0 )
1573 {
1574 if( lphc->wState & CBF_EDIT )
1575 CBUpdateEdit( lphc, index );
1576 else
1577 {
1578 InvalidateRect(lphc->self, &lphc->textRect, TRUE);
1579 }
1580 }
1581 return (LRESULT)index;
1582 }
1583
1584 /***********************************************************************
1585 * COMBO_LButtonDown
1586 */
1587 static void COMBO_LButtonDown( LPHEADCOMBO lphc, LPARAM lParam )
1588 {
1589 POINT pt;
1590 BOOL bButton;
1591 HWND hWnd = lphc->self;
1592
1593 pt.x = (short)LOWORD(lParam);
1594 pt.y = (short)HIWORD(lParam);
1595 bButton = PtInRect(&lphc->buttonRect, pt);
1596
1597 if( (CB_GETTYPE(lphc) == CBS_DROPDOWNLIST) ||
1598 (bButton && (CB_GETTYPE(lphc) == CBS_DROPDOWN)) )
1599 {
1600 lphc->wState |= CBF_BUTTONDOWN;
1601 if( lphc->wState & CBF_DROPPED )
1602 {
1603 /* got a click to cancel selection */
1604
1605 lphc->wState &= ~CBF_BUTTONDOWN;
1606 CBRollUp( lphc, TRUE, FALSE );
1607 if( !IsWindow( hWnd ) ) return;
1608
1609 if( lphc->wState & CBF_CAPTURE )
1610 {
1611 lphc->wState &= ~CBF_CAPTURE;
1612 ReleaseCapture();
1613 }
1614 }
1615 else
1616 {
1617 /* drop down the listbox and start tracking */
1618
1619 lphc->wState |= CBF_CAPTURE;
1620 SetCapture( hWnd );
1621 CBDropDown( lphc );
1622 }
1623 if( bButton ) CBRepaintButton( lphc );
1624 }
1625 }
1626
1627 /***********************************************************************
1628 * COMBO_LButtonUp
1629 *
1630 * Release capture and stop tracking if needed.
1631 */
1632 static void COMBO_LButtonUp( LPHEADCOMBO lphc )
1633 {
1634 if( lphc->wState & CBF_CAPTURE )
1635 {
1636 lphc->wState &= ~CBF_CAPTURE;
1637 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
1638 {
1639 INT index = CBUpdateLBox( lphc, TRUE );
1640 /* Update edit only if item is in the list */
1641 if(index >= 0)
1642 {
1643 lphc->wState |= CBF_NOLBSELECT;
1644 CBUpdateEdit( lphc, index );
1645 lphc->wState &= ~CBF_NOLBSELECT;
1646 }
1647 }
1648 ReleaseCapture();
1649 SetCapture(lphc->hWndLBox);
1650 }
1651
1652 if( lphc->wState & CBF_BUTTONDOWN )
1653 {
1654 lphc->wState &= ~CBF_BUTTONDOWN;
1655 CBRepaintButton( lphc );
1656 }
1657 }
1658
1659 /***********************************************************************
1660 * COMBO_MouseMove
1661 *
1662 * Two things to do - track combo button and release capture when
1663 * pointer goes into the listbox.
1664 */
1665 static void COMBO_MouseMove( LPHEADCOMBO lphc, WPARAM wParam, LPARAM lParam )
1666 {
1667 POINT pt;
1668 RECT lbRect;
1669
1670 pt.x = (short)LOWORD(lParam);
1671 pt.y = (short)HIWORD(lParam);
1672
1673 if( lphc->wState & CBF_BUTTONDOWN )
1674 {
1675 BOOL bButton;
1676
1677 bButton = PtInRect(&lphc->buttonRect, pt);
1678
1679 if( !bButton )
1680 {
1681 lphc->wState &= ~CBF_BUTTONDOWN;
1682 CBRepaintButton( lphc );
1683 }
1684 }
1685
1686 GetClientRect( lphc->hWndLBox, &lbRect );
1687 MapWindowPoints( lphc->self, lphc->hWndLBox, &pt, 1 );
1688 if( PtInRect(&lbRect, pt) )
1689 {
1690 lphc->wState &= ~CBF_CAPTURE;
1691 ReleaseCapture();
1692 if( CB_GETTYPE(lphc) == CBS_DROPDOWN ) CBUpdateLBox( lphc, TRUE );
1693
1694 /* hand over pointer tracking */
1695 SendMessageW(lphc->hWndLBox, WM_LBUTTONDOWN, wParam, lParam);
1696 }
1697 }
1698
1699 static LRESULT COMBO_GetComboBoxInfo(const HEADCOMBO *lphc, COMBOBOXINFO *pcbi)
1700 {
1701 if (!pcbi || (pcbi->cbSize < sizeof(COMBOBOXINFO)))
1702 return FALSE;
1703
1704 pcbi->rcItem = lphc->textRect;
1705 pcbi->rcButton = lphc->buttonRect;
1706 pcbi->stateButton = 0;
1707 if (lphc->wState & CBF_BUTTONDOWN)
1708 pcbi->stateButton |= STATE_SYSTEM_PRESSED;
1709 if (IsRectEmpty(&lphc->buttonRect))
1710 pcbi->stateButton |= STATE_SYSTEM_INVISIBLE;
1711 pcbi->hwndCombo = lphc->self;
1712 pcbi->hwndItem = lphc->hWndEdit;
1713 pcbi->hwndList = lphc->hWndLBox;
1714 return TRUE;
1715 }
1716
1717 LRESULT CALLBACK COMBO_WindowProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
1718 {
1719 HEADCOMBO *lphc = (HEADCOMBO *)GetWindowLongPtrW( hwnd, 0 );
1720 HTHEME theme;
1721
1722 TRACE("[%p]: msg %#x wp %08lx lp %08lx\n", hwnd, message, wParam, lParam );
1723
1724 if (!IsWindow(hwnd)) return 0;
1725
1726 if (lphc || message == WM_NCCREATE)
1727 switch(message)
1728 {
1729 case WM_NCCREATE:
1730 {
1731 LONG style = ((CREATESTRUCTW *)lParam)->style;
1732 return COMBO_NCCreate(hwnd, style);
1733 }
1734
1735 case WM_NCDESTROY:
1736 COMBO_NCDestroy(lphc);
1737 break;/* -> DefWindowProc */
1738
1739 case WM_CREATE:
1740 {
1741 HWND hwndParent;
1742 LONG style;
1743
1744 hwndParent = ((CREATESTRUCTW *)lParam)->hwndParent;
1745 style = ((CREATESTRUCTW *)lParam)->style;
1746 return COMBO_Create(hwnd, lphc, hwndParent, style);
1747 }
1748
1749 case WM_DESTROY:
1750 theme = GetWindowTheme( hwnd );
1751 CloseThemeData( theme );
1752 break;
1753
1754 case WM_THEMECHANGED:
1755 theme = GetWindowTheme( hwnd );
1756 CloseThemeData( theme );
1757 OpenThemeData( hwnd, WC_COMBOBOXW );
1758 break;
1759
1760 case WM_PRINTCLIENT:
1761 case WM_PAINT:
1762 {
1763 LRESULT ret = 0;
1764 PAINTSTRUCT ps;
1765 HDC hdc;
1766
1767 hdc = wParam ? (HDC)wParam : BeginPaint(hwnd, &ps);
1768
1769 if (hdc && !(lphc->wState & CBF_NOREDRAW))
1770 {
1771 HTHEME theme = GetWindowTheme(hwnd);
1772
1773 if (theme)
1774 ret = COMBO_ThemedPaint(theme, lphc, hdc);
1775 else
1776 ret = COMBO_Paint(lphc, hdc);
1777 }
1778
1779 if (!wParam)
1780 EndPaint(hwnd, &ps);
1781
1782 return ret;
1783 }
1784 case WM_ERASEBKGND:
1785 /* do all painting in WM_PAINT like Windows does */
1786 return 1;
1787
1788 case WM_GETDLGCODE:
1789 {
1790 LRESULT result = DLGC_WANTARROWS | DLGC_WANTCHARS;
1791 if (lParam && (((LPMSG)lParam)->message == WM_KEYDOWN))
1792 {
1793 int vk = (int)((LPMSG)lParam)->wParam;
1794
1795 if ((vk == VK_RETURN || vk == VK_ESCAPE) && (lphc->wState & CBF_DROPPED))
1796 result |= DLGC_WANTMESSAGE;
1797 }
1798 return result;
1799 }
1800
1801 case WM_SIZE:
1802 if (lphc->hWndLBox && !(lphc->wState & CBF_NORESIZE))
1803 COMBO_Size( lphc );
1804 return TRUE;
1805
1806 case WM_SETFONT:
1807 COMBO_Font( lphc, (HFONT)wParam, (BOOL)lParam );
1808 return TRUE;
1809
1810 case WM_GETFONT:
1811 return (LRESULT)lphc->hFont;
1812
1813 case WM_SETFOCUS:
1814 if (lphc->wState & CBF_EDIT)
1815 {
1816 SetFocus( lphc->hWndEdit );
1817 /* The first time focus is received, select all the text */
1818 if (!(lphc->wState & CBF_BEENFOCUSED))
1819 {
1820 SendMessageW(lphc->hWndEdit, EM_SETSEL, 0, -1);
1821 lphc->wState |= CBF_BEENFOCUSED;
1822 }
1823 }
1824 else
1825 COMBO_SetFocus( lphc );
1826 return TRUE;
1827
1828 case WM_KILLFOCUS:
1829 {
1830 HWND hwndFocus = (HWND)wParam;
1831 if (!hwndFocus || (hwndFocus != lphc->hWndEdit && hwndFocus != lphc->hWndLBox))
1832 COMBO_KillFocus( lphc );
1833 return TRUE;
1834 }
1835
1836 case WM_COMMAND:
1837 return COMBO_Command( lphc, wParam, (HWND)lParam );
1838
1839 case WM_GETTEXT:
1840 return COMBO_GetText( lphc, wParam, (LPWSTR)lParam );
1841
1842 case WM_SETTEXT:
1843 case WM_GETTEXTLENGTH:
1844 case WM_CLEAR:
1845 if ((message == WM_GETTEXTLENGTH) && !ISWIN31 && !(lphc->wState & CBF_EDIT))
1846 {
1847 int j = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
1848 if (j == -1) return 0;
1849 return SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, j, 0);
1850 }
1851 else if ( lphc->wState & CBF_EDIT )
1852 {
1853 LRESULT ret;
1854 lphc->wState |= CBF_NOEDITNOTIFY;
1855 ret = SendMessageW(lphc->hWndEdit, message, wParam, lParam);
1856 lphc->wState &= ~CBF_NOEDITNOTIFY;
1857 return ret;
1858 }
1859 else
1860 return CB_ERR;
1861
1862 case WM_CUT:
1863 case WM_PASTE:
1864 case WM_COPY:
1865 if (lphc->wState & CBF_EDIT)
1866 return SendMessageW(lphc->hWndEdit, message, wParam, lParam);
1867 else return CB_ERR;
1868
1869 case WM_DRAWITEM:
1870 case WM_DELETEITEM:
1871 case WM_COMPAREITEM:
1872 case WM_MEASUREITEM:
1873 return COMBO_ItemOp(lphc, message, lParam);
1874
1875 case WM_ENABLE:
1876 if (lphc->wState & CBF_EDIT)
1877 EnableWindow( lphc->hWndEdit, (BOOL)wParam );
1878 EnableWindow( lphc->hWndLBox, (BOOL)wParam );
1879
1880 /* Force the control to repaint when the enabled state changes. */
1881 InvalidateRect(lphc->self, NULL, TRUE);
1882 return TRUE;
1883
1884 case WM_SETREDRAW:
1885 if (wParam)
1886 lphc->wState &= ~CBF_NOREDRAW;
1887 else
1888 lphc->wState |= CBF_NOREDRAW;
1889
1890 if ( lphc->wState & CBF_EDIT )
1891 SendMessageW(lphc->hWndEdit, message, wParam, lParam);
1892 SendMessageW(lphc->hWndLBox, message, wParam, lParam);
1893 return 0;
1894
1895 case WM_SYSKEYDOWN:
1896 if ( KEYDATA_ALT & HIWORD(lParam) )
1897 if( wParam == VK_UP || wParam == VK_DOWN )
1898 COMBO_FlipListbox( lphc, FALSE, FALSE );
1899 return 0;
1900
1901 case WM_KEYDOWN:
1902 if ((wParam == VK_RETURN || wParam == VK_ESCAPE) &&
1903 (lphc->wState & CBF_DROPPED))
1904 {
1905 CBRollUp( lphc, wParam == VK_RETURN, FALSE );
1906 return TRUE;
1907 }
1908 else if ((wParam == VK_F4) && !(lphc->wState & CBF_EUI))
1909 {
1910 COMBO_FlipListbox( lphc, FALSE, FALSE );
1911 return TRUE;
1912 }
1913 /* fall through */
1914 case WM_CHAR:
1915 case WM_IME_CHAR:
1916 {
1917 HWND hwndTarget;
1918
1919 if ( lphc->wState & CBF_EDIT )
1920 hwndTarget = lphc->hWndEdit;
1921 else
1922 hwndTarget = lphc->hWndLBox;
1923
1924 return SendMessageW(hwndTarget, message, wParam, lParam);
1925 }
1926
1927 case WM_LBUTTONDOWN:
1928 if ( !(lphc->wState & CBF_FOCUSED) ) SetFocus( lphc->self );
1929 if ( lphc->wState & CBF_FOCUSED ) COMBO_LButtonDown( lphc, lParam );
1930 return TRUE;
1931
1932 case WM_LBUTTONUP:
1933 COMBO_LButtonUp( lphc );
1934 return TRUE;
1935
1936 case WM_MOUSEMOVE:
1937 if (!IsRectEmpty(&lphc->buttonRect))
1938 {
1939 POINT pt;
1940
1941 pt.x = (short)LOWORD(lParam);
1942 pt.y = (short)HIWORD(lParam);
1943
1944 if (PtInRect(&lphc->buttonRect, pt))
1945 {
1946 if (!(lphc->wState & CBF_HOT))
1947 {
1948 lphc->wState |= CBF_HOT;
1949 RedrawWindow(hwnd, &lphc->buttonRect, 0, RDW_INVALIDATE | RDW_UPDATENOW);
1950 }
1951 }
1952 else if (lphc->wState & CBF_HOT)
1953 {
1954 lphc->wState &= ~CBF_HOT;
1955 RedrawWindow(hwnd, &lphc->buttonRect, 0, RDW_INVALIDATE | RDW_UPDATENOW);
1956 }
1957 }
1958
1959 if ( lphc->wState & CBF_CAPTURE )
1960 COMBO_MouseMove( lphc, wParam, lParam );
1961 return TRUE;
1962
1963 case WM_MOUSEWHEEL:
1964 if (wParam & (MK_SHIFT | MK_CONTROL))
1965 return DefWindowProcW(hwnd, message, wParam, lParam);
1966
1967 if (GET_WHEEL_DELTA_WPARAM(wParam) > 0) return SendMessageW(hwnd, WM_KEYDOWN, VK_UP, 0);
1968 if (GET_WHEEL_DELTA_WPARAM(wParam) < 0) return SendMessageW(hwnd, WM_KEYDOWN, VK_DOWN, 0);
1969 return TRUE;
1970
1971 /* Combo messages */
1972 case CB_ADDSTRING:
1973 if (lphc->dwStyle & CBS_LOWERCASE)
1974 CharLowerW((LPWSTR)lParam);
1975 else if (lphc->dwStyle & CBS_UPPERCASE)
1976 CharUpperW((LPWSTR)lParam);
1977 return SendMessageW(lphc->hWndLBox, LB_ADDSTRING, 0, lParam);
1978
1979 case CB_INSERTSTRING:
1980 if (lphc->dwStyle & CBS_LOWERCASE)
1981 CharLowerW((LPWSTR)lParam);
1982 else if (lphc->dwStyle & CBS_UPPERCASE)
1983 CharUpperW((LPWSTR)lParam);
1984 return SendMessageW(lphc->hWndLBox, LB_INSERTSTRING, wParam, lParam);
1985
1986 case CB_DELETESTRING:
1987 return SendMessageW(lphc->hWndLBox, LB_DELETESTRING, wParam, 0);
1988
1989 case CB_SELECTSTRING:
1990 return COMBO_SelectString(lphc, (INT)wParam, lParam);
1991
1992 case CB_FINDSTRING:
1993 return SendMessageW(lphc->hWndLBox, LB_FINDSTRING, wParam, lParam);
1994
1995 case CB_FINDSTRINGEXACT:
1996 return SendMessageW(lphc->hWndLBox, LB_FINDSTRINGEXACT, wParam, lParam);
1997
1998 case CB_SETITEMHEIGHT:
1999 return COMBO_SetItemHeight( lphc, (INT)wParam, (INT)lParam);
2000
2001 case CB_GETITEMHEIGHT:
2002 if ((INT)wParam >= 0) /* listbox item */
2003 return SendMessageW(lphc->hWndLBox, LB_GETITEMHEIGHT, wParam, 0);
2004 return CBGetTextAreaHeight(hwnd, lphc);
2005
2006 case CB_RESETCONTENT:
2007 SendMessageW(lphc->hWndLBox, LB_RESETCONTENT, 0, 0);
2008
2009 if ((lphc->wState & CBF_EDIT) && CB_HASSTRINGS(lphc))
2010 {
2011 static const WCHAR empty_stringW[] = { 0 };
2012 SendMessageW(lphc->hWndEdit, WM_SETTEXT, 0, (LPARAM)empty_stringW);
2013 }
2014 else
2015 InvalidateRect(lphc->self, NULL, TRUE);
2016 return TRUE;
2017
2018 case CB_INITSTORAGE:
2019 return SendMessageW(lphc->hWndLBox, LB_INITSTORAGE, wParam, lParam);
2020
2021 case CB_GETHORIZONTALEXTENT:
2022 return SendMessageW(lphc->hWndLBox, LB_GETHORIZONTALEXTENT, 0, 0);
2023
2024 case CB_SETHORIZONTALEXTENT:
2025 return SendMessageW(lphc->hWndLBox, LB_SETHORIZONTALEXTENT, wParam, 0);
2026
2027 case CB_GETTOPINDEX:
2028 return SendMessageW(lphc->hWndLBox, LB_GETTOPINDEX, 0, 0);
2029
2030 case CB_GETLOCALE:
2031 return SendMessageW(lphc->hWndLBox, LB_GETLOCALE, 0, 0);
2032
2033 case CB_SETLOCALE:
2034 return SendMessageW(lphc->hWndLBox, LB_SETLOCALE, wParam, 0);
2035
2036 case CB_SETDROPPEDWIDTH:
2037 if ((CB_GETTYPE(lphc) == CBS_SIMPLE) || (INT)wParam >= 32768)
2038 return CB_ERR;
2039
2040 /* new value must be higher than combobox width */
2041 if ((INT)wParam >= lphc->droppedRect.right - lphc->droppedRect.left)
2042 lphc->droppedWidth = wParam;
2043 else if (wParam)
2044 lphc->droppedWidth = 0;
2045
2046 /* recalculate the combobox area */
2047 CBCalcPlacement(hwnd, lphc, &lphc->textRect, &lphc->buttonRect, &lphc->droppedRect );
2048
2049 /* fall through */
2050 case CB_GETDROPPEDWIDTH:
2051 if (lphc->droppedWidth)
2052 return lphc->droppedWidth;
2053 return lphc->droppedRect.right - lphc->droppedRect.left;
2054
2055 case CB_GETDROPPEDCONTROLRECT:
2056 if (lParam)
2057 CBGetDroppedControlRect(lphc, (LPRECT)lParam );
2058 return CB_OKAY;
2059
2060 case CB_GETDROPPEDSTATE:
2061 return (lphc->wState & CBF_DROPPED) != 0;
2062
2063 case CB_DIR:
2064 return SendMessageW(lphc->hWndLBox, LB_DIR, wParam, lParam);
2065
2066 case CB_SHOWDROPDOWN:
2067 if (CB_GETTYPE(lphc) != CBS_SIMPLE)
2068 {
2069 if (wParam)
2070 {
2071 if (!(lphc->wState & CBF_DROPPED))
2072 CBDropDown( lphc );
2073 }
2074 else if (lphc->wState & CBF_DROPPED)
2075 CBRollUp( lphc, FALSE, TRUE );
2076 }
2077 return TRUE;
2078
2079 case CB_GETCOUNT:
2080 return SendMessageW(lphc->hWndLBox, LB_GETCOUNT, 0, 0);
2081
2082 case CB_GETCURSEL:
2083 return SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
2084
2085 case CB_SETCURSEL:
2086 lParam = SendMessageW(lphc->hWndLBox, LB_SETCURSEL, wParam, 0);
2087 if (lParam >= 0)
2088 SendMessageW(lphc->hWndLBox, LB_SETTOPINDEX, wParam, 0);
2089
2090 /* no LBN_SELCHANGE in this case, update manually */
2091 CBPaintText(lphc, NULL);
2092 lphc->wState &= ~CBF_SELCHANGE;
2093 return lParam;
2094
2095 case CB_GETLBTEXT:
2096 return SendMessageW(lphc->hWndLBox, LB_GETTEXT, wParam, lParam);
2097
2098 case CB_GETLBTEXTLEN:
2099 return SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, wParam, 0);
2100
2101 case CB_GETITEMDATA:
2102 return SendMessageW(lphc->hWndLBox, LB_GETITEMDATA, wParam, 0);
2103
2104 case CB_SETITEMDATA:
2105 return SendMessageW(lphc->hWndLBox, LB_SETITEMDATA, wParam, lParam);
2106
2107 case CB_GETEDITSEL:
2108 /* Edit checks passed parameters itself */
2109 if (lphc->wState & CBF_EDIT)
2110 return SendMessageW(lphc->hWndEdit, EM_GETSEL, wParam, lParam);
2111 return CB_ERR;
2112
2113 case CB_SETEDITSEL:
2114 if (lphc->wState & CBF_EDIT)
2115 return SendMessageW(lphc->hWndEdit, EM_SETSEL, (INT)(SHORT)LOWORD(lParam), (INT)(SHORT)HIWORD(lParam) );
2116 return CB_ERR;
2117
2118 case CB_SETEXTENDEDUI:
2119 if (CB_GETTYPE(lphc) == CBS_SIMPLE )
2120 return CB_ERR;
2121 if (wParam)
2122 lphc->wState |= CBF_EUI;
2123 else
2124 lphc->wState &= ~CBF_EUI;
2125 return CB_OKAY;
2126
2127 case CB_GETEXTENDEDUI:
2128 return (lphc->wState & CBF_EUI) != 0;
2129
2130 case CB_GETCOMBOBOXINFO:
2131 return COMBO_GetComboBoxInfo(lphc, (COMBOBOXINFO *)lParam);
2132
2133 case CB_LIMITTEXT:
2134 if (lphc->wState & CBF_EDIT)
2135 return SendMessageW(lphc->hWndEdit, EM_LIMITTEXT, wParam, lParam);
2136 return TRUE;
2137
2138 default:
2139 if (message >= WM_USER)
2140 WARN("unknown msg WM_USER+%04x wp=%04lx lp=%08lx\n", message - WM_USER, wParam, lParam );
2141 break;
2142 }
2143
2144 return DefWindowProcW(hwnd, message, wParam, lParam);
2145 }
2146
2147 void COMBO_Register(void)
2148 {
2149 WNDCLASSW wndClass;
2150
2151 memset(&wndClass, 0, sizeof(wndClass));
2152 wndClass.style = CS_PARENTDC | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW | CS_GLOBALCLASS;
2153 wndClass.lpfnWndProc = COMBO_WindowProc;
2154 wndClass.cbClsExtra = 0;
2155 wndClass.cbWndExtra = sizeof(HEADCOMBO *);
2156 wndClass.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
2157 wndClass.hbrBackground = NULL;
2158 wndClass.lpszClassName = WC_COMBOBOXW;
2159 RegisterClassW(&wndClass);
2160 }
Windows API implementation