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