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