?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
jscript: Added ArrayInstance::on_put implementation.
[wine.git] / dlls / user32 / combo.c
blob6e741544730184a87a4d3c98479fb889d3c8d5d2
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 /* FIXME: In which cases WM_CTLCOLORLISTBOX should be sent? */
888 hBkgBrush = (HBRUSH)SendMessageW(lphc->owner, WM_CTLCOLOREDIT,
889 (WPARAM)hDC, (LPARAM)lphc->self );
890 }
891
892 /*
893 * Catch errors.
894 */
895 if( !hBkgBrush )
896 hBkgBrush = GetSysColorBrush(COLOR_WINDOW);
897
898 return hBkgBrush;
899 }
900
901
902 /***********************************************************************
903 * COMBO_Paint
904 */
905 static LRESULT COMBO_Paint(LPHEADCOMBO lphc, HDC hParamDC)
906 {
907 PAINTSTRUCT ps;
908 HDC hDC;
909
910 hDC = (hParamDC) ? hParamDC
911 : BeginPaint( lphc->self, &ps);
912
913 TRACE("hdc=%p\n", hDC);
914
915 if( hDC && !(lphc->wState & CBF_NOREDRAW) )
916 {
917 HBRUSH hPrevBrush, hBkgBrush;
918
919 /*
920 * Retrieve the background brush and select it in the
921 * DC.
922 */
923 hBkgBrush = COMBO_PrepareColors(lphc, hDC);
924
925 hPrevBrush = SelectObject( hDC, hBkgBrush );
926 if (!(lphc->wState & CBF_EDIT))
927 FillRect(hDC, &lphc->textRect, hBkgBrush);
928
929 /*
930 * In non 3.1 look, there is a sunken border on the combobox
931 */
932 CBPaintBorder(lphc->self, lphc, hDC);
933
934 if( !IsRectEmpty(&lphc->buttonRect) )
935 {
936 CBPaintButton(lphc, hDC, lphc->buttonRect);
937 }
938
939 /* paint the edit control padding area */
940 if (CB_GETTYPE(lphc) != CBS_DROPDOWNLIST)
941 {
942 RECT rPadEdit = lphc->textRect;
943
944 InflateRect(&rPadEdit, EDIT_CONTROL_PADDING(), EDIT_CONTROL_PADDING());
945
946 FrameRect( hDC, &rPadEdit, GetSysColorBrush(COLOR_WINDOW) );
947 }
948
949 if( !(lphc->wState & CBF_EDIT) )
950 CBPaintText( lphc, hDC, lphc->textRect);
951
952 if( hPrevBrush )
953 SelectObject( hDC, hPrevBrush );
954 }
955
956 if( !hParamDC )
957 EndPaint(lphc->self, &ps);
958
959 return 0;
960 }
961
962 /***********************************************************************
963 * CBUpdateLBox
964 *
965 * Select listbox entry according to the contents of the edit control.
966 */
967 static INT CBUpdateLBox( LPHEADCOMBO lphc, BOOL bSelect )
968 {
969 INT length, idx;
970 LPWSTR pText = NULL;
971
972 idx = LB_ERR;
973 length = SendMessageW( lphc->hWndEdit, WM_GETTEXTLENGTH, 0, 0 );
974
975 if( length > 0 )
976 pText = HeapAlloc( GetProcessHeap(), 0, (length + 1) * sizeof(WCHAR));
977
978 TRACE("\t edit text length %i\n", length );
979
980 if( pText )
981 {
982 GetWindowTextW( lphc->hWndEdit, pText, length + 1);
983 idx = SendMessageW(lphc->hWndLBox, LB_FINDSTRING,
984 (WPARAM)(-1), (LPARAM)pText );
985 HeapFree( GetProcessHeap(), 0, pText );
986 }
987
988 SendMessageW(lphc->hWndLBox, LB_SETCURSEL, (WPARAM)(bSelect ? idx : -1), 0);
989
990 /* probably superfluous but Windows sends this too */
991 SendMessageW(lphc->hWndLBox, LB_SETCARETINDEX, (WPARAM)(idx < 0 ? 0 : idx), 0);
992 SendMessageW(lphc->hWndLBox, LB_SETTOPINDEX, (WPARAM)(idx < 0 ? 0 : idx), 0);
993
994 return idx;
995 }
996
997 /***********************************************************************
998 * CBUpdateEdit
999 *
1000 * Copy a listbox entry to the edit control.
1001 */
1002 static void CBUpdateEdit( LPHEADCOMBO lphc , INT index )
1003 {
1004 INT length;
1005 LPWSTR pText = NULL;
1006 static const WCHAR empty_stringW[] = { 0 };
1007
1008 TRACE("\t %i\n", index );
1009
1010 if( index >= 0 ) /* got an entry */
1011 {
1012 length = SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, (WPARAM)index, 0);
1013 if( length != LB_ERR)
1014 {
1015 if( (pText = HeapAlloc( GetProcessHeap(), 0, (length + 1) * sizeof(WCHAR))) )
1016 {
1017 SendMessageW(lphc->hWndLBox, LB_GETTEXT,
1018 (WPARAM)index, (LPARAM)pText );
1019 }
1020 }
1021 }
1022
1023 if( CB_HASSTRINGS(lphc) )
1024 {
1025 lphc->wState |= (CBF_NOEDITNOTIFY | CBF_NOLBSELECT);
1026 SendMessageW(lphc->hWndEdit, WM_SETTEXT, 0, pText ? (LPARAM)pText : (LPARAM)empty_stringW);
1027 lphc->wState &= ~(CBF_NOEDITNOTIFY | CBF_NOLBSELECT);
1028 }
1029
1030 if( lphc->wState & CBF_FOCUSED )
1031 SendMessageW(lphc->hWndEdit, EM_SETSEL, 0, (LPARAM)(-1));
1032
1033 HeapFree( GetProcessHeap(), 0, pText );
1034 }
1035
1036 /***********************************************************************
1037 * CBDropDown
1038 *
1039 * Show listbox popup.
1040 */
1041 static void CBDropDown( LPHEADCOMBO lphc )
1042 {
1043 HMONITOR monitor;
1044 MONITORINFO mon_info;
1045 RECT rect,r;
1046 int nItems = 0;
1047 int nDroppedHeight;
1048
1049 TRACE("[%p]: drop down\n", lphc->self);
1050
1051 CB_NOTIFY( lphc, CBN_DROPDOWN );
1052
1053 /* set selection */
1054
1055 lphc->wState |= CBF_DROPPED;
1056 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
1057 {
1058 lphc->droppedIndex = CBUpdateLBox( lphc, TRUE );
1059
1060 /* Update edit only if item is in the list */
1061 if( !(lphc->wState & CBF_CAPTURE) && lphc->droppedIndex >= 0)
1062 CBUpdateEdit( lphc, lphc->droppedIndex );
1063 }
1064 else
1065 {
1066 lphc->droppedIndex = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
1067
1068 SendMessageW(lphc->hWndLBox, LB_SETTOPINDEX,
1069 (WPARAM)(lphc->droppedIndex == LB_ERR ? 0 : lphc->droppedIndex), 0 );
1070 SendMessageW(lphc->hWndLBox, LB_CARETON, 0, 0);
1071 }
1072
1073 /* now set popup position */
1074 GetWindowRect( lphc->self, &rect );
1075
1076 /*
1077 * If it's a dropdown, the listbox is offset
1078 */
1079 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
1080 rect.left += COMBO_EDITBUTTONSPACE();
1081
1082 /* if the dropped height is greater than the total height of the dropped
1083 items list, then force the drop down list height to be the total height
1084 of the items in the dropped list */
1085
1086 /* And Remove any extra space (Best Fit) */
1087 nDroppedHeight = lphc->droppedRect.bottom - lphc->droppedRect.top;
1088 /* if listbox length has been set directly by its handle */
1089 GetWindowRect(lphc->hWndLBox, &r);
1090 if (nDroppedHeight < r.bottom - r.top)
1091 nDroppedHeight = r.bottom - r.top;
1092 nItems = (int)SendMessageW(lphc->hWndLBox, LB_GETCOUNT, 0, 0);
1093
1094 if (nItems > 0)
1095 {
1096 int nHeight;
1097 int nIHeight;
1098
1099 nIHeight = (int)SendMessageW(lphc->hWndLBox, LB_GETITEMHEIGHT, 0, 0);
1100
1101 nHeight = nIHeight*nItems;
1102
1103 if (nHeight < nDroppedHeight - COMBO_YBORDERSIZE())
1104 nDroppedHeight = nHeight + COMBO_YBORDERSIZE();
1105
1106 if (nDroppedHeight < nHeight)
1107 {
1108 if (nItems < 5)
1109 nDroppedHeight = (nItems+1)*nIHeight;
1110 else if (nDroppedHeight < 6*nIHeight)
1111 nDroppedHeight = 6*nIHeight;
1112 }
1113 }
1114
1115 /*If height of dropped rectangle gets beyond a screen size it should go up, otherwise down.*/
1116 monitor = MonitorFromRect( &rect, MONITOR_DEFAULTTOPRIMARY );
1117 mon_info.cbSize = sizeof(mon_info);
1118 GetMonitorInfoW( monitor, &mon_info );
1119
1120 if( (rect.bottom + nDroppedHeight) >= mon_info.rcWork.bottom )
1121 rect.bottom = rect.top - nDroppedHeight;
1122
1123 SetWindowPos( lphc->hWndLBox, HWND_TOP, rect.left, rect.bottom,
1124 lphc->droppedRect.right - lphc->droppedRect.left,
1125 nDroppedHeight,
1126 SWP_NOACTIVATE | SWP_SHOWWINDOW);
1127
1128
1129 if( !(lphc->wState & CBF_NOREDRAW) )
1130 RedrawWindow( lphc->self, NULL, 0, RDW_INVALIDATE |
1131 RDW_ERASE | RDW_UPDATENOW | RDW_NOCHILDREN );
1132
1133 EnableWindow( lphc->hWndLBox, TRUE );
1134 if (GetCapture() != lphc->self)
1135 SetCapture(lphc->hWndLBox);
1136 }
1137
1138 /***********************************************************************
1139 * CBRollUp
1140 *
1141 * Hide listbox popup.
1142 */
1143 static void CBRollUp( LPHEADCOMBO lphc, BOOL ok, BOOL bButton )
1144 {
1145 HWND hWnd = lphc->self;
1146
1147 TRACE("[%p]: sel ok? [%i] dropped? [%i]\n",
1148 lphc->self, ok, (INT)(lphc->wState & CBF_DROPPED));
1149
1150 CB_NOTIFY( lphc, (ok) ? CBN_SELENDOK : CBN_SELENDCANCEL );
1151
1152 if( IsWindow( hWnd ) && CB_GETTYPE(lphc) != CBS_SIMPLE )
1153 {
1154
1155 if( lphc->wState & CBF_DROPPED )
1156 {
1157 RECT rect;
1158
1159 lphc->wState &= ~CBF_DROPPED;
1160 ShowWindow( lphc->hWndLBox, SW_HIDE );
1161
1162 if(GetCapture() == lphc->hWndLBox)
1163 {
1164 ReleaseCapture();
1165 }
1166
1167 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
1168 {
1169 rect = lphc->buttonRect;
1170 }
1171 else
1172 {
1173 if( bButton )
1174 {
1175 UnionRect( &rect,
1176 &lphc->buttonRect,
1177 &lphc->textRect);
1178 }
1179 else
1180 rect = lphc->textRect;
1181
1182 bButton = TRUE;
1183 }
1184
1185 if( bButton && !(lphc->wState & CBF_NOREDRAW) )
1186 RedrawWindow( hWnd, &rect, 0, RDW_INVALIDATE |
1187 RDW_ERASE | RDW_UPDATENOW | RDW_NOCHILDREN );
1188 CB_NOTIFY( lphc, CBN_CLOSEUP );
1189 }
1190 }
1191 }
1192
1193 /***********************************************************************
1194 * COMBO_FlipListbox
1195 *
1196 * Used by the ComboLBox to show/hide itself in response to VK_F4, etc...
1197 */
1198 BOOL COMBO_FlipListbox( LPHEADCOMBO lphc, BOOL ok, BOOL bRedrawButton )
1199 {
1200 if( lphc->wState & CBF_DROPPED )
1201 {
1202 CBRollUp( lphc, ok, bRedrawButton );
1203 return FALSE;
1204 }
1205
1206 CBDropDown( lphc );
1207 return TRUE;
1208 }
1209
1210 /***********************************************************************
1211 * CBRepaintButton
1212 */
1213 static void CBRepaintButton( LPHEADCOMBO lphc )
1214 {
1215 InvalidateRect(lphc->self, &lphc->buttonRect, TRUE);
1216 UpdateWindow(lphc->self);
1217 }
1218
1219 /***********************************************************************
1220 * COMBO_SetFocus
1221 */
1222 static void COMBO_SetFocus( LPHEADCOMBO lphc )
1223 {
1224 if( !(lphc->wState & CBF_FOCUSED) )
1225 {
1226 if( CB_GETTYPE(lphc) == CBS_DROPDOWNLIST )
1227 SendMessageW(lphc->hWndLBox, LB_CARETON, 0, 0);
1228
1229 /* This is wrong. Message sequences seem to indicate that this
1230 is set *after* the notify. */
1231 /* lphc->wState |= CBF_FOCUSED; */
1232
1233 if( !(lphc->wState & CBF_EDIT) )
1234 InvalidateRect(lphc->self, &lphc->textRect, TRUE);
1235
1236 CB_NOTIFY( lphc, CBN_SETFOCUS );
1237 lphc->wState |= CBF_FOCUSED;
1238 }
1239 }
1240
1241 /***********************************************************************
1242 * COMBO_KillFocus
1243 */
1244 static void COMBO_KillFocus( LPHEADCOMBO lphc )
1245 {
1246 HWND hWnd = lphc->self;
1247
1248 if( lphc->wState & CBF_FOCUSED )
1249 {
1250 CBRollUp( lphc, FALSE, TRUE );
1251 if( IsWindow( hWnd ) )
1252 {
1253 if( CB_GETTYPE(lphc) == CBS_DROPDOWNLIST )
1254 SendMessageW(lphc->hWndLBox, LB_CARETOFF, 0, 0);
1255
1256 lphc->wState &= ~CBF_FOCUSED;
1257
1258 /* redraw text */
1259 if( !(lphc->wState & CBF_EDIT) )
1260 InvalidateRect(lphc->self, &lphc->textRect, TRUE);
1261
1262 CB_NOTIFY( lphc, CBN_KILLFOCUS );
1263 }
1264 }
1265 }
1266
1267 /***********************************************************************
1268 * COMBO_Command
1269 */
1270 static LRESULT COMBO_Command( LPHEADCOMBO lphc, WPARAM wParam, HWND hWnd )
1271 {
1272 if ( lphc->wState & CBF_EDIT && lphc->hWndEdit == hWnd )
1273 {
1274 /* ">> 8" makes gcc generate jump-table instead of cmp ladder */
1275
1276 switch( HIWORD(wParam) >> 8 )
1277 {
1278 case (EN_SETFOCUS >> 8):
1279
1280 TRACE("[%p]: edit [%p] got focus\n", lphc->self, lphc->hWndEdit );
1281
1282 COMBO_SetFocus( lphc );
1283 break;
1284
1285 case (EN_KILLFOCUS >> 8):
1286
1287 TRACE("[%p]: edit [%p] lost focus\n", lphc->self, lphc->hWndEdit );
1288
1289 /* NOTE: it seems that Windows' edit control sends an
1290 * undocumented message WM_USER + 0x1B instead of this
1291 * notification (only when it happens to be a part of
1292 * the combo). ?? - AK.
1293 */
1294
1295 COMBO_KillFocus( lphc );
1296 break;
1297
1298
1299 case (EN_CHANGE >> 8):
1300 /*
1301 * In some circumstances (when the selection of the combobox
1302 * is changed for example) we don't want the EN_CHANGE notification
1303 * to be forwarded to the parent of the combobox. This code
1304 * checks a flag that is set in these occasions and ignores the
1305 * notification.
1306 */
1307 if (lphc->wState & CBF_NOLBSELECT)
1308 {
1309 lphc->wState &= ~CBF_NOLBSELECT;
1310 }
1311 else
1312 {
1313 CBUpdateLBox( lphc, lphc->wState & CBF_DROPPED );
1314 }
1315
1316 if (!(lphc->wState & CBF_NOEDITNOTIFY))
1317 CB_NOTIFY( lphc, CBN_EDITCHANGE );
1318 break;
1319
1320 case (EN_UPDATE >> 8):
1321 if (!(lphc->wState & CBF_NOEDITNOTIFY))
1322 CB_NOTIFY( lphc, CBN_EDITUPDATE );
1323 break;
1324
1325 case (EN_ERRSPACE >> 8):
1326 CB_NOTIFY( lphc, CBN_ERRSPACE );
1327 }
1328 }
1329 else if( lphc->hWndLBox == hWnd )
1330 {
1331 switch( (short)HIWORD(wParam) )
1332 {
1333 case LBN_ERRSPACE:
1334 CB_NOTIFY( lphc, CBN_ERRSPACE );
1335 break;
1336
1337 case LBN_DBLCLK:
1338 CB_NOTIFY( lphc, CBN_DBLCLK );
1339 break;
1340
1341 case LBN_SELCHANGE:
1342 case LBN_SELCANCEL:
1343
1344 TRACE("[%p]: lbox selection change [%x]\n", lphc->self, lphc->wState );
1345
1346 /* do not roll up if selection is being tracked
1347 * by arrow keys in the dropdown listbox */
1348 if (!(lphc->wState & CBF_NOROLLUP))
1349 {
1350 CBRollUp( lphc, (HIWORD(wParam) == LBN_SELCHANGE), TRUE );
1351 }
1352 else lphc->wState &= ~CBF_NOROLLUP;
1353
1354 CB_NOTIFY( lphc, CBN_SELCHANGE );
1355
1356 if( HIWORD(wParam) == LBN_SELCHANGE)
1357 {
1358 if( lphc->wState & CBF_EDIT )
1359 {
1360 INT index = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
1361 lphc->wState |= CBF_NOLBSELECT;
1362 CBUpdateEdit( lphc, index );
1363 /* select text in edit, as Windows does */
1364 SendMessageW(lphc->hWndEdit, EM_SETSEL, 0, (LPARAM)(-1));
1365 }
1366 else
1367 {
1368 InvalidateRect(lphc->self, &lphc->textRect, TRUE);
1369 UpdateWindow(lphc->self);
1370 }
1371 }
1372 break;
1373
1374 case LBN_SETFOCUS:
1375 case LBN_KILLFOCUS:
1376 /* nothing to do here since ComboLBox always resets the focus to its
1377 * combo/edit counterpart */
1378 break;
1379 }
1380 }
1381 return 0;
1382 }
1383
1384 /***********************************************************************
1385 * COMBO_ItemOp
1386 *
1387 * Fixup an ownerdrawn item operation and pass it up to the combobox owner.
1388 */
1389 static LRESULT COMBO_ItemOp( LPHEADCOMBO lphc, UINT msg, LPARAM lParam )
1390 {
1391 HWND hWnd = lphc->self;
1392 UINT id = (UINT)GetWindowLongPtrW( hWnd, GWLP_ID );
1393
1394 TRACE("[%p]: ownerdraw op %04x\n", lphc->self, msg );
1395
1396 switch( msg )
1397 {
1398 case WM_DELETEITEM:
1399 {
1400 DELETEITEMSTRUCT *lpIS = (DELETEITEMSTRUCT *)lParam;
1401 lpIS->CtlType = ODT_COMBOBOX;
1402 lpIS->CtlID = id;
1403 lpIS->hwndItem = hWnd;
1404 break;
1405 }
1406 case WM_DRAWITEM:
1407 {
1408 DRAWITEMSTRUCT *lpIS = (DRAWITEMSTRUCT *)lParam;
1409 lpIS->CtlType = ODT_COMBOBOX;
1410 lpIS->CtlID = id;
1411 lpIS->hwndItem = hWnd;
1412 break;
1413 }
1414 case WM_COMPAREITEM:
1415 {
1416 COMPAREITEMSTRUCT *lpIS = (COMPAREITEMSTRUCT *)lParam;
1417 lpIS->CtlType = ODT_COMBOBOX;
1418 lpIS->CtlID = id;
1419 lpIS->hwndItem = hWnd;
1420 break;
1421 }
1422 case WM_MEASUREITEM:
1423 {
1424 MEASUREITEMSTRUCT *lpIS = (MEASUREITEMSTRUCT *)lParam;
1425 lpIS->CtlType = ODT_COMBOBOX;
1426 lpIS->CtlID = id;
1427 break;
1428 }
1429 }
1430 return SendMessageW(lphc->owner, msg, id, lParam);
1431 }
1432
1433
1434 /***********************************************************************
1435 * COMBO_GetTextW
1436 */
1437 static LRESULT COMBO_GetTextW( LPHEADCOMBO lphc, INT count, LPWSTR buf )
1438 {
1439 INT length;
1440
1441 if( lphc->wState & CBF_EDIT )
1442 return SendMessageW( lphc->hWndEdit, WM_GETTEXT, count, (LPARAM)buf );
1443
1444 /* get it from the listbox */
1445
1446 if (!count || !buf) return 0;
1447 if( lphc->hWndLBox )
1448 {
1449 INT idx = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
1450 if (idx == LB_ERR) goto error;
1451 length = SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, idx, 0 );
1452 if (length == LB_ERR) goto error;
1453
1454 /* 'length' is without the terminating character */
1455 if (length >= count)
1456 {
1457 LPWSTR lpBuffer = HeapAlloc(GetProcessHeap(), 0, (length + 1) * sizeof(WCHAR));
1458 if (!lpBuffer) goto error;
1459 length = SendMessageW(lphc->hWndLBox, LB_GETTEXT, idx, (LPARAM)lpBuffer);
1460
1461 /* truncate if buffer is too short */
1462 if (length != LB_ERR)
1463 {
1464 lstrcpynW( buf, lpBuffer, count );
1465 length = count;
1466 }
1467 HeapFree( GetProcessHeap(), 0, lpBuffer );
1468 }
1469 else length = SendMessageW(lphc->hWndLBox, LB_GETTEXT, idx, (LPARAM)buf);
1470
1471 if (length == LB_ERR) return 0;
1472 return length;
1473 }
1474
1475 error: /* error - truncate string, return zero */
1476 buf[0] = 0;
1477 return 0;
1478 }
1479
1480
1481 /***********************************************************************
1482 * COMBO_GetTextA
1483 *
1484 * NOTE! LB_GETTEXT does not count terminating \0, WM_GETTEXT does.
1485 * also LB_GETTEXT might return values < 0, WM_GETTEXT doesn't.
1486 */
1487 static LRESULT COMBO_GetTextA( LPHEADCOMBO lphc, INT count, LPSTR buf )
1488 {
1489 INT length;
1490
1491 if( lphc->wState & CBF_EDIT )
1492 return SendMessageA( lphc->hWndEdit, WM_GETTEXT, count, (LPARAM)buf );
1493
1494 /* get it from the listbox */
1495
1496 if (!count || !buf) return 0;
1497 if( lphc->hWndLBox )
1498 {
1499 INT idx = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
1500 if (idx == LB_ERR) goto error;
1501 length = SendMessageA(lphc->hWndLBox, LB_GETTEXTLEN, idx, 0 );
1502 if (length == LB_ERR) goto error;
1503
1504 /* 'length' is without the terminating character */
1505 if (length >= count)
1506 {
1507 LPSTR lpBuffer = HeapAlloc(GetProcessHeap(), 0, (length + 1) );
1508 if (!lpBuffer) goto error;
1509 length = SendMessageA(lphc->hWndLBox, LB_GETTEXT, idx, (LPARAM)lpBuffer);
1510
1511 /* truncate if buffer is too short */
1512 if (length != LB_ERR)
1513 {
1514 lstrcpynA( buf, lpBuffer, count );
1515 length = count;
1516 }
1517 HeapFree( GetProcessHeap(), 0, lpBuffer );
1518 }
1519 else length = SendMessageA(lphc->hWndLBox, LB_GETTEXT, idx, (LPARAM)buf);
1520
1521 if (length == LB_ERR) return 0;
1522 return length;
1523 }
1524
1525 error: /* error - truncate string, return zero */
1526 buf[0] = 0;
1527 return 0;
1528 }
1529
1530
1531 /***********************************************************************
1532 * CBResetPos
1533 *
1534 * This function sets window positions according to the updated
1535 * component placement struct.
1536 */
1537 static void CBResetPos(
1538 LPHEADCOMBO lphc,
1539 const RECT *rectEdit,
1540 const RECT *rectLB,
1541 BOOL bRedraw)
1542 {
1543 BOOL bDrop = (CB_GETTYPE(lphc) != CBS_SIMPLE);
1544
1545 /* NOTE: logs sometimes have WM_LBUTTONUP before a cascade of
1546 * sizing messages */
1547
1548 if( lphc->wState & CBF_EDIT )
1549 SetWindowPos( lphc->hWndEdit, 0,
1550 rectEdit->left, rectEdit->top,
1551 rectEdit->right - rectEdit->left,
1552 rectEdit->bottom - rectEdit->top,
1553 SWP_NOZORDER | SWP_NOACTIVATE | ((bDrop) ? SWP_NOREDRAW : 0) );
1554
1555 SetWindowPos( lphc->hWndLBox, 0,
1556 rectLB->left, rectLB->top,
1557 rectLB->right - rectLB->left,
1558 rectLB->bottom - rectLB->top,
1559 SWP_NOACTIVATE | SWP_NOZORDER | ((bDrop) ? SWP_NOREDRAW : 0) );
1560
1561 if( bDrop )
1562 {
1563 if( lphc->wState & CBF_DROPPED )
1564 {
1565 lphc->wState &= ~CBF_DROPPED;
1566 ShowWindow( lphc->hWndLBox, SW_HIDE );
1567 }
1568
1569 if( bRedraw && !(lphc->wState & CBF_NOREDRAW) )
1570 RedrawWindow( lphc->self, NULL, 0,
1571 RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW );
1572 }
1573 }
1574
1575
1576 /***********************************************************************
1577 * COMBO_Size
1578 */
1579 static void COMBO_Size( LPHEADCOMBO lphc, BOOL bRedraw )
1580 {
1581 CBCalcPlacement(lphc->self,
1582 lphc,
1583 &lphc->textRect,
1584 &lphc->buttonRect,
1585 &lphc->droppedRect);
1586
1587 CBResetPos( lphc, &lphc->textRect, &lphc->droppedRect, bRedraw );
1588 }
1589
1590
1591 /***********************************************************************
1592 * COMBO_Font
1593 */
1594 static void COMBO_Font( LPHEADCOMBO lphc, HFONT hFont, BOOL bRedraw )
1595 {
1596 /*
1597 * Set the font
1598 */
1599 lphc->hFont = hFont;
1600
1601 /*
1602 * Propagate to owned windows.
1603 */
1604 if( lphc->wState & CBF_EDIT )
1605 SendMessageW(lphc->hWndEdit, WM_SETFONT, (WPARAM)hFont, bRedraw);
1606 SendMessageW(lphc->hWndLBox, WM_SETFONT, (WPARAM)hFont, bRedraw);
1607
1608 /*
1609 * Redo the layout of the control.
1610 */
1611 if ( CB_GETTYPE(lphc) == CBS_SIMPLE)
1612 {
1613 CBCalcPlacement(lphc->self,
1614 lphc,
1615 &lphc->textRect,
1616 &lphc->buttonRect,
1617 &lphc->droppedRect);
1618
1619 CBResetPos( lphc, &lphc->textRect, &lphc->droppedRect, TRUE );
1620 }
1621 else
1622 {
1623 CBForceDummyResize(lphc);
1624 }
1625 }
1626
1627
1628 /***********************************************************************
1629 * COMBO_SetItemHeight
1630 */
1631 static LRESULT COMBO_SetItemHeight( LPHEADCOMBO lphc, INT index, INT height )
1632 {
1633 LRESULT lRet = CB_ERR;
1634
1635 if( index == -1 ) /* set text field height */
1636 {
1637 if( height < 32768 )
1638 {
1639 lphc->editHeight = height + 2; /* Is the 2 for 2*EDIT_CONTROL_PADDING? */
1640
1641 /*
1642 * Redo the layout of the control.
1643 */
1644 if ( CB_GETTYPE(lphc) == CBS_SIMPLE)
1645 {
1646 CBCalcPlacement(lphc->self,
1647 lphc,
1648 &lphc->textRect,
1649 &lphc->buttonRect,
1650 &lphc->droppedRect);
1651
1652 CBResetPos( lphc, &lphc->textRect, &lphc->droppedRect, TRUE );
1653 }
1654 else
1655 {
1656 CBForceDummyResize(lphc);
1657 }
1658
1659 lRet = height;
1660 }
1661 }
1662 else if ( CB_OWNERDRAWN(lphc) ) /* set listbox item height */
1663 lRet = SendMessageW(lphc->hWndLBox, LB_SETITEMHEIGHT,
1664 (WPARAM)index, (LPARAM)height );
1665 return lRet;
1666 }
1667
1668 /***********************************************************************
1669 * COMBO_SelectString
1670 */
1671 static LRESULT COMBO_SelectString( LPHEADCOMBO lphc, INT start, LPARAM pText, BOOL unicode )
1672 {
1673 INT index = unicode ? SendMessageW(lphc->hWndLBox, LB_SELECTSTRING, (WPARAM)start, pText) :
1674 SendMessageA(lphc->hWndLBox, LB_SELECTSTRING, (WPARAM)start, pText);
1675 if( index >= 0 )
1676 {
1677 if( lphc->wState & CBF_EDIT )
1678 CBUpdateEdit( lphc, index );
1679 else
1680 {
1681 InvalidateRect(lphc->self, &lphc->textRect, TRUE);
1682 }
1683 }
1684 return (LRESULT)index;
1685 }
1686
1687 /***********************************************************************
1688 * COMBO_LButtonDown
1689 */
1690 static void COMBO_LButtonDown( LPHEADCOMBO lphc, LPARAM lParam )
1691 {
1692 POINT pt;
1693 BOOL bButton;
1694 HWND hWnd = lphc->self;
1695
1696 pt.x = (short)LOWORD(lParam);
1697 pt.y = (short)HIWORD(lParam);
1698 bButton = PtInRect(&lphc->buttonRect, pt);
1699
1700 if( (CB_GETTYPE(lphc) == CBS_DROPDOWNLIST) ||
1701 (bButton && (CB_GETTYPE(lphc) == CBS_DROPDOWN)) )
1702 {
1703 lphc->wState |= CBF_BUTTONDOWN;
1704 if( lphc->wState & CBF_DROPPED )
1705 {
1706 /* got a click to cancel selection */
1707
1708 lphc->wState &= ~CBF_BUTTONDOWN;
1709 CBRollUp( lphc, TRUE, FALSE );
1710 if( !IsWindow( hWnd ) ) return;
1711
1712 if( lphc->wState & CBF_CAPTURE )
1713 {
1714 lphc->wState &= ~CBF_CAPTURE;
1715 ReleaseCapture();
1716 }
1717 }
1718 else
1719 {
1720 /* drop down the listbox and start tracking */
1721
1722 lphc->wState |= CBF_CAPTURE;
1723 SetCapture( hWnd );
1724 CBDropDown( lphc );
1725 }
1726 if( bButton ) CBRepaintButton( lphc );
1727 }
1728 }
1729
1730 /***********************************************************************
1731 * COMBO_LButtonUp
1732 *
1733 * Release capture and stop tracking if needed.
1734 */
1735 static void COMBO_LButtonUp( LPHEADCOMBO lphc )
1736 {
1737 if( lphc->wState & CBF_CAPTURE )
1738 {
1739 lphc->wState &= ~CBF_CAPTURE;
1740 if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
1741 {
1742 INT index = CBUpdateLBox( lphc, TRUE );
1743 /* Update edit only if item is in the list */
1744 if(index >= 0)
1745 {
1746 lphc->wState |= CBF_NOLBSELECT;
1747 CBUpdateEdit( lphc, index );
1748 lphc->wState &= ~CBF_NOLBSELECT;
1749 }
1750 }
1751 ReleaseCapture();
1752 SetCapture(lphc->hWndLBox);
1753 }
1754
1755 if( lphc->wState & CBF_BUTTONDOWN )
1756 {
1757 lphc->wState &= ~CBF_BUTTONDOWN;
1758 CBRepaintButton( lphc );
1759 }
1760 }
1761
1762 /***********************************************************************
1763 * COMBO_MouseMove
1764 *
1765 * Two things to do - track combo button and release capture when
1766 * pointer goes into the listbox.
1767 */
1768 static void COMBO_MouseMove( LPHEADCOMBO lphc, WPARAM wParam, LPARAM lParam )
1769 {
1770 POINT pt;
1771 RECT lbRect;
1772
1773 pt.x = (short)LOWORD(lParam);
1774 pt.y = (short)HIWORD(lParam);
1775
1776 if( lphc->wState & CBF_BUTTONDOWN )
1777 {
1778 BOOL bButton;
1779
1780 bButton = PtInRect(&lphc->buttonRect, pt);
1781
1782 if( !bButton )
1783 {
1784 lphc->wState &= ~CBF_BUTTONDOWN;
1785 CBRepaintButton( lphc );
1786 }
1787 }
1788
1789 GetClientRect( lphc->hWndLBox, &lbRect );
1790 MapWindowPoints( lphc->self, lphc->hWndLBox, &pt, 1 );
1791 if( PtInRect(&lbRect, pt) )
1792 {
1793 lphc->wState &= ~CBF_CAPTURE;
1794 ReleaseCapture();
1795 if( CB_GETTYPE(lphc) == CBS_DROPDOWN ) CBUpdateLBox( lphc, TRUE );
1796
1797 /* hand over pointer tracking */
1798 SendMessageW(lphc->hWndLBox, WM_LBUTTONDOWN, wParam, lParam);
1799 }
1800 }
1801
1802 static LRESULT COMBO_GetComboBoxInfo(const HEADCOMBO *lphc, COMBOBOXINFO *pcbi)
1803 {
1804 if (!pcbi || (pcbi->cbSize < sizeof(COMBOBOXINFO)))
1805 return FALSE;
1806
1807 pcbi->rcItem = lphc->textRect;
1808 pcbi->rcButton = lphc->buttonRect;
1809 pcbi->stateButton = 0;
1810 if (lphc->wState & CBF_BUTTONDOWN)
1811 pcbi->stateButton |= STATE_SYSTEM_PRESSED;
1812 if (IsRectEmpty(&lphc->buttonRect))
1813 pcbi->stateButton |= STATE_SYSTEM_INVISIBLE;
1814 pcbi->hwndCombo = lphc->self;
1815 pcbi->hwndItem = lphc->hWndEdit;
1816 pcbi->hwndList = lphc->hWndLBox;
1817 return TRUE;
1818 }
1819
1820 static char *strdupA(LPCSTR str)
1821 {
1822 char *ret;
1823 DWORD len;
1824
1825 if(!str) return NULL;
1826
1827 len = strlen(str);
1828 ret = HeapAlloc(GetProcessHeap(), 0, len + 1);
1829 memcpy(ret, str, len + 1);
1830 return ret;
1831 }
1832
1833 /***********************************************************************
1834 * ComboWndProc_common
1835 */
1836 static LRESULT ComboWndProc_common( HWND hwnd, UINT message,
1837 WPARAM wParam, LPARAM lParam, BOOL unicode )
1838 {
1839 LPHEADCOMBO lphc = (LPHEADCOMBO)GetWindowLongPtrW( hwnd, 0 );
1840
1841 TRACE("[%p]: msg %s wp %08lx lp %08lx\n",
1842 hwnd, SPY_GetMsgName(message, hwnd), wParam, lParam );
1843
1844 if( lphc || message == WM_NCCREATE )
1845 switch(message)
1846 {
1847
1848 /* System messages */
1849
1850 case WM_NCCREATE:
1851 {
1852 LONG style = unicode ? ((LPCREATESTRUCTW)lParam)->style :
1853 ((LPCREATESTRUCTA)lParam)->style;
1854 return COMBO_NCCreate(hwnd, style);
1855 }
1856 case WM_NCDESTROY:
1857 COMBO_NCDestroy(lphc);
1858 break;/* -> DefWindowProc */
1859
1860 case WM_CREATE:
1861 {
1862 HWND hwndParent;
1863 LONG style;
1864 if(unicode)
1865 {
1866 hwndParent = ((LPCREATESTRUCTW)lParam)->hwndParent;
1867 style = ((LPCREATESTRUCTW)lParam)->style;
1868 }
1869 else
1870 {
1871 hwndParent = ((LPCREATESTRUCTA)lParam)->hwndParent;
1872 style = ((LPCREATESTRUCTA)lParam)->style;
1873 }
1874 return COMBO_Create(hwnd, lphc, hwndParent, style, unicode);
1875 }
1876
1877 case WM_PRINTCLIENT:
1878 /* Fallthrough */
1879 case WM_PAINT:
1880 /* wParam may contain a valid HDC! */
1881 return COMBO_Paint(lphc, (HDC)wParam);
1882
1883 case WM_ERASEBKGND:
1884 /* do all painting in WM_PAINT like Windows does */
1885 return 1;
1886
1887 case WM_GETDLGCODE:
1888 {
1889 LRESULT result = DLGC_WANTARROWS | DLGC_WANTCHARS;
1890 if (lParam && (((LPMSG)lParam)->message == WM_KEYDOWN))
1891 {
1892 int vk = (int)((LPMSG)lParam)->wParam;
1893
1894 if ((vk == VK_RETURN || vk == VK_ESCAPE) && (lphc->wState & CBF_DROPPED))
1895 result |= DLGC_WANTMESSAGE;
1896 }
1897 return result;
1898 }
1899 case WM_WINDOWPOSCHANGING:
1900 return COMBO_WindowPosChanging(hwnd, lphc, (LPWINDOWPOS)lParam);
1901 case WM_WINDOWPOSCHANGED:
1902 /* SetWindowPos can be called on a Combobox to resize its Listbox.
1903 * In that case, the Combobox itself will not be resized, so we won't
1904 * get a WM_SIZE. Since we still want to update the Listbox, we have to
1905 * do it here.
1906 */
1907 /* we should not force repainting on WM_WINDOWPOSCHANGED, it breaks
1908 * Z-order based painting.
1909 */
1910 /* fall through */
1911 case WM_SIZE:
1912 if( lphc->hWndLBox &&
1913 !(lphc->wState & CBF_NORESIZE) ) COMBO_Size( lphc, message == WM_SIZE );
1914 return TRUE;
1915 case WM_SETFONT:
1916 COMBO_Font( lphc, (HFONT)wParam, (BOOL)lParam );
1917 return TRUE;
1918 case WM_GETFONT:
1919 return (LRESULT)lphc->hFont;
1920 case WM_SETFOCUS:
1921 if( lphc->wState & CBF_EDIT )
1922 SetFocus( lphc->hWndEdit );
1923 else
1924 COMBO_SetFocus( lphc );
1925 return TRUE;
1926 case WM_KILLFOCUS:
1927 {
1928 HWND hwndFocus = WIN_GetFullHandle( (HWND)wParam );
1929 if( !hwndFocus ||
1930 (hwndFocus != lphc->hWndEdit && hwndFocus != lphc->hWndLBox ))
1931 COMBO_KillFocus( lphc );
1932 return TRUE;
1933 }
1934 case WM_COMMAND:
1935 return COMBO_Command( lphc, wParam, WIN_GetFullHandle( (HWND)lParam ) );
1936 case WM_GETTEXT:
1937 return unicode ? COMBO_GetTextW( lphc, wParam, (LPWSTR)lParam )
1938 : COMBO_GetTextA( lphc, wParam, (LPSTR)lParam );
1939 case WM_SETTEXT:
1940 case WM_GETTEXTLENGTH:
1941 case WM_CLEAR:
1942 if ((message == WM_GETTEXTLENGTH) && !ISWIN31 && !(lphc->wState & CBF_EDIT))
1943 {
1944 int j = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
1945 if (j == -1) return 0;
1946 return unicode ? SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, j, 0) :
1947 SendMessageA(lphc->hWndLBox, LB_GETTEXTLEN, j, 0);
1948 }
1949 else if( lphc->wState & CBF_EDIT )
1950 {
1951 LRESULT ret;
1952 lphc->wState |= CBF_NOEDITNOTIFY;
1953 ret = unicode ? SendMessageW(lphc->hWndEdit, message, wParam, lParam) :
1954 SendMessageA(lphc->hWndEdit, message, wParam, lParam);
1955 lphc->wState &= ~CBF_NOEDITNOTIFY;
1956 return ret;
1957 }
1958 else return CB_ERR;
1959 case WM_CUT:
1960 case WM_PASTE:
1961 case WM_COPY:
1962 if( lphc->wState & CBF_EDIT )
1963 {
1964 return unicode ? SendMessageW(lphc->hWndEdit, message, wParam, lParam) :
1965 SendMessageA(lphc->hWndEdit, message, wParam, lParam);
1966 }
1967 else return CB_ERR;
1968
1969 case WM_DRAWITEM:
1970 case WM_DELETEITEM:
1971 case WM_COMPAREITEM:
1972 case WM_MEASUREITEM:
1973 return COMBO_ItemOp(lphc, message, lParam);
1974 case WM_ENABLE:
1975 if( lphc->wState & CBF_EDIT )
1976 EnableWindow( lphc->hWndEdit, (BOOL)wParam );
1977 EnableWindow( lphc->hWndLBox, (BOOL)wParam );
1978
1979 /* Force the control to repaint when the enabled state changes. */
1980 InvalidateRect(lphc->self, NULL, TRUE);
1981 return TRUE;
1982 case WM_SETREDRAW:
1983 if( wParam )
1984 lphc->wState &= ~CBF_NOREDRAW;
1985 else
1986 lphc->wState |= CBF_NOREDRAW;
1987
1988 if( lphc->wState & CBF_EDIT )
1989 SendMessageW(lphc->hWndEdit, message, wParam, lParam);
1990 SendMessageW(lphc->hWndLBox, message, wParam, lParam);
1991 return 0;
1992 case WM_SYSKEYDOWN:
1993 if( KEYDATA_ALT & HIWORD(lParam) )
1994 if( wParam == VK_UP || wParam == VK_DOWN )
1995 COMBO_FlipListbox( lphc, FALSE, FALSE );
1996 return 0;
1997
1998 case WM_CHAR:
1999 case WM_IME_CHAR:
2000 case WM_KEYDOWN:
2001 {
2002 HWND hwndTarget;
2003
2004 if ((wParam == VK_RETURN || wParam == VK_ESCAPE) &&
2005 (lphc->wState & CBF_DROPPED))
2006 {
2007 CBRollUp( lphc, wParam == VK_RETURN, FALSE );
2008 return TRUE;
2009 }
2010 else if ((wParam == VK_F4) && !(lphc->wState & CBF_EUI))
2011 {
2012 COMBO_FlipListbox( lphc, FALSE, FALSE );
2013 return TRUE;
2014 }
2015
2016 if( lphc->wState & CBF_EDIT )
2017 hwndTarget = lphc->hWndEdit;
2018 else
2019 hwndTarget = lphc->hWndLBox;
2020
2021 return unicode ? SendMessageW(hwndTarget, message, wParam, lParam) :
2022 SendMessageA(hwndTarget, message, wParam, lParam);
2023 }
2024 case WM_LBUTTONDOWN:
2025 if( !(lphc->wState & CBF_FOCUSED) ) SetFocus( lphc->self );
2026 if( lphc->wState & CBF_FOCUSED ) COMBO_LButtonDown( lphc, lParam );
2027 return TRUE;
2028 case WM_LBUTTONUP:
2029 COMBO_LButtonUp( lphc );
2030 return TRUE;
2031 case WM_MOUSEMOVE:
2032 if( lphc->wState & CBF_CAPTURE )
2033 COMBO_MouseMove( lphc, wParam, lParam );
2034 return TRUE;
2035
2036 case WM_MOUSEWHEEL:
2037 if (wParam & (MK_SHIFT | MK_CONTROL))
2038 return unicode ? DefWindowProcW(hwnd, message, wParam, lParam) :
2039 DefWindowProcA(hwnd, message, wParam, lParam);
2040
2041 if (GET_WHEEL_DELTA_WPARAM(wParam) > 0) return SendMessageW(hwnd, WM_KEYDOWN, VK_UP, 0);
2042 if (GET_WHEEL_DELTA_WPARAM(wParam) < 0) return SendMessageW(hwnd, WM_KEYDOWN, VK_DOWN, 0);
2043 return TRUE;
2044
2045 /* Combo messages */
2046
2047 case CB_ADDSTRING16:
2048 if( CB_HASSTRINGS(lphc) ) lParam = (LPARAM)MapSL(lParam);
2049 /* fall through */
2050 case CB_ADDSTRING:
2051 if( unicode )
2052 {
2053 if( lphc->dwStyle & CBS_LOWERCASE )
2054 CharLowerW((LPWSTR)lParam);
2055 else if( lphc->dwStyle & CBS_UPPERCASE )
2056 CharUpperW((LPWSTR)lParam);
2057 return SendMessageW(lphc->hWndLBox, LB_ADDSTRING, 0, lParam);
2058 }
2059 else /* unlike the unicode version, the ansi version does not overwrite
2060 the string if converting case */
2061 {
2062 char *string = NULL;
2063 LRESULT ret;
2064 if( lphc->dwStyle & CBS_LOWERCASE )
2065 {
2066 string = strdupA((LPSTR)lParam);
2067 CharLowerA(string);
2068 }
2069
2070 else if( lphc->dwStyle & CBS_UPPERCASE )
2071 {
2072 string = strdupA((LPSTR)lParam);
2073 CharUpperA(string);
2074 }
2075
2076 ret = SendMessageA(lphc->hWndLBox, LB_ADDSTRING, 0, string ? (LPARAM)string : lParam);
2077 HeapFree(GetProcessHeap(), 0, string);
2078 return ret;
2079 }
2080 case CB_INSERTSTRING16:
2081 wParam = (INT)(INT16)wParam;
2082 if( CB_HASSTRINGS(lphc) ) lParam = (LPARAM)MapSL(lParam);
2083 /* fall through */
2084 case CB_INSERTSTRING:
2085 if( unicode )
2086 {
2087 if( lphc->dwStyle & CBS_LOWERCASE )
2088 CharLowerW((LPWSTR)lParam);
2089 else if( lphc->dwStyle & CBS_UPPERCASE )
2090 CharUpperW((LPWSTR)lParam);
2091 return SendMessageW(lphc->hWndLBox, LB_INSERTSTRING, wParam, lParam);
2092 }
2093 else
2094 {
2095 if( lphc->dwStyle & CBS_LOWERCASE )
2096 CharLowerA((LPSTR)lParam);
2097 else if( lphc->dwStyle & CBS_UPPERCASE )
2098 CharUpperA((LPSTR)lParam);
2099
2100 return SendMessageA(lphc->hWndLBox, LB_INSERTSTRING, wParam, lParam);
2101 }
2102 case CB_DELETESTRING16:
2103 case CB_DELETESTRING:
2104 return unicode ? SendMessageW(lphc->hWndLBox, LB_DELETESTRING, wParam, 0) :
2105 SendMessageA(lphc->hWndLBox, LB_DELETESTRING, wParam, 0);
2106 case CB_SELECTSTRING16:
2107 wParam = (INT)(INT16)wParam;
2108 if( CB_HASSTRINGS(lphc) ) lParam = (LPARAM)MapSL(lParam);
2109 /* fall through */
2110 case CB_SELECTSTRING:
2111 return COMBO_SelectString(lphc, (INT)wParam, lParam, unicode);
2112 case CB_FINDSTRING16:
2113 wParam = (INT)(INT16)wParam;
2114 if( CB_HASSTRINGS(lphc) ) lParam = (LPARAM)MapSL(lParam);
2115 /* fall through */
2116 case CB_FINDSTRING:
2117 return unicode ? SendMessageW(lphc->hWndLBox, LB_FINDSTRING, wParam, lParam) :
2118 SendMessageA(lphc->hWndLBox, LB_FINDSTRING, wParam, lParam);
2119 case CB_FINDSTRINGEXACT16:
2120 wParam = (INT)(INT16)wParam;
2121 if( CB_HASSTRINGS(lphc) ) lParam = (LPARAM)MapSL(lParam);
2122 /* fall through */
2123 case CB_FINDSTRINGEXACT:
2124 return unicode ? SendMessageW(lphc->hWndLBox, LB_FINDSTRINGEXACT, wParam, lParam) :
2125 SendMessageA(lphc->hWndLBox, LB_FINDSTRINGEXACT, wParam, lParam);
2126 case CB_SETITEMHEIGHT16:
2127 wParam = (INT)(INT16)wParam; /* signed integer */
2128 /* fall through */
2129 case CB_SETITEMHEIGHT:
2130 return COMBO_SetItemHeight( lphc, (INT)wParam, (INT)lParam);
2131 case CB_GETITEMHEIGHT16:
2132 wParam = (INT)(INT16)wParam;
2133 /* fall through */
2134 case CB_GETITEMHEIGHT:
2135 if( (INT)wParam >= 0 ) /* listbox item */
2136 return SendMessageW(lphc->hWndLBox, LB_GETITEMHEIGHT, wParam, 0);
2137 return CBGetTextAreaHeight(hwnd, lphc);
2138 case CB_RESETCONTENT16:
2139 case CB_RESETCONTENT:
2140 SendMessageW(lphc->hWndLBox, LB_RESETCONTENT, 0, 0);
2141 if( (lphc->wState & CBF_EDIT) && CB_HASSTRINGS(lphc) )
2142 {
2143 static const WCHAR empty_stringW[] = { 0 };
2144 SendMessageW(lphc->hWndEdit, WM_SETTEXT, 0, (LPARAM)empty_stringW);
2145 }
2146 else
2147 InvalidateRect(lphc->self, NULL, TRUE);
2148 return TRUE;
2149 case CB_INITSTORAGE:
2150 return SendMessageW(lphc->hWndLBox, LB_INITSTORAGE, wParam, lParam);
2151 case CB_GETHORIZONTALEXTENT:
2152 return SendMessageW(lphc->hWndLBox, LB_GETHORIZONTALEXTENT, 0, 0);
2153 case CB_SETHORIZONTALEXTENT:
2154 return SendMessageW(lphc->hWndLBox, LB_SETHORIZONTALEXTENT, wParam, 0);
2155 case CB_GETTOPINDEX:
2156 return SendMessageW(lphc->hWndLBox, LB_GETTOPINDEX, 0, 0);
2157 case CB_GETLOCALE:
2158 return SendMessageW(lphc->hWndLBox, LB_GETLOCALE, 0, 0);
2159 case CB_SETLOCALE:
2160 return SendMessageW(lphc->hWndLBox, LB_SETLOCALE, wParam, 0);
2161 case CB_GETDROPPEDWIDTH:
2162 if( lphc->droppedWidth )
2163 return lphc->droppedWidth;
2164 return lphc->droppedRect.right - lphc->droppedRect.left;
2165 case CB_SETDROPPEDWIDTH:
2166 if( (CB_GETTYPE(lphc) != CBS_SIMPLE) &&
2167 (INT)wParam < 32768 ) lphc->droppedWidth = (INT)wParam;
2168 return CB_ERR;
2169 case CB_GETDROPPEDCONTROLRECT16:
2170 lParam = (LPARAM)MapSL(lParam);
2171 if( lParam )
2172 {
2173 RECT r;
2174 RECT16 *r16 = (RECT16 *)lParam;
2175 CBGetDroppedControlRect( lphc, &r );
2176 r16->left = r.left;
2177 r16->top = r.top;
2178 r16->right = r.right;
2179 r16->bottom = r.bottom;
2180 }
2181 return CB_OKAY;
2182 case CB_GETDROPPEDCONTROLRECT:
2183 if( lParam ) CBGetDroppedControlRect(lphc, (LPRECT)lParam );
2184 return CB_OKAY;
2185 case CB_GETDROPPEDSTATE16:
2186 case CB_GETDROPPEDSTATE:
2187 return (lphc->wState & CBF_DROPPED) ? TRUE : FALSE;
2188 case CB_DIR16:
2189 return SendMessageA(lphc->hWndLBox, LB_DIR16, wParam, lParam);
2190 case CB_DIR:
2191 return unicode ? SendMessageW(lphc->hWndLBox, LB_DIR, wParam, lParam) :
2192 SendMessageA(lphc->hWndLBox, LB_DIR, wParam, lParam);
2193
2194 case CB_SHOWDROPDOWN16:
2195 case CB_SHOWDROPDOWN:
2196 if( CB_GETTYPE(lphc) != CBS_SIMPLE )
2197 {
2198 if( wParam )
2199 {
2200 if( !(lphc->wState & CBF_DROPPED) )
2201 CBDropDown( lphc );
2202 }
2203 else
2204 if( lphc->wState & CBF_DROPPED )
2205 CBRollUp( lphc, FALSE, TRUE );
2206 }
2207 return TRUE;
2208 case CB_GETCOUNT16:
2209 case CB_GETCOUNT:
2210 return SendMessageW(lphc->hWndLBox, LB_GETCOUNT, 0, 0);
2211 case CB_GETCURSEL16:
2212 case CB_GETCURSEL:
2213 return SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
2214 case CB_SETCURSEL16:
2215 wParam = (INT)(INT16)wParam;
2216 /* fall through */
2217 case CB_SETCURSEL:
2218 lParam = SendMessageW(lphc->hWndLBox, LB_SETCURSEL, wParam, 0);
2219 if( lParam >= 0 )
2220 SendMessageW(lphc->hWndLBox, LB_SETTOPINDEX, wParam, 0);
2221
2222 /* no LBN_SELCHANGE in this case, update manually */
2223 if( lphc->wState & CBF_EDIT )
2224 CBUpdateEdit( lphc, (INT)wParam );
2225 else
2226 InvalidateRect(lphc->self, &lphc->textRect, TRUE);
2227 lphc->wState &= ~CBF_SELCHANGE;
2228 return lParam;
2229 case CB_GETLBTEXT16:
2230 wParam = (INT)(INT16)wParam;
2231 lParam = (LPARAM)MapSL(lParam);
2232 /* fall through */
2233 case CB_GETLBTEXT:
2234 return unicode ? SendMessageW(lphc->hWndLBox, LB_GETTEXT, wParam, lParam) :
2235 SendMessageA(lphc->hWndLBox, LB_GETTEXT, wParam, lParam);
2236 case CB_GETLBTEXTLEN16:
2237 wParam = (INT)(INT16)wParam;
2238 /* fall through */
2239 case CB_GETLBTEXTLEN:
2240 return unicode ? SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, wParam, 0) :
2241 SendMessageA(lphc->hWndLBox, LB_GETTEXTLEN, wParam, 0);
2242 case CB_GETITEMDATA16:
2243 wParam = (INT)(INT16)wParam;
2244 /* fall through */
2245 case CB_GETITEMDATA:
2246 return SendMessageW(lphc->hWndLBox, LB_GETITEMDATA, wParam, 0);
2247 case CB_SETITEMDATA16:
2248 wParam = (INT)(INT16)wParam;
2249 /* fall through */
2250 case CB_SETITEMDATA:
2251 return SendMessageW(lphc->hWndLBox, LB_SETITEMDATA, wParam, lParam);
2252 case CB_GETEDITSEL16:
2253 wParam = lParam = 0; /* just in case */
2254 /* fall through */
2255 case CB_GETEDITSEL:
2256 /* Edit checks passed parameters itself */
2257 if( lphc->wState & CBF_EDIT )
2258 return SendMessageW(lphc->hWndEdit, EM_GETSEL, wParam, lParam);
2259 return CB_ERR;
2260 case CB_SETEDITSEL16:
2261 case CB_SETEDITSEL:
2262 if( lphc->wState & CBF_EDIT )
2263 return SendMessageW(lphc->hWndEdit, EM_SETSEL,
2264 (INT)(INT16)LOWORD(lParam), (INT)(INT16)HIWORD(lParam) );
2265 return CB_ERR;
2266 case CB_SETEXTENDEDUI16:
2267 case CB_SETEXTENDEDUI:
2268 if( CB_GETTYPE(lphc) == CBS_SIMPLE )
2269 return CB_ERR;
2270 if( wParam )
2271 lphc->wState |= CBF_EUI;
2272 else lphc->wState &= ~CBF_EUI;
2273 return CB_OKAY;
2274 case CB_GETEXTENDEDUI16:
2275 case CB_GETEXTENDEDUI:
2276 return (lphc->wState & CBF_EUI) ? TRUE : FALSE;
2277 case CB_GETCOMBOBOXINFO:
2278 return COMBO_GetComboBoxInfo(lphc, (COMBOBOXINFO *)lParam);
2279 case CB_LIMITTEXT:
2280 if( lphc->wState & CBF_EDIT )
2281 return SendMessageW(lphc->hWndEdit, EM_LIMITTEXT, wParam, lParam);
2282 default:
2283 if (message >= WM_USER)
2284 WARN("unknown msg WM_USER+%04x wp=%04lx lp=%08lx\n",
2285 message - WM_USER, wParam, lParam );
2286 break;
2287 }
2288 return unicode ? DefWindowProcW(hwnd, message, wParam, lParam) :
2289 DefWindowProcA(hwnd, message, wParam, lParam);
2290 }
2291
2292 /***********************************************************************
2293 * ComboWndProcA
2294 *
2295 * This is just a wrapper for the real ComboWndProc which locks/unlocks
2296 * window structs.
2297 */
2298 static LRESULT WINAPI ComboWndProcA( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
2299 {
2300 if (!IsWindow(hwnd)) return 0;
2301 return ComboWndProc_common( hwnd, message, wParam, lParam, FALSE );
2302 }
2303
2304 /***********************************************************************
2305 * ComboWndProcW
2306 */
2307 static LRESULT WINAPI ComboWndProcW( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
2308 {
2309 if (!IsWindow(hwnd)) return 0;
2310 return ComboWndProc_common( hwnd, message, wParam, lParam, TRUE );
2311 }
2312
2313 /*************************************************************************
2314 * GetComboBoxInfo (USER32.@)
2315 */
2316 BOOL WINAPI GetComboBoxInfo(HWND hwndCombo, /* [in] handle to combo box */
2317 PCOMBOBOXINFO pcbi /* [in/out] combo box information */)
2318 {
2319 TRACE("(%p, %p)\n", hwndCombo, pcbi);
2320 return SendMessageW(hwndCombo, CB_GETCOMBOBOXINFO, 0, (LPARAM)pcbi);
2321 }
Windows API implementation