4 * Copyright 1997 Alex Korobka
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 * This code was audited for completeness against the documented features
23 * of Comctl32.dll version 6.0 on Oct. 4, 2004, by Dimitrie O. Paun.
25 * Unless otherwise noted, we believe this code to be complete, as per
26 * the specification mentioned above.
27 * If you discover missing features, or bugs, please note them below.
30 * - ComboBox_[GS]etMinVisible()
31 * - CB_GETMINVISIBLE, CB_SETMINVISIBLE
44 #include "wine/winuser16.h"
45 #include "wine/unicode.h"
46 #include "user_private.h"
50 #include "wine/debug.h"
52 WINE_DEFAULT_DEBUG_CHANNEL(combo
);
54 /* bits in the dwKeyData */
55 #define KEYDATA_ALT 0x2000
56 #define KEYDATA_PREVSTATE 0x4000
59 * Additional combo box definitions
62 #define CB_NOTIFY( lphc, code ) \
63 (SendMessageW((lphc)->owner, WM_COMMAND, \
64 MAKEWPARAM(GetWindowLongPtrW((lphc)->self,GWLP_ID), (code)), (LPARAM)(lphc)->self))
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))
72 #define ISWIN31 (LOWORD(GetVersion()) == 0x0a03)
77 static HBITMAP hComboBmp
= 0;
78 static UINT CBitHeight
, CBitWidth
;
81 * Look and feel dependent "constants"
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
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
);
93 /*********************************************************************
94 * combo class descriptor
96 static const WCHAR comboboxW
[] = {'C','o','m','b','o','B','o','x',0};
97 const struct builtin_class_descr COMBO_builtin_class
=
100 CS_PARENTDC
| CS_DBLCLKS
| CS_HREDRAW
| CS_VREDRAW
, /* style */
101 ComboWndProcA
, /* procA */
102 ComboWndProcW
, /* procW */
103 sizeof(HEADCOMBO
*), /* extra */
104 IDC_ARROW
, /* cursor */
109 /***********************************************************************
112 * Load combo button bitmap.
114 static BOOL
COMBO_Init(void)
118 if( hComboBmp
) return TRUE
;
119 if( (hDC
= CreateCompatibleDC(0)) )
122 if( (hComboBmp
= LoadBitmapW(0, MAKEINTRESOURCEW(OBM_COMBO
))) )
128 GetObjectW( hComboBmp
, sizeof(bm
), &bm
);
129 CBitHeight
= bm
.bmHeight
;
130 CBitWidth
= bm
.bmWidth
;
132 TRACE("combo bitmap [%i,%i]\n", CBitWidth
, CBitHeight
);
134 hPrevB
= SelectObject( hDC
, hComboBmp
);
135 SetRect( &r
, 0, 0, CBitWidth
, CBitHeight
);
136 InvertRect( hDC
, &r
);
137 SelectObject( hDC
, hPrevB
);
146 /***********************************************************************
149 static LRESULT
COMBO_NCCreate(HWND hwnd
, LONG style
)
153 if (COMBO_Init() && (lphc
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(HEADCOMBO
))) )
156 SetWindowLongPtrW( hwnd
, 0, (LONG_PTR
)lphc
);
158 /* some braindead apps do try to use scrollbar/border flags */
160 lphc
->dwStyle
= style
& ~(WS_BORDER
| WS_HSCROLL
| WS_VSCROLL
);
161 SetWindowLongW( hwnd
, GWL_STYLE
, style
& ~(WS_BORDER
| WS_HSCROLL
| WS_VSCROLL
) );
164 * We also have to remove the client edge style to make sure
165 * we don't end-up with a non client area.
167 SetWindowLongW( hwnd
, GWL_EXSTYLE
,
168 GetWindowLongW( hwnd
, GWL_EXSTYLE
) & ~WS_EX_CLIENTEDGE
);
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
;
175 TRACE("[%p], style = %08x\n", lphc
, lphc
->dwStyle
);
181 /***********************************************************************
184 static LRESULT
COMBO_NCDestroy( LPHEADCOMBO lphc
)
189 TRACE("[%p]: freeing storage\n", lphc
->self
);
191 if( (CB_GETTYPE(lphc
) != CBS_SIMPLE
) && lphc
->hWndLBox
)
192 DestroyWindow( lphc
->hWndLBox
);
194 SetWindowLongPtrW( lphc
->self
, 0, 0 );
195 HeapFree( GetProcessHeap(), 0, lphc
);
200 /***********************************************************************
201 * CBGetTextAreaHeight
203 * This method will calculate the height of the text area of the
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
212 static INT
CBGetTextAreaHeight(
218 if( lphc
->editHeight
) /* explicitly set height */
220 iTextItemHeight
= lphc
->editHeight
;
225 HDC hDC
= GetDC(hwnd
);
230 hPrevFont
= SelectObject( hDC
, lphc
->hFont
);
232 GetTextMetricsW(hDC
, &tm
);
234 baseUnitY
= tm
.tmHeight
;
237 SelectObject( hDC
, hPrevFont
);
239 ReleaseDC(hwnd
, hDC
);
241 iTextItemHeight
= baseUnitY
+ 4;
245 * Check the ownerdraw case if we haven't asked the parent the size
248 if ( CB_OWNERDRAWN(lphc
) &&
249 (lphc
->wState
& CBF_MEASUREITEM
) )
251 MEASUREITEMSTRUCT measureItem
;
253 INT originalItemHeight
= iTextItemHeight
;
254 UINT id
= (UINT
)GetWindowLongPtrW( lphc
->self
, GWLP_ID
);
257 * We use the client rect for the width of the item.
259 GetClientRect(hwnd
, &clientRect
);
261 lphc
->wState
&= ~CBF_MEASUREITEM
;
264 * Send a first one to measure the size of the text area
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
;
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)
279 if (lphc
->dwStyle
& CBS_OWNERDRAWFIXED
)
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
;
292 * Keep the size for the next time
294 lphc
->editHeight
= iTextItemHeight
;
297 return iTextItemHeight
;
300 /***********************************************************************
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.
307 static void CBForceDummyResize(
313 newComboHeight
= CBGetTextAreaHeight(lphc
->self
,lphc
) + 2*COMBO_YBORDERSIZE();
315 GetWindowRect(lphc
->self
, &windowRect
);
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
325 SetWindowPos( lphc
->self
,
328 windowRect
.right
- windowRect
.left
,
330 SWP_NOMOVE
| SWP_NOZORDER
| SWP_NOACTIVATE
);
333 /***********************************************************************
336 * Set up component coordinates given valid lphc->RectCombo.
338 static void CBCalcPlacement(
346 * Again, start with the client rectangle.
348 GetClientRect(hwnd
, lprEdit
);
353 InflateRect(lprEdit
, -COMBO_XBORDERSIZE(), -COMBO_YBORDERSIZE());
356 * Chop off the bottom part to fit with the height of the text area.
358 lprEdit
->bottom
= lprEdit
->top
+ CBGetTextAreaHeight(hwnd
, lphc
);
361 * The button starts the same vertical position as the text area.
363 CopyRect(lprButton
, lprEdit
);
366 * If the combobox is "simple" there is no button.
368 if( CB_GETTYPE(lphc
) == CBS_SIMPLE
)
369 lprButton
->left
= lprButton
->right
= lprButton
->bottom
= 0;
373 * Let's assume the combobox button is the same width as the
375 * size the button horizontally and cut-off the text area.
377 lprButton
->left
= lprButton
->right
- GetSystemMetrics(SM_CXVSCROLL
);
378 lprEdit
->right
= lprButton
->left
;
382 * In the case of a dropdown, there is an additional spacing between the
383 * text area and the button.
385 if( CB_GETTYPE(lphc
) == CBS_DROPDOWN
)
387 lprEdit
->right
-= COMBO_EDITBUTTONSPACE();
391 * If we have an edit control, we space it away from the borders slightly.
393 if (CB_GETTYPE(lphc
) != CBS_DROPDOWNLIST
)
395 InflateRect(lprEdit
, -EDIT_CONTROL_PADDING(), -EDIT_CONTROL_PADDING());
399 * Adjust the size of the listbox popup.
401 if( CB_GETTYPE(lphc
) == CBS_SIMPLE
)
404 * Use the client rectangle to initialize the listbox rectangle
406 GetClientRect(hwnd
, lprLB
);
409 * Then, chop-off the top part.
411 lprLB
->top
= lprEdit
->bottom
+ COMBO_YBORDERSIZE();
416 * Make sure the dropped width is as large as the combobox itself.
418 if (lphc
->droppedWidth
< (lprButton
->right
+ COMBO_XBORDERSIZE()))
420 lprLB
->right
= lprLB
->left
+ (lprButton
->right
+ COMBO_XBORDERSIZE());
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
427 if( CB_GETTYPE(lphc
) == CBS_DROPDOWN
)
428 lprLB
->right
-= COMBO_EDITBUTTONSPACE();
431 lprLB
->right
= lprLB
->left
+ lphc
->droppedWidth
;
434 /* don't allow negative window width */
435 if (lprEdit
->right
< lprEdit
->left
)
436 lprEdit
->right
= lprEdit
->left
;
438 TRACE("\ttext\t= (%d,%d-%d,%d)\n",
439 lprEdit
->left
, lprEdit
->top
, lprEdit
->right
, lprEdit
->bottom
);
441 TRACE("\tbutton\t= (%d,%d-%d,%d)\n",
442 lprButton
->left
, lprButton
->top
, lprButton
->right
, lprButton
->bottom
);
444 TRACE("\tlbox\t= (%d,%d-%d,%d)\n",
445 lprLB
->left
, lprLB
->top
, lprLB
->right
, lprLB
->bottom
);
448 /***********************************************************************
449 * CBGetDroppedControlRect
451 static void CBGetDroppedControlRect( LPHEADCOMBO lphc
, LPRECT lpRect
)
453 /* In windows, CB_GETDROPPEDCONTROLRECT returns the upper left corner
454 of the combo box and the lower right corner of the listbox */
456 GetWindowRect(lphc
->self
, lpRect
);
458 lpRect
->right
= lpRect
->left
+ lphc
->droppedRect
.right
- lphc
->droppedRect
.left
;
459 lpRect
->bottom
= lpRect
->top
+ lphc
->droppedRect
.bottom
- lphc
->droppedRect
.top
;
463 /***********************************************************************
464 * COMBO_WindowPosChanging
466 static LRESULT
COMBO_WindowPosChanging(
469 WINDOWPOS
* posChanging
)
472 * We need to override the WM_WINDOWPOSCHANGING method to handle all
473 * the non-simple comboboxes. The problem is that those controls are
474 * always the same height. We have to make sure they are not resized
477 if ( ( CB_GETTYPE(lphc
) != CBS_SIMPLE
) &&
478 ((posChanging
->flags
& SWP_NOSIZE
) == 0) )
482 newComboHeight
= CBGetTextAreaHeight(hwnd
,lphc
) +
483 2*COMBO_YBORDERSIZE();
486 * Resizing a combobox has another side effect, it resizes the dropped
487 * rectangle as well. However, it does it only if the new height for the
488 * combobox is different from the height it should have. In other words,
489 * if the application resizing the combobox only had the intention to resize
490 * the actual control, for example, to do the layout of a dialog that is
491 * resized, the height of the dropdown is not changed.
493 if (posChanging
->cy
!= newComboHeight
)
495 TRACE("posChanging->cy=%d, newComboHeight=%d, oldbot=%d, oldtop=%d\n",
496 posChanging
->cy
, newComboHeight
, lphc
->droppedRect
.bottom
,
497 lphc
->droppedRect
.top
);
498 lphc
->droppedRect
.bottom
= lphc
->droppedRect
.top
+ posChanging
->cy
- newComboHeight
;
500 posChanging
->cy
= newComboHeight
;
507 /***********************************************************************
510 static LRESULT
COMBO_Create( HWND hwnd
, LPHEADCOMBO lphc
, HWND hwndParent
, LONG style
,
513 static const WCHAR clbName
[] = {'C','o','m','b','o','L','B','o','x',0};
514 static const WCHAR editName
[] = {'E','d','i','t',0};
516 if( !CB_GETTYPE(lphc
) ) lphc
->dwStyle
|= CBS_SIMPLE
;
517 if( CB_GETTYPE(lphc
) != CBS_DROPDOWNLIST
) lphc
->wState
|= CBF_EDIT
;
519 lphc
->owner
= hwndParent
;
522 * The item height and dropped width are not set when the control
525 lphc
->droppedWidth
= lphc
->editHeight
= 0;
528 * The first time we go through, we want to measure the ownerdraw item
530 lphc
->wState
|= CBF_MEASUREITEM
;
532 /* M$ IE 3.01 actually creates (and rapidly destroys) an ownerless combobox */
534 if( lphc
->owner
|| !(style
& WS_VISIBLE
) )
540 * Initialize the dropped rect to the size of the client area of the
541 * control and then, force all the areas of the combobox to be
544 GetClientRect( hwnd
, &lphc
->droppedRect
);
545 CBCalcPlacement(hwnd
, lphc
, &lphc
->textRect
, &lphc
->buttonRect
, &lphc
->droppedRect
);
548 * Adjust the position of the popup listbox if it's necessary
550 if ( CB_GETTYPE(lphc
) != CBS_SIMPLE
)
552 lphc
->droppedRect
.top
= lphc
->textRect
.bottom
+ COMBO_YBORDERSIZE();
555 * If it's a dropdown, the listbox is offset
557 if( CB_GETTYPE(lphc
) == CBS_DROPDOWN
)
558 lphc
->droppedRect
.left
+= COMBO_EDITBUTTONSPACE();
560 if (lphc
->droppedRect
.bottom
< lphc
->droppedRect
.top
)
561 lphc
->droppedRect
.bottom
= lphc
->droppedRect
.top
;
562 if (lphc
->droppedRect
.right
< lphc
->droppedRect
.left
)
563 lphc
->droppedRect
.right
= lphc
->droppedRect
.left
;
564 MapWindowPoints( hwnd
, 0, (LPPOINT
)&lphc
->droppedRect
, 2 );
567 /* create listbox popup */
569 lbeStyle
= (LBS_NOTIFY
| LBS_COMBOBOX
| WS_BORDER
| WS_CLIPSIBLINGS
| WS_CHILD
) |
570 (style
& (WS_VSCROLL
| CBS_OWNERDRAWFIXED
| CBS_OWNERDRAWVARIABLE
));
572 if( lphc
->dwStyle
& CBS_SORT
)
573 lbeStyle
|= LBS_SORT
;
574 if( lphc
->dwStyle
& CBS_HASSTRINGS
)
575 lbeStyle
|= LBS_HASSTRINGS
;
576 if( lphc
->dwStyle
& CBS_NOINTEGRALHEIGHT
)
577 lbeStyle
|= LBS_NOINTEGRALHEIGHT
;
578 if( lphc
->dwStyle
& CBS_DISABLENOSCROLL
)
579 lbeStyle
|= LBS_DISABLENOSCROLL
;
581 if( CB_GETTYPE(lphc
) == CBS_SIMPLE
) /* child listbox */
583 lbeStyle
|= WS_VISIBLE
;
586 * In win 95 look n feel, the listbox in the simple combobox has
587 * the WS_EXCLIENTEDGE style instead of the WS_BORDER style.
589 lbeStyle
&= ~WS_BORDER
;
590 lbeExStyle
|= WS_EX_CLIENTEDGE
;
594 lbeExStyle
|= (WS_EX_TOPMOST
| WS_EX_TOOLWINDOW
);
598 lphc
->hWndLBox
= CreateWindowExW(lbeExStyle
, clbName
, NULL
, lbeStyle
,
599 lphc
->droppedRect
.left
,
600 lphc
->droppedRect
.top
,
601 lphc
->droppedRect
.right
- lphc
->droppedRect
.left
,
602 lphc
->droppedRect
.bottom
- lphc
->droppedRect
.top
,
603 hwnd
, (HMENU
)ID_CB_LISTBOX
,
604 (HINSTANCE
)GetWindowLongPtrW( hwnd
, GWLP_HINSTANCE
), lphc
);
606 lphc
->hWndLBox
= CreateWindowExA(lbeExStyle
, "ComboLBox", NULL
, lbeStyle
,
607 lphc
->droppedRect
.left
,
608 lphc
->droppedRect
.top
,
609 lphc
->droppedRect
.right
- lphc
->droppedRect
.left
,
610 lphc
->droppedRect
.bottom
- lphc
->droppedRect
.top
,
611 hwnd
, (HMENU
)ID_CB_LISTBOX
,
612 (HINSTANCE
)GetWindowLongPtrW( hwnd
, GWLP_HINSTANCE
), lphc
);
617 lbeStyle
= WS_CHILD
| WS_VISIBLE
| ES_NOHIDESEL
| ES_LEFT
| ES_COMBO
;
619 if( lphc
->wState
& CBF_EDIT
)
621 if( lphc
->dwStyle
& CBS_OEMCONVERT
)
622 lbeStyle
|= ES_OEMCONVERT
;
623 if( lphc
->dwStyle
& CBS_AUTOHSCROLL
)
624 lbeStyle
|= ES_AUTOHSCROLL
;
625 if( lphc
->dwStyle
& CBS_LOWERCASE
)
626 lbeStyle
|= ES_LOWERCASE
;
627 else if( lphc
->dwStyle
& CBS_UPPERCASE
)
628 lbeStyle
|= ES_UPPERCASE
;
630 if (!IsWindowEnabled(hwnd
)) lbeStyle
|= WS_DISABLED
;
633 lphc
->hWndEdit
= CreateWindowExW(0, editName
, NULL
, lbeStyle
,
634 lphc
->textRect
.left
, lphc
->textRect
.top
,
635 lphc
->textRect
.right
- lphc
->textRect
.left
,
636 lphc
->textRect
.bottom
- lphc
->textRect
.top
,
637 hwnd
, (HMENU
)ID_CB_EDIT
,
638 (HINSTANCE
)GetWindowLongPtrW( hwnd
, GWLP_HINSTANCE
), NULL
);
640 lphc
->hWndEdit
= CreateWindowExA(0, "Edit", NULL
, lbeStyle
,
641 lphc
->textRect
.left
, lphc
->textRect
.top
,
642 lphc
->textRect
.right
- lphc
->textRect
.left
,
643 lphc
->textRect
.bottom
- lphc
->textRect
.top
,
644 hwnd
, (HMENU
)ID_CB_EDIT
,
645 (HINSTANCE
)GetWindowLongPtrW( hwnd
, GWLP_HINSTANCE
), NULL
);
647 if( !lphc
->hWndEdit
)
653 if( CB_GETTYPE(lphc
) != CBS_SIMPLE
)
655 /* Now do the trick with parent */
656 SetParent(lphc
->hWndLBox
, HWND_DESKTOP
);
658 * If the combo is a dropdown, we must resize the control
659 * to fit only the text area and button. To do this,
660 * we send a dummy resize and the WM_WINDOWPOSCHANGING message
661 * will take care of setting the height for us.
663 CBForceDummyResize(lphc
);
666 TRACE("init done\n");
669 ERR("edit control failure.\n");
670 } else ERR("listbox failure.\n");
671 } else ERR("no owner for visible combo.\n");
673 /* CreateWindow() will send WM_NCDESTROY to cleanup */
678 /***********************************************************************
681 * Paint combo button (normal, pressed, and disabled states).
683 static void CBPaintButton( LPHEADCOMBO lphc
, HDC hdc
, RECT rectButton
)
685 UINT buttonState
= DFCS_SCROLLCOMBOBOX
;
687 if( lphc
->wState
& CBF_NOREDRAW
)
691 if (lphc
->wState
& CBF_BUTTONDOWN
)
692 buttonState
|= DFCS_PUSHED
;
694 if (CB_DISABLED(lphc
))
695 buttonState
|= DFCS_INACTIVE
;
697 DrawFrameControl(hdc
, &rectButton
, DFC_SCROLL
, buttonState
);
700 /***********************************************************************
703 * Paint CBS_DROPDOWNLIST text field / update edit control contents.
705 static void CBPaintText(
713 if( lphc
->wState
& CBF_NOREDRAW
) return;
717 /* follow Windows combobox that sends a bunch of text
718 * inquiries to its listbox while processing WM_PAINT. */
720 if( (id
= SendMessageW(lphc
->hWndLBox
, LB_GETCURSEL
, 0, 0) ) != LB_ERR
)
722 size
= SendMessageW(lphc
->hWndLBox
, LB_GETTEXTLEN
, id
, 0);
724 FIXME("LB_ERR probably not handled yet\n");
725 if( (pText
= HeapAlloc( GetProcessHeap(), 0, (size
+ 1) * sizeof(WCHAR
))) )
727 /* size from LB_GETTEXTLEN may be too large, from LB_GETTEXT is accurate */
728 size
=SendMessageW(lphc
->hWndLBox
, LB_GETTEXT
, (WPARAM
)id
, (LPARAM
)pText
);
729 pText
[size
] = '\0'; /* just in case */
733 if( !CB_OWNERDRAWN(lphc
) )
736 if( lphc
->wState
& CBF_EDIT
)
738 static const WCHAR empty_stringW
[] = { 0 };
739 if( CB_HASSTRINGS(lphc
) ) SetWindowTextW( lphc
->hWndEdit
, pText
? pText
: empty_stringW
);
740 if( lphc
->wState
& CBF_FOCUSED
)
741 SendMessageW(lphc
->hWndEdit
, EM_SETSEL
, 0, (LPARAM
)(-1));
743 else /* paint text field ourselves */
745 UINT itemState
= ODS_COMBOBOXEDIT
;
746 HFONT hPrevFont
= (lphc
->hFont
) ? SelectObject(hdc
, lphc
->hFont
) : 0;
749 * Give ourselves some space.
751 InflateRect( &rectEdit
, -1, -1 );
753 if( CB_OWNERDRAWN(lphc
) )
757 UINT ctlid
= (UINT
)GetWindowLongPtrW( lphc
->self
, GWLP_ID
);
759 /* setup state for DRAWITEM message. Owner will highlight */
760 if ( (lphc
->wState
& CBF_FOCUSED
) &&
761 !(lphc
->wState
& CBF_DROPPED
) )
762 itemState
|= ODS_SELECTED
| ODS_FOCUS
;
765 * Save the current clip region.
766 * To retrieve the clip region, we need to create one "dummy"
769 clipRegion
= CreateRectRgnIndirect(&rectEdit
);
771 if (GetClipRgn(hdc
, clipRegion
)!=1)
773 DeleteObject(clipRegion
);
777 if (!IsWindowEnabled(lphc
->self
)) itemState
|= ODS_DISABLED
;
779 dis
.CtlType
= ODT_COMBOBOX
;
781 dis
.hwndItem
= lphc
->self
;
782 dis
.itemAction
= ODA_DRAWENTIRE
;
784 dis
.itemState
= itemState
;
786 dis
.rcItem
= rectEdit
;
787 dis
.itemData
= SendMessageW(lphc
->hWndLBox
, LB_GETITEMDATA
,
791 * Clip the DC and have the parent draw the item.
793 IntersectClipRect(hdc
,
794 rectEdit
.left
, rectEdit
.top
,
795 rectEdit
.right
, rectEdit
.bottom
);
797 SendMessageW(lphc
->owner
, WM_DRAWITEM
, ctlid
, (LPARAM
)&dis
);
800 * Reset the clipping region.
802 SelectClipRgn(hdc
, clipRegion
);
806 static const WCHAR empty_stringW
[] = { 0 };
808 if ( (lphc
->wState
& CBF_FOCUSED
) &&
809 !(lphc
->wState
& CBF_DROPPED
) ) {
812 FillRect( hdc
, &rectEdit
, GetSysColorBrush(COLOR_HIGHLIGHT
) );
813 SetBkColor( hdc
, GetSysColor( COLOR_HIGHLIGHT
) );
814 SetTextColor( hdc
, GetSysColor( COLOR_HIGHLIGHTTEXT
) );
820 ETO_OPAQUE
| ETO_CLIPPED
,
822 pText
? pText
: empty_stringW
, size
, NULL
);
824 if(lphc
->wState
& CBF_FOCUSED
&& !(lphc
->wState
& CBF_DROPPED
))
825 DrawFocusRect( hdc
, &rectEdit
);
829 SelectObject(hdc
, hPrevFont
);
831 HeapFree( GetProcessHeap(), 0, pText
);
834 /***********************************************************************
837 static void CBPaintBorder(
839 const HEADCOMBO
*lphc
,
844 if (CB_GETTYPE(lphc
) != CBS_SIMPLE
)
846 GetClientRect(hwnd
, &clientRect
);
850 CopyRect(&clientRect
, &lphc
->textRect
);
852 InflateRect(&clientRect
, EDIT_CONTROL_PADDING(), EDIT_CONTROL_PADDING());
853 InflateRect(&clientRect
, COMBO_XBORDERSIZE(), COMBO_YBORDERSIZE());
856 DrawEdge(hdc
, &clientRect
, EDGE_SUNKEN
, BF_RECT
);
859 /***********************************************************************
860 * COMBO_PrepareColors
862 * This method will sent the appropriate WM_CTLCOLOR message to
863 * prepare and setup the colors for the combo's DC.
865 * It also returns the brush to use for the background.
867 static HBRUSH
COMBO_PrepareColors(
874 * Get the background brush for this control.
876 if (CB_DISABLED(lphc
))
878 hBkgBrush
= (HBRUSH
)SendMessageW(lphc
->owner
, WM_CTLCOLORSTATIC
,
879 (WPARAM
)hDC
, (LPARAM
)lphc
->self
);
882 * We have to change the text color since WM_CTLCOLORSTATIC will
883 * set it to the "enabled" color. This is the same behavior as the
886 SetTextColor(hDC
, GetSysColor(COLOR_GRAYTEXT
));
890 if (lphc
->wState
& CBF_EDIT
)
892 hBkgBrush
= (HBRUSH
)SendMessageW(lphc
->owner
, WM_CTLCOLOREDIT
,
893 (WPARAM
)hDC
, (LPARAM
)lphc
->self
);
897 hBkgBrush
= (HBRUSH
)SendMessageW(lphc
->owner
, WM_CTLCOLORLISTBOX
,
898 (WPARAM
)hDC
, (LPARAM
)lphc
->self
);
906 hBkgBrush
= GetSysColorBrush(COLOR_WINDOW
);
912 /***********************************************************************
915 static LRESULT
COMBO_Paint(LPHEADCOMBO lphc
, HDC hParamDC
)
920 hDC
= (hParamDC
) ? hParamDC
921 : BeginPaint( lphc
->self
, &ps
);
923 TRACE("hdc=%p\n", hDC
);
925 if( hDC
&& !(lphc
->wState
& CBF_NOREDRAW
) )
927 HBRUSH hPrevBrush
, hBkgBrush
;
930 * Retrieve the background brush and select it in the
933 hBkgBrush
= COMBO_PrepareColors(lphc
, hDC
);
935 hPrevBrush
= SelectObject( hDC
, hBkgBrush
);
936 if (!(lphc
->wState
& CBF_EDIT
))
937 FillRect(hDC
, &lphc
->textRect
, hBkgBrush
);
940 * In non 3.1 look, there is a sunken border on the combobox
942 CBPaintBorder(lphc
->self
, lphc
, hDC
);
944 if( !IsRectEmpty(&lphc
->buttonRect
) )
946 CBPaintButton(lphc
, hDC
, lphc
->buttonRect
);
949 /* paint the edit control padding area */
950 if (CB_GETTYPE(lphc
) != CBS_DROPDOWNLIST
)
952 RECT rPadEdit
= lphc
->textRect
;
954 InflateRect(&rPadEdit
, EDIT_CONTROL_PADDING(), EDIT_CONTROL_PADDING());
956 FrameRect( hDC
, &rPadEdit
, GetSysColorBrush(COLOR_WINDOW
) );
959 if( !(lphc
->wState
& CBF_EDIT
) )
960 CBPaintText( lphc
, hDC
, lphc
->textRect
);
963 SelectObject( hDC
, hPrevBrush
);
967 EndPaint(lphc
->self
, &ps
);
972 /***********************************************************************
975 * Select listbox entry according to the contents of the edit control.
977 static INT
CBUpdateLBox( LPHEADCOMBO lphc
, BOOL bSelect
)
983 length
= SendMessageW( lphc
->hWndEdit
, WM_GETTEXTLENGTH
, 0, 0 );
986 pText
= HeapAlloc( GetProcessHeap(), 0, (length
+ 1) * sizeof(WCHAR
));
988 TRACE("\t edit text length %i\n", length
);
992 GetWindowTextW( lphc
->hWndEdit
, pText
, length
+ 1);
993 idx
= SendMessageW(lphc
->hWndLBox
, LB_FINDSTRING
,
994 (WPARAM
)(-1), (LPARAM
)pText
);
995 HeapFree( GetProcessHeap(), 0, pText
);
998 SendMessageW(lphc
->hWndLBox
, LB_SETCURSEL
, (WPARAM
)(bSelect
? idx
: -1), 0);
1000 /* probably superfluous but Windows sends this too */
1001 SendMessageW(lphc
->hWndLBox
, LB_SETCARETINDEX
, (WPARAM
)(idx
< 0 ? 0 : idx
), 0);
1002 SendMessageW(lphc
->hWndLBox
, LB_SETTOPINDEX
, (WPARAM
)(idx
< 0 ? 0 : idx
), 0);
1007 /***********************************************************************
1010 * Copy a listbox entry to the edit control.
1012 static void CBUpdateEdit( LPHEADCOMBO lphc
, INT index
)
1015 LPWSTR pText
= NULL
;
1016 static const WCHAR empty_stringW
[] = { 0 };
1018 TRACE("\t %i\n", index
);
1020 if( index
>= 0 ) /* got an entry */
1022 length
= SendMessageW(lphc
->hWndLBox
, LB_GETTEXTLEN
, (WPARAM
)index
, 0);
1023 if( length
!= LB_ERR
)
1025 if( (pText
= HeapAlloc( GetProcessHeap(), 0, (length
+ 1) * sizeof(WCHAR
))) )
1027 SendMessageW(lphc
->hWndLBox
, LB_GETTEXT
,
1028 (WPARAM
)index
, (LPARAM
)pText
);
1033 if( CB_HASSTRINGS(lphc
) )
1035 lphc
->wState
|= (CBF_NOEDITNOTIFY
| CBF_NOLBSELECT
);
1036 SendMessageW(lphc
->hWndEdit
, WM_SETTEXT
, 0, pText
? (LPARAM
)pText
: (LPARAM
)empty_stringW
);
1037 lphc
->wState
&= ~(CBF_NOEDITNOTIFY
| CBF_NOLBSELECT
);
1040 if( lphc
->wState
& CBF_FOCUSED
)
1041 SendMessageW(lphc
->hWndEdit
, EM_SETSEL
, 0, (LPARAM
)(-1));
1043 HeapFree( GetProcessHeap(), 0, pText
);
1046 /***********************************************************************
1049 * Show listbox popup.
1051 static void CBDropDown( LPHEADCOMBO lphc
)
1054 MONITORINFO mon_info
;
1059 TRACE("[%p]: drop down\n", lphc
->self
);
1061 CB_NOTIFY( lphc
, CBN_DROPDOWN
);
1065 lphc
->wState
|= CBF_DROPPED
;
1066 if( CB_GETTYPE(lphc
) == CBS_DROPDOWN
)
1068 lphc
->droppedIndex
= CBUpdateLBox( lphc
, TRUE
);
1070 /* Update edit only if item is in the list */
1071 if( !(lphc
->wState
& CBF_CAPTURE
) && lphc
->droppedIndex
>= 0)
1072 CBUpdateEdit( lphc
, lphc
->droppedIndex
);
1076 lphc
->droppedIndex
= SendMessageW(lphc
->hWndLBox
, LB_GETCURSEL
, 0, 0);
1078 SendMessageW(lphc
->hWndLBox
, LB_SETTOPINDEX
,
1079 (WPARAM
)(lphc
->droppedIndex
== LB_ERR
? 0 : lphc
->droppedIndex
), 0 );
1080 SendMessageW(lphc
->hWndLBox
, LB_CARETON
, 0, 0);
1083 /* now set popup position */
1084 GetWindowRect( lphc
->self
, &rect
);
1087 * If it's a dropdown, the listbox is offset
1089 if( CB_GETTYPE(lphc
) == CBS_DROPDOWN
)
1090 rect
.left
+= COMBO_EDITBUTTONSPACE();
1092 /* if the dropped height is greater than the total height of the dropped
1093 items list, then force the drop down list height to be the total height
1094 of the items in the dropped list */
1096 /* And Remove any extra space (Best Fit) */
1097 nDroppedHeight
= lphc
->droppedRect
.bottom
- lphc
->droppedRect
.top
;
1098 /* if listbox length has been set directly by its handle */
1099 GetWindowRect(lphc
->hWndLBox
, &r
);
1100 if (nDroppedHeight
< r
.bottom
- r
.top
)
1101 nDroppedHeight
= r
.bottom
- r
.top
;
1102 nItems
= (int)SendMessageW(lphc
->hWndLBox
, LB_GETCOUNT
, 0, 0);
1109 nIHeight
= (int)SendMessageW(lphc
->hWndLBox
, LB_GETITEMHEIGHT
, 0, 0);
1111 nHeight
= nIHeight
*nItems
;
1113 if (nHeight
< nDroppedHeight
- COMBO_YBORDERSIZE())
1114 nDroppedHeight
= nHeight
+ COMBO_YBORDERSIZE();
1116 if (nDroppedHeight
< nHeight
)
1119 nDroppedHeight
= (nItems
+1)*nIHeight
;
1121 nDroppedHeight
= 6*nIHeight
;
1125 /*If height of dropped rectangle gets beyond a screen size it should go up, otherwise down.*/
1126 monitor
= MonitorFromRect( &rect
, MONITOR_DEFAULTTOPRIMARY
);
1127 mon_info
.cbSize
= sizeof(mon_info
);
1128 GetMonitorInfoW( monitor
, &mon_info
);
1130 if( (rect
.bottom
+ nDroppedHeight
) >= mon_info
.rcWork
.bottom
)
1131 rect
.bottom
= rect
.top
- nDroppedHeight
;
1133 SetWindowPos( lphc
->hWndLBox
, HWND_TOP
, rect
.left
, rect
.bottom
,
1134 lphc
->droppedRect
.right
- lphc
->droppedRect
.left
,
1136 SWP_NOACTIVATE
| SWP_SHOWWINDOW
);
1139 if( !(lphc
->wState
& CBF_NOREDRAW
) )
1140 RedrawWindow( lphc
->self
, NULL
, 0, RDW_INVALIDATE
|
1141 RDW_ERASE
| RDW_UPDATENOW
| RDW_NOCHILDREN
);
1143 EnableWindow( lphc
->hWndLBox
, TRUE
);
1144 if (GetCapture() != lphc
->self
)
1145 SetCapture(lphc
->hWndLBox
);
1148 /***********************************************************************
1151 * Hide listbox popup.
1153 static void CBRollUp( LPHEADCOMBO lphc
, BOOL ok
, BOOL bButton
)
1155 HWND hWnd
= lphc
->self
;
1157 TRACE("[%p]: sel ok? [%i] dropped? [%i]\n",
1158 lphc
->self
, ok
, (INT
)(lphc
->wState
& CBF_DROPPED
));
1160 CB_NOTIFY( lphc
, (ok
) ? CBN_SELENDOK
: CBN_SELENDCANCEL
);
1162 if( IsWindow( hWnd
) && CB_GETTYPE(lphc
) != CBS_SIMPLE
)
1165 if( lphc
->wState
& CBF_DROPPED
)
1169 lphc
->wState
&= ~CBF_DROPPED
;
1170 ShowWindow( lphc
->hWndLBox
, SW_HIDE
);
1172 if(GetCapture() == lphc
->hWndLBox
)
1177 if( CB_GETTYPE(lphc
) == CBS_DROPDOWN
)
1179 rect
= lphc
->buttonRect
;
1190 rect
= lphc
->textRect
;
1195 if( bButton
&& !(lphc
->wState
& CBF_NOREDRAW
) )
1196 RedrawWindow( hWnd
, &rect
, 0, RDW_INVALIDATE
|
1197 RDW_ERASE
| RDW_UPDATENOW
| RDW_NOCHILDREN
);
1198 CB_NOTIFY( lphc
, CBN_CLOSEUP
);
1203 /***********************************************************************
1206 * Used by the ComboLBox to show/hide itself in response to VK_F4, etc...
1208 BOOL
COMBO_FlipListbox( LPHEADCOMBO lphc
, BOOL ok
, BOOL bRedrawButton
)
1210 if( lphc
->wState
& CBF_DROPPED
)
1212 CBRollUp( lphc
, ok
, bRedrawButton
);
1220 /***********************************************************************
1223 static void CBRepaintButton( LPHEADCOMBO lphc
)
1225 InvalidateRect(lphc
->self
, &lphc
->buttonRect
, TRUE
);
1226 UpdateWindow(lphc
->self
);
1229 /***********************************************************************
1232 static void COMBO_SetFocus( LPHEADCOMBO lphc
)
1234 if( !(lphc
->wState
& CBF_FOCUSED
) )
1236 if( CB_GETTYPE(lphc
) == CBS_DROPDOWNLIST
)
1237 SendMessageW(lphc
->hWndLBox
, LB_CARETON
, 0, 0);
1239 /* This is wrong. Message sequences seem to indicate that this
1240 is set *after* the notify. */
1241 /* lphc->wState |= CBF_FOCUSED; */
1243 if( !(lphc
->wState
& CBF_EDIT
) )
1244 InvalidateRect(lphc
->self
, &lphc
->textRect
, TRUE
);
1246 CB_NOTIFY( lphc
, CBN_SETFOCUS
);
1247 lphc
->wState
|= CBF_FOCUSED
;
1251 /***********************************************************************
1254 static void COMBO_KillFocus( LPHEADCOMBO lphc
)
1256 HWND hWnd
= lphc
->self
;
1258 if( lphc
->wState
& CBF_FOCUSED
)
1260 CBRollUp( lphc
, FALSE
, TRUE
);
1261 if( IsWindow( hWnd
) )
1263 if( CB_GETTYPE(lphc
) == CBS_DROPDOWNLIST
)
1264 SendMessageW(lphc
->hWndLBox
, LB_CARETOFF
, 0, 0);
1266 lphc
->wState
&= ~CBF_FOCUSED
;
1269 if( !(lphc
->wState
& CBF_EDIT
) )
1270 InvalidateRect(lphc
->self
, &lphc
->textRect
, TRUE
);
1272 CB_NOTIFY( lphc
, CBN_KILLFOCUS
);
1277 /***********************************************************************
1280 static LRESULT
COMBO_Command( LPHEADCOMBO lphc
, WPARAM wParam
, HWND hWnd
)
1282 if ( lphc
->wState
& CBF_EDIT
&& lphc
->hWndEdit
== hWnd
)
1284 /* ">> 8" makes gcc generate jump-table instead of cmp ladder */
1286 switch( HIWORD(wParam
) >> 8 )
1288 case (EN_SETFOCUS
>> 8):
1290 TRACE("[%p]: edit [%p] got focus\n", lphc
->self
, lphc
->hWndEdit
);
1292 COMBO_SetFocus( lphc
);
1295 case (EN_KILLFOCUS
>> 8):
1297 TRACE("[%p]: edit [%p] lost focus\n", lphc
->self
, lphc
->hWndEdit
);
1299 /* NOTE: it seems that Windows' edit control sends an
1300 * undocumented message WM_USER + 0x1B instead of this
1301 * notification (only when it happens to be a part of
1302 * the combo). ?? - AK.
1305 COMBO_KillFocus( lphc
);
1309 case (EN_CHANGE
>> 8):
1311 * In some circumstances (when the selection of the combobox
1312 * is changed for example) we don't want the EN_CHANGE notification
1313 * to be forwarded to the parent of the combobox. This code
1314 * checks a flag that is set in these occasions and ignores the
1317 if (lphc
->wState
& CBF_NOLBSELECT
)
1319 lphc
->wState
&= ~CBF_NOLBSELECT
;
1323 CBUpdateLBox( lphc
, lphc
->wState
& CBF_DROPPED
);
1326 if (!(lphc
->wState
& CBF_NOEDITNOTIFY
))
1327 CB_NOTIFY( lphc
, CBN_EDITCHANGE
);
1330 case (EN_UPDATE
>> 8):
1331 if (!(lphc
->wState
& CBF_NOEDITNOTIFY
))
1332 CB_NOTIFY( lphc
, CBN_EDITUPDATE
);
1335 case (EN_ERRSPACE
>> 8):
1336 CB_NOTIFY( lphc
, CBN_ERRSPACE
);
1339 else if( lphc
->hWndLBox
== hWnd
)
1341 switch( (short)HIWORD(wParam
) )
1344 CB_NOTIFY( lphc
, CBN_ERRSPACE
);
1348 CB_NOTIFY( lphc
, CBN_DBLCLK
);
1354 TRACE("[%p]: lbox selection change [%x]\n", lphc
->self
, lphc
->wState
);
1356 CB_NOTIFY( lphc
, CBN_SELCHANGE
);
1358 if( HIWORD(wParam
) == LBN_SELCHANGE
)
1360 if( lphc
->wState
& CBF_EDIT
)
1362 INT index
= SendMessageW(lphc
->hWndLBox
, LB_GETCURSEL
, 0, 0);
1363 lphc
->wState
|= CBF_NOLBSELECT
;
1364 CBUpdateEdit( lphc
, index
);
1365 /* select text in edit, as Windows does */
1366 SendMessageW(lphc
->hWndEdit
, EM_SETSEL
, 0, (LPARAM
)(-1));
1369 InvalidateRect(lphc
->self
, &lphc
->textRect
, TRUE
);
1372 /* do not roll up if selection is being tracked
1373 * by arrowkeys in the dropdown listbox */
1374 if( ((lphc
->wState
& CBF_DROPPED
) && !(lphc
->wState
& CBF_NOROLLUP
)) )
1376 CBRollUp( lphc
, (HIWORD(wParam
) == LBN_SELCHANGE
), TRUE
);
1378 else lphc
->wState
&= ~CBF_NOROLLUP
;
1384 /* nothing to do here since ComboLBox always resets the focus to its
1385 * combo/edit counterpart */
1392 /***********************************************************************
1395 * Fixup an ownerdrawn item operation and pass it up to the combobox owner.
1397 static LRESULT
COMBO_ItemOp( LPHEADCOMBO lphc
, UINT msg
, LPARAM lParam
)
1399 HWND hWnd
= lphc
->self
;
1400 UINT id
= (UINT
)GetWindowLongPtrW( hWnd
, GWLP_ID
);
1402 TRACE("[%p]: ownerdraw op %04x\n", lphc
->self
, msg
);
1408 DELETEITEMSTRUCT
*lpIS
= (DELETEITEMSTRUCT
*)lParam
;
1409 lpIS
->CtlType
= ODT_COMBOBOX
;
1411 lpIS
->hwndItem
= hWnd
;
1416 DRAWITEMSTRUCT
*lpIS
= (DRAWITEMSTRUCT
*)lParam
;
1417 lpIS
->CtlType
= ODT_COMBOBOX
;
1419 lpIS
->hwndItem
= hWnd
;
1422 case WM_COMPAREITEM
:
1424 COMPAREITEMSTRUCT
*lpIS
= (COMPAREITEMSTRUCT
*)lParam
;
1425 lpIS
->CtlType
= ODT_COMBOBOX
;
1427 lpIS
->hwndItem
= hWnd
;
1430 case WM_MEASUREITEM
:
1432 MEASUREITEMSTRUCT
*lpIS
= (MEASUREITEMSTRUCT
*)lParam
;
1433 lpIS
->CtlType
= ODT_COMBOBOX
;
1438 return SendMessageW(lphc
->owner
, msg
, id
, lParam
);
1442 /***********************************************************************
1445 static LRESULT
COMBO_GetTextW( LPHEADCOMBO lphc
, INT count
, LPWSTR buf
)
1449 if( lphc
->wState
& CBF_EDIT
)
1450 return SendMessageW( lphc
->hWndEdit
, WM_GETTEXT
, count
, (LPARAM
)buf
);
1452 /* get it from the listbox */
1454 if (!count
|| !buf
) return 0;
1455 if( lphc
->hWndLBox
)
1457 INT idx
= SendMessageW(lphc
->hWndLBox
, LB_GETCURSEL
, 0, 0);
1458 if (idx
== LB_ERR
) goto error
;
1459 length
= SendMessageW(lphc
->hWndLBox
, LB_GETTEXTLEN
, idx
, 0 );
1460 if (length
== LB_ERR
) goto error
;
1462 /* 'length' is without the terminating character */
1463 if (length
>= count
)
1465 LPWSTR lpBuffer
= HeapAlloc(GetProcessHeap(), 0, (length
+ 1) * sizeof(WCHAR
));
1466 if (!lpBuffer
) goto error
;
1467 length
= SendMessageW(lphc
->hWndLBox
, LB_GETTEXT
, idx
, (LPARAM
)lpBuffer
);
1469 /* truncate if buffer is too short */
1470 if (length
!= LB_ERR
)
1472 lstrcpynW( buf
, lpBuffer
, count
);
1475 HeapFree( GetProcessHeap(), 0, lpBuffer
);
1477 else length
= SendMessageW(lphc
->hWndLBox
, LB_GETTEXT
, idx
, (LPARAM
)buf
);
1479 if (length
== LB_ERR
) return 0;
1483 error
: /* error - truncate string, return zero */
1489 /***********************************************************************
1492 * NOTE! LB_GETTEXT does not count terminating \0, WM_GETTEXT does.
1493 * also LB_GETTEXT might return values < 0, WM_GETTEXT doesn't.
1495 static LRESULT
COMBO_GetTextA( LPHEADCOMBO lphc
, INT count
, LPSTR buf
)
1499 if( lphc
->wState
& CBF_EDIT
)
1500 return SendMessageA( lphc
->hWndEdit
, WM_GETTEXT
, count
, (LPARAM
)buf
);
1502 /* get it from the listbox */
1504 if (!count
|| !buf
) return 0;
1505 if( lphc
->hWndLBox
)
1507 INT idx
= SendMessageW(lphc
->hWndLBox
, LB_GETCURSEL
, 0, 0);
1508 if (idx
== LB_ERR
) goto error
;
1509 length
= SendMessageA(lphc
->hWndLBox
, LB_GETTEXTLEN
, idx
, 0 );
1510 if (length
== LB_ERR
) goto error
;
1512 /* 'length' is without the terminating character */
1513 if (length
>= count
)
1515 LPSTR lpBuffer
= HeapAlloc(GetProcessHeap(), 0, (length
+ 1) );
1516 if (!lpBuffer
) goto error
;
1517 length
= SendMessageA(lphc
->hWndLBox
, LB_GETTEXT
, idx
, (LPARAM
)lpBuffer
);
1519 /* truncate if buffer is too short */
1520 if (length
!= LB_ERR
)
1522 lstrcpynA( buf
, lpBuffer
, count
);
1525 HeapFree( GetProcessHeap(), 0, lpBuffer
);
1527 else length
= SendMessageA(lphc
->hWndLBox
, LB_GETTEXT
, idx
, (LPARAM
)buf
);
1529 if (length
== LB_ERR
) return 0;
1533 error
: /* error - truncate string, return zero */
1539 /***********************************************************************
1542 * This function sets window positions according to the updated
1543 * component placement struct.
1545 static void CBResetPos(
1547 const RECT
*rectEdit
,
1551 BOOL bDrop
= (CB_GETTYPE(lphc
) != CBS_SIMPLE
);
1553 /* NOTE: logs sometimes have WM_LBUTTONUP before a cascade of
1554 * sizing messages */
1556 if( lphc
->wState
& CBF_EDIT
)
1557 SetWindowPos( lphc
->hWndEdit
, 0,
1558 rectEdit
->left
, rectEdit
->top
,
1559 rectEdit
->right
- rectEdit
->left
,
1560 rectEdit
->bottom
- rectEdit
->top
,
1561 SWP_NOZORDER
| SWP_NOACTIVATE
| ((bDrop
) ? SWP_NOREDRAW
: 0) );
1563 SetWindowPos( lphc
->hWndLBox
, 0,
1564 rectLB
->left
, rectLB
->top
,
1565 rectLB
->right
- rectLB
->left
,
1566 rectLB
->bottom
- rectLB
->top
,
1567 SWP_NOACTIVATE
| SWP_NOZORDER
| ((bDrop
) ? SWP_NOREDRAW
: 0) );
1571 if( lphc
->wState
& CBF_DROPPED
)
1573 lphc
->wState
&= ~CBF_DROPPED
;
1574 ShowWindow( lphc
->hWndLBox
, SW_HIDE
);
1577 if( bRedraw
&& !(lphc
->wState
& CBF_NOREDRAW
) )
1578 RedrawWindow( lphc
->self
, NULL
, 0,
1579 RDW_INVALIDATE
| RDW_ERASE
| RDW_UPDATENOW
);
1584 /***********************************************************************
1587 static void COMBO_Size( LPHEADCOMBO lphc
, BOOL bRedraw
)
1589 CBCalcPlacement(lphc
->self
,
1593 &lphc
->droppedRect
);
1595 CBResetPos( lphc
, &lphc
->textRect
, &lphc
->droppedRect
, bRedraw
);
1599 /***********************************************************************
1602 static void COMBO_Font( LPHEADCOMBO lphc
, HFONT hFont
, BOOL bRedraw
)
1607 lphc
->hFont
= hFont
;
1610 * Propagate to owned windows.
1612 if( lphc
->wState
& CBF_EDIT
)
1613 SendMessageW(lphc
->hWndEdit
, WM_SETFONT
, (WPARAM
)hFont
, bRedraw
);
1614 SendMessageW(lphc
->hWndLBox
, WM_SETFONT
, (WPARAM
)hFont
, bRedraw
);
1617 * Redo the layout of the control.
1619 if ( CB_GETTYPE(lphc
) == CBS_SIMPLE
)
1621 CBCalcPlacement(lphc
->self
,
1625 &lphc
->droppedRect
);
1627 CBResetPos( lphc
, &lphc
->textRect
, &lphc
->droppedRect
, TRUE
);
1631 CBForceDummyResize(lphc
);
1636 /***********************************************************************
1637 * COMBO_SetItemHeight
1639 static LRESULT
COMBO_SetItemHeight( LPHEADCOMBO lphc
, INT index
, INT height
)
1641 LRESULT lRet
= CB_ERR
;
1643 if( index
== -1 ) /* set text field height */
1645 if( height
< 32768 )
1647 lphc
->editHeight
= height
+ 2; /* Is the 2 for 2*EDIT_CONTROL_PADDING? */
1650 * Redo the layout of the control.
1652 if ( CB_GETTYPE(lphc
) == CBS_SIMPLE
)
1654 CBCalcPlacement(lphc
->self
,
1658 &lphc
->droppedRect
);
1660 CBResetPos( lphc
, &lphc
->textRect
, &lphc
->droppedRect
, TRUE
);
1664 CBForceDummyResize(lphc
);
1670 else if ( CB_OWNERDRAWN(lphc
) ) /* set listbox item height */
1671 lRet
= SendMessageW(lphc
->hWndLBox
, LB_SETITEMHEIGHT
,
1672 (WPARAM
)index
, (LPARAM
)height
);
1676 /***********************************************************************
1677 * COMBO_SelectString
1679 static LRESULT
COMBO_SelectString( LPHEADCOMBO lphc
, INT start
, LPARAM pText
, BOOL unicode
)
1681 INT index
= unicode
? SendMessageW(lphc
->hWndLBox
, LB_SELECTSTRING
, (WPARAM
)start
, pText
) :
1682 SendMessageA(lphc
->hWndLBox
, LB_SELECTSTRING
, (WPARAM
)start
, pText
);
1685 if( lphc
->wState
& CBF_EDIT
)
1686 CBUpdateEdit( lphc
, index
);
1689 InvalidateRect(lphc
->self
, &lphc
->textRect
, TRUE
);
1692 return (LRESULT
)index
;
1695 /***********************************************************************
1698 static void COMBO_LButtonDown( LPHEADCOMBO lphc
, LPARAM lParam
)
1702 HWND hWnd
= lphc
->self
;
1704 pt
.x
= (short)LOWORD(lParam
);
1705 pt
.y
= (short)HIWORD(lParam
);
1706 bButton
= PtInRect(&lphc
->buttonRect
, pt
);
1708 if( (CB_GETTYPE(lphc
) == CBS_DROPDOWNLIST
) ||
1709 (bButton
&& (CB_GETTYPE(lphc
) == CBS_DROPDOWN
)) )
1711 lphc
->wState
|= CBF_BUTTONDOWN
;
1712 if( lphc
->wState
& CBF_DROPPED
)
1714 /* got a click to cancel selection */
1716 lphc
->wState
&= ~CBF_BUTTONDOWN
;
1717 CBRollUp( lphc
, TRUE
, FALSE
);
1718 if( !IsWindow( hWnd
) ) return;
1720 if( lphc
->wState
& CBF_CAPTURE
)
1722 lphc
->wState
&= ~CBF_CAPTURE
;
1728 /* drop down the listbox and start tracking */
1730 lphc
->wState
|= CBF_CAPTURE
;
1734 if( bButton
) CBRepaintButton( lphc
);
1738 /***********************************************************************
1741 * Release capture and stop tracking if needed.
1743 static void COMBO_LButtonUp( LPHEADCOMBO lphc
)
1745 if( lphc
->wState
& CBF_CAPTURE
)
1747 lphc
->wState
&= ~CBF_CAPTURE
;
1748 if( CB_GETTYPE(lphc
) == CBS_DROPDOWN
)
1750 INT index
= CBUpdateLBox( lphc
, TRUE
);
1751 /* Update edit only if item is in the list */
1754 lphc
->wState
|= CBF_NOLBSELECT
;
1755 CBUpdateEdit( lphc
, index
);
1756 lphc
->wState
&= ~CBF_NOLBSELECT
;
1760 SetCapture(lphc
->hWndLBox
);
1763 if( lphc
->wState
& CBF_BUTTONDOWN
)
1765 lphc
->wState
&= ~CBF_BUTTONDOWN
;
1766 CBRepaintButton( lphc
);
1770 /***********************************************************************
1773 * Two things to do - track combo button and release capture when
1774 * pointer goes into the listbox.
1776 static void COMBO_MouseMove( LPHEADCOMBO lphc
, WPARAM wParam
, LPARAM lParam
)
1781 pt
.x
= (short)LOWORD(lParam
);
1782 pt
.y
= (short)HIWORD(lParam
);
1784 if( lphc
->wState
& CBF_BUTTONDOWN
)
1788 bButton
= PtInRect(&lphc
->buttonRect
, pt
);
1792 lphc
->wState
&= ~CBF_BUTTONDOWN
;
1793 CBRepaintButton( lphc
);
1797 GetClientRect( lphc
->hWndLBox
, &lbRect
);
1798 MapWindowPoints( lphc
->self
, lphc
->hWndLBox
, &pt
, 1 );
1799 if( PtInRect(&lbRect
, pt
) )
1801 lphc
->wState
&= ~CBF_CAPTURE
;
1803 if( CB_GETTYPE(lphc
) == CBS_DROPDOWN
) CBUpdateLBox( lphc
, TRUE
);
1805 /* hand over pointer tracking */
1806 SendMessageW(lphc
->hWndLBox
, WM_LBUTTONDOWN
, wParam
, lParam
);
1810 static LRESULT
COMBO_GetComboBoxInfo(const HEADCOMBO
*lphc
, COMBOBOXINFO
*pcbi
)
1812 if (!pcbi
|| (pcbi
->cbSize
< sizeof(COMBOBOXINFO
)))
1815 pcbi
->rcItem
= lphc
->textRect
;
1816 pcbi
->rcButton
= lphc
->buttonRect
;
1817 pcbi
->stateButton
= 0;
1818 if (lphc
->wState
& CBF_BUTTONDOWN
)
1819 pcbi
->stateButton
|= STATE_SYSTEM_PRESSED
;
1820 if (IsRectEmpty(&lphc
->buttonRect
))
1821 pcbi
->stateButton
|= STATE_SYSTEM_INVISIBLE
;
1822 pcbi
->hwndCombo
= lphc
->self
;
1823 pcbi
->hwndItem
= lphc
->hWndEdit
;
1824 pcbi
->hwndList
= lphc
->hWndLBox
;
1828 static char *strdupA(LPCSTR str
)
1833 if(!str
) return NULL
;
1836 ret
= HeapAlloc(GetProcessHeap(), 0, len
+ 1);
1837 memcpy(ret
, str
, len
+ 1);
1841 /***********************************************************************
1842 * ComboWndProc_common
1844 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/shellcc/platform/commctls/comboboxes/comboboxes.asp
1846 static LRESULT
ComboWndProc_common( HWND hwnd
, UINT message
,
1847 WPARAM wParam
, LPARAM lParam
, BOOL unicode
)
1849 LPHEADCOMBO lphc
= (LPHEADCOMBO
)GetWindowLongPtrW( hwnd
, 0 );
1851 TRACE("[%p]: msg %s wp %08lx lp %08lx\n",
1852 hwnd
, SPY_GetMsgName(message
, hwnd
), wParam
, lParam
);
1854 if( lphc
|| message
== WM_NCCREATE
)
1858 /* System messages */
1862 LONG style
= unicode
? ((LPCREATESTRUCTW
)lParam
)->style
:
1863 ((LPCREATESTRUCTA
)lParam
)->style
;
1864 return COMBO_NCCreate(hwnd
, style
);
1867 COMBO_NCDestroy(lphc
);
1868 break;/* -> DefWindowProc */
1876 hwndParent
= ((LPCREATESTRUCTW
)lParam
)->hwndParent
;
1877 style
= ((LPCREATESTRUCTW
)lParam
)->style
;
1881 hwndParent
= ((LPCREATESTRUCTA
)lParam
)->hwndParent
;
1882 style
= ((LPCREATESTRUCTA
)lParam
)->style
;
1884 return COMBO_Create(hwnd
, lphc
, hwndParent
, style
, unicode
);
1887 case WM_PRINTCLIENT
:
1890 /* wParam may contain a valid HDC! */
1891 return COMBO_Paint(lphc
, (HDC
)wParam
);
1894 /* do all painting in WM_PAINT like Windows does */
1899 LRESULT result
= DLGC_WANTARROWS
| DLGC_WANTCHARS
;
1900 if (lParam
&& (((LPMSG
)lParam
)->message
== WM_KEYDOWN
))
1902 int vk
= (int)((LPMSG
)lParam
)->wParam
;
1904 if ((vk
== VK_RETURN
|| vk
== VK_ESCAPE
) && (lphc
->wState
& CBF_DROPPED
))
1905 result
|= DLGC_WANTMESSAGE
;
1909 case WM_WINDOWPOSCHANGING
:
1910 return COMBO_WindowPosChanging(hwnd
, lphc
, (LPWINDOWPOS
)lParam
);
1911 case WM_WINDOWPOSCHANGED
:
1912 /* SetWindowPos can be called on a Combobox to resize its Listbox.
1913 * In that case, the Combobox itself will not be resized, so we won't
1914 * get a WM_SIZE. Since we still want to update the Listbox, we have to
1917 /* we should not force repainting on WM_WINDOWPOSCHANGED, it breaks
1918 * Z-order based painting.
1922 if( lphc
->hWndLBox
&&
1923 !(lphc
->wState
& CBF_NORESIZE
) ) COMBO_Size( lphc
, message
== WM_SIZE
);
1926 COMBO_Font( lphc
, (HFONT
)wParam
, (BOOL
)lParam
);
1929 return (LRESULT
)lphc
->hFont
;
1931 if( lphc
->wState
& CBF_EDIT
)
1932 SetFocus( lphc
->hWndEdit
);
1934 COMBO_SetFocus( lphc
);
1938 HWND hwndFocus
= WIN_GetFullHandle( (HWND
)wParam
);
1940 (hwndFocus
!= lphc
->hWndEdit
&& hwndFocus
!= lphc
->hWndLBox
))
1941 COMBO_KillFocus( lphc
);
1945 return COMBO_Command( lphc
, wParam
, WIN_GetFullHandle( (HWND
)lParam
) );
1947 return unicode
? COMBO_GetTextW( lphc
, wParam
, (LPWSTR
)lParam
)
1948 : COMBO_GetTextA( lphc
, wParam
, (LPSTR
)lParam
);
1950 case WM_GETTEXTLENGTH
:
1952 if ((message
== WM_GETTEXTLENGTH
) && !ISWIN31
&& !(lphc
->wState
& CBF_EDIT
))
1954 int j
= SendMessageW(lphc
->hWndLBox
, LB_GETCURSEL
, 0, 0);
1955 if (j
== -1) return 0;
1956 return unicode
? SendMessageW(lphc
->hWndLBox
, LB_GETTEXTLEN
, j
, 0) :
1957 SendMessageA(lphc
->hWndLBox
, LB_GETTEXTLEN
, j
, 0);
1959 else if( lphc
->wState
& CBF_EDIT
)
1962 lphc
->wState
|= CBF_NOEDITNOTIFY
;
1963 ret
= unicode
? SendMessageW(lphc
->hWndEdit
, message
, wParam
, lParam
) :
1964 SendMessageA(lphc
->hWndEdit
, message
, wParam
, lParam
);
1965 lphc
->wState
&= ~CBF_NOEDITNOTIFY
;
1972 if( lphc
->wState
& CBF_EDIT
)
1974 return unicode
? SendMessageW(lphc
->hWndEdit
, message
, wParam
, lParam
) :
1975 SendMessageA(lphc
->hWndEdit
, message
, wParam
, lParam
);
1981 case WM_COMPAREITEM
:
1982 case WM_MEASUREITEM
:
1983 return COMBO_ItemOp(lphc
, message
, lParam
);
1985 if( lphc
->wState
& CBF_EDIT
)
1986 EnableWindow( lphc
->hWndEdit
, (BOOL
)wParam
);
1987 EnableWindow( lphc
->hWndLBox
, (BOOL
)wParam
);
1989 /* Force the control to repaint when the enabled state changes. */
1990 InvalidateRect(lphc
->self
, NULL
, TRUE
);
1994 lphc
->wState
&= ~CBF_NOREDRAW
;
1996 lphc
->wState
|= CBF_NOREDRAW
;
1998 if( lphc
->wState
& CBF_EDIT
)
1999 SendMessageW(lphc
->hWndEdit
, message
, wParam
, lParam
);
2000 SendMessageW(lphc
->hWndLBox
, message
, wParam
, lParam
);
2003 if( KEYDATA_ALT
& HIWORD(lParam
) )
2004 if( wParam
== VK_UP
|| wParam
== VK_DOWN
)
2005 COMBO_FlipListbox( lphc
, FALSE
, FALSE
);
2014 if ((wParam
== VK_RETURN
|| wParam
== VK_ESCAPE
) &&
2015 (lphc
->wState
& CBF_DROPPED
))
2017 CBRollUp( lphc
, wParam
== VK_RETURN
, FALSE
);
2020 else if ((wParam
== VK_F4
) && !(lphc
->wState
& CBF_EUI
))
2022 COMBO_FlipListbox( lphc
, FALSE
, FALSE
);
2026 if( lphc
->wState
& CBF_EDIT
)
2027 hwndTarget
= lphc
->hWndEdit
;
2029 hwndTarget
= lphc
->hWndLBox
;
2031 return unicode
? SendMessageW(hwndTarget
, message
, wParam
, lParam
) :
2032 SendMessageA(hwndTarget
, message
, wParam
, lParam
);
2034 case WM_LBUTTONDOWN
:
2035 if( !(lphc
->wState
& CBF_FOCUSED
) ) SetFocus( lphc
->self
);
2036 if( lphc
->wState
& CBF_FOCUSED
) COMBO_LButtonDown( lphc
, lParam
);
2039 COMBO_LButtonUp( lphc
);
2042 if( lphc
->wState
& CBF_CAPTURE
)
2043 COMBO_MouseMove( lphc
, wParam
, lParam
);
2047 if (wParam
& (MK_SHIFT
| MK_CONTROL
))
2048 return unicode
? DefWindowProcW(hwnd
, message
, wParam
, lParam
) :
2049 DefWindowProcA(hwnd
, message
, wParam
, lParam
);
2051 if (GET_WHEEL_DELTA_WPARAM(wParam
) > 0) return SendMessageW(hwnd
, WM_KEYDOWN
, VK_UP
, 0);
2052 if (GET_WHEEL_DELTA_WPARAM(wParam
) < 0) return SendMessageW(hwnd
, WM_KEYDOWN
, VK_DOWN
, 0);
2055 /* Combo messages */
2057 case CB_ADDSTRING16
:
2058 if( CB_HASSTRINGS(lphc
) ) lParam
= (LPARAM
)MapSL(lParam
);
2063 if( lphc
->dwStyle
& CBS_LOWERCASE
)
2064 CharLowerW((LPWSTR
)lParam
);
2065 else if( lphc
->dwStyle
& CBS_UPPERCASE
)
2066 CharUpperW((LPWSTR
)lParam
);
2067 return SendMessageW(lphc
->hWndLBox
, LB_ADDSTRING
, 0, lParam
);
2069 else /* unlike the unicode version, the ansi version does not overwrite
2070 the string if converting case */
2072 char *string
= NULL
;
2074 if( lphc
->dwStyle
& CBS_LOWERCASE
)
2076 string
= strdupA((LPSTR
)lParam
);
2080 else if( lphc
->dwStyle
& CBS_UPPERCASE
)
2082 string
= strdupA((LPSTR
)lParam
);
2086 ret
= SendMessageA(lphc
->hWndLBox
, LB_ADDSTRING
, 0, string
? (LPARAM
)string
: lParam
);
2087 HeapFree(GetProcessHeap(), 0, string
);
2090 case CB_INSERTSTRING16
:
2091 wParam
= (INT
)(INT16
)wParam
;
2092 if( CB_HASSTRINGS(lphc
) ) lParam
= (LPARAM
)MapSL(lParam
);
2094 case CB_INSERTSTRING
:
2097 if( lphc
->dwStyle
& CBS_LOWERCASE
)
2098 CharLowerW((LPWSTR
)lParam
);
2099 else if( lphc
->dwStyle
& CBS_UPPERCASE
)
2100 CharUpperW((LPWSTR
)lParam
);
2101 return SendMessageW(lphc
->hWndLBox
, LB_INSERTSTRING
, wParam
, lParam
);
2105 if( lphc
->dwStyle
& CBS_LOWERCASE
)
2106 CharLowerA((LPSTR
)lParam
);
2107 else if( lphc
->dwStyle
& CBS_UPPERCASE
)
2108 CharUpperA((LPSTR
)lParam
);
2110 return SendMessageA(lphc
->hWndLBox
, LB_INSERTSTRING
, wParam
, lParam
);
2112 case CB_DELETESTRING16
:
2113 case CB_DELETESTRING
:
2114 return unicode
? SendMessageW(lphc
->hWndLBox
, LB_DELETESTRING
, wParam
, 0) :
2115 SendMessageA(lphc
->hWndLBox
, LB_DELETESTRING
, wParam
, 0);
2116 case CB_SELECTSTRING16
:
2117 wParam
= (INT
)(INT16
)wParam
;
2118 if( CB_HASSTRINGS(lphc
) ) lParam
= (LPARAM
)MapSL(lParam
);
2120 case CB_SELECTSTRING
:
2121 return COMBO_SelectString(lphc
, (INT
)wParam
, lParam
, unicode
);
2122 case CB_FINDSTRING16
:
2123 wParam
= (INT
)(INT16
)wParam
;
2124 if( CB_HASSTRINGS(lphc
) ) lParam
= (LPARAM
)MapSL(lParam
);
2127 return unicode
? SendMessageW(lphc
->hWndLBox
, LB_FINDSTRING
, wParam
, lParam
) :
2128 SendMessageA(lphc
->hWndLBox
, LB_FINDSTRING
, wParam
, lParam
);
2129 case CB_FINDSTRINGEXACT16
:
2130 wParam
= (INT
)(INT16
)wParam
;
2131 if( CB_HASSTRINGS(lphc
) ) lParam
= (LPARAM
)MapSL(lParam
);
2133 case CB_FINDSTRINGEXACT
:
2134 return unicode
? SendMessageW(lphc
->hWndLBox
, LB_FINDSTRINGEXACT
, wParam
, lParam
) :
2135 SendMessageA(lphc
->hWndLBox
, LB_FINDSTRINGEXACT
, wParam
, lParam
);
2136 case CB_SETITEMHEIGHT16
:
2137 wParam
= (INT
)(INT16
)wParam
; /* signed integer */
2139 case CB_SETITEMHEIGHT
:
2140 return COMBO_SetItemHeight( lphc
, (INT
)wParam
, (INT
)lParam
);
2141 case CB_GETITEMHEIGHT16
:
2142 wParam
= (INT
)(INT16
)wParam
;
2144 case CB_GETITEMHEIGHT
:
2145 if( (INT
)wParam
>= 0 ) /* listbox item */
2146 return SendMessageW(lphc
->hWndLBox
, LB_GETITEMHEIGHT
, wParam
, 0);
2147 return CBGetTextAreaHeight(hwnd
, lphc
);
2148 case CB_RESETCONTENT16
:
2149 case CB_RESETCONTENT
:
2150 SendMessageW(lphc
->hWndLBox
, LB_RESETCONTENT
, 0, 0);
2151 if( (lphc
->wState
& CBF_EDIT
) && CB_HASSTRINGS(lphc
) )
2153 static const WCHAR empty_stringW
[] = { 0 };
2154 SendMessageW(lphc
->hWndEdit
, WM_SETTEXT
, 0, (LPARAM
)empty_stringW
);
2157 InvalidateRect(lphc
->self
, NULL
, TRUE
);
2159 case CB_INITSTORAGE
:
2160 return SendMessageW(lphc
->hWndLBox
, LB_INITSTORAGE
, wParam
, lParam
);
2161 case CB_GETHORIZONTALEXTENT
:
2162 return SendMessageW(lphc
->hWndLBox
, LB_GETHORIZONTALEXTENT
, 0, 0);
2163 case CB_SETHORIZONTALEXTENT
:
2164 return SendMessageW(lphc
->hWndLBox
, LB_SETHORIZONTALEXTENT
, wParam
, 0);
2165 case CB_GETTOPINDEX
:
2166 return SendMessageW(lphc
->hWndLBox
, LB_GETTOPINDEX
, 0, 0);
2168 return SendMessageW(lphc
->hWndLBox
, LB_GETLOCALE
, 0, 0);
2170 return SendMessageW(lphc
->hWndLBox
, LB_SETLOCALE
, wParam
, 0);
2171 case CB_GETDROPPEDWIDTH
:
2172 if( lphc
->droppedWidth
)
2173 return lphc
->droppedWidth
;
2174 return lphc
->droppedRect
.right
- lphc
->droppedRect
.left
;
2175 case CB_SETDROPPEDWIDTH
:
2176 if( (CB_GETTYPE(lphc
) != CBS_SIMPLE
) &&
2177 (INT
)wParam
< 32768 ) lphc
->droppedWidth
= (INT
)wParam
;
2179 case CB_GETDROPPEDCONTROLRECT16
:
2180 lParam
= (LPARAM
)MapSL(lParam
);
2184 RECT16
*r16
= (RECT16
*)lParam
;
2185 CBGetDroppedControlRect( lphc
, &r
);
2188 r16
->right
= r
.right
;
2189 r16
->bottom
= r
.bottom
;
2192 case CB_GETDROPPEDCONTROLRECT
:
2193 if( lParam
) CBGetDroppedControlRect(lphc
, (LPRECT
)lParam
);
2195 case CB_GETDROPPEDSTATE16
:
2196 case CB_GETDROPPEDSTATE
:
2197 return (lphc
->wState
& CBF_DROPPED
) ? TRUE
: FALSE
;
2199 return SendMessageA(lphc
->hWndLBox
, LB_DIR16
, wParam
, lParam
);
2201 return unicode
? SendMessageW(lphc
->hWndLBox
, LB_DIR
, wParam
, lParam
) :
2202 SendMessageA(lphc
->hWndLBox
, LB_DIR
, wParam
, lParam
);
2204 case CB_SHOWDROPDOWN16
:
2205 case CB_SHOWDROPDOWN
:
2206 if( CB_GETTYPE(lphc
) != CBS_SIMPLE
)
2210 if( !(lphc
->wState
& CBF_DROPPED
) )
2214 if( lphc
->wState
& CBF_DROPPED
)
2215 CBRollUp( lphc
, FALSE
, TRUE
);
2220 return SendMessageW(lphc
->hWndLBox
, LB_GETCOUNT
, 0, 0);
2221 case CB_GETCURSEL16
:
2223 return SendMessageW(lphc
->hWndLBox
, LB_GETCURSEL
, 0, 0);
2224 case CB_SETCURSEL16
:
2225 wParam
= (INT
)(INT16
)wParam
;
2228 lParam
= SendMessageW(lphc
->hWndLBox
, LB_SETCURSEL
, wParam
, 0);
2230 SendMessageW(lphc
->hWndLBox
, LB_SETTOPINDEX
, wParam
, 0);
2232 /* no LBN_SELCHANGE in this case, update manually */
2233 if( lphc
->wState
& CBF_EDIT
)
2234 CBUpdateEdit( lphc
, (INT
)wParam
);
2236 InvalidateRect(lphc
->self
, &lphc
->textRect
, TRUE
);
2237 lphc
->wState
&= ~CBF_SELCHANGE
;
2239 case CB_GETLBTEXT16
:
2240 wParam
= (INT
)(INT16
)wParam
;
2241 lParam
= (LPARAM
)MapSL(lParam
);
2244 return unicode
? SendMessageW(lphc
->hWndLBox
, LB_GETTEXT
, wParam
, lParam
) :
2245 SendMessageA(lphc
->hWndLBox
, LB_GETTEXT
, wParam
, lParam
);
2246 case CB_GETLBTEXTLEN16
:
2247 wParam
= (INT
)(INT16
)wParam
;
2249 case CB_GETLBTEXTLEN
:
2250 return unicode
? SendMessageW(lphc
->hWndLBox
, LB_GETTEXTLEN
, wParam
, 0) :
2251 SendMessageA(lphc
->hWndLBox
, LB_GETTEXTLEN
, wParam
, 0);
2252 case CB_GETITEMDATA16
:
2253 wParam
= (INT
)(INT16
)wParam
;
2255 case CB_GETITEMDATA
:
2256 return SendMessageW(lphc
->hWndLBox
, LB_GETITEMDATA
, wParam
, 0);
2257 case CB_SETITEMDATA16
:
2258 wParam
= (INT
)(INT16
)wParam
;
2260 case CB_SETITEMDATA
:
2261 return SendMessageW(lphc
->hWndLBox
, LB_SETITEMDATA
, wParam
, lParam
);
2262 case CB_GETEDITSEL16
:
2263 wParam
= lParam
= 0; /* just in case */
2266 /* Edit checks passed parameters itself */
2267 if( lphc
->wState
& CBF_EDIT
)
2268 return SendMessageW(lphc
->hWndEdit
, EM_GETSEL
, wParam
, lParam
);
2270 case CB_SETEDITSEL16
:
2272 if( lphc
->wState
& CBF_EDIT
)
2273 return SendMessageW(lphc
->hWndEdit
, EM_SETSEL
,
2274 (INT
)(INT16
)LOWORD(lParam
), (INT
)(INT16
)HIWORD(lParam
) );
2276 case CB_SETEXTENDEDUI16
:
2277 case CB_SETEXTENDEDUI
:
2278 if( CB_GETTYPE(lphc
) == CBS_SIMPLE
)
2281 lphc
->wState
|= CBF_EUI
;
2282 else lphc
->wState
&= ~CBF_EUI
;
2284 case CB_GETEXTENDEDUI16
:
2285 case CB_GETEXTENDEDUI
:
2286 return (lphc
->wState
& CBF_EUI
) ? TRUE
: FALSE
;
2287 case CB_GETCOMBOBOXINFO
:
2288 return COMBO_GetComboBoxInfo(lphc
, (COMBOBOXINFO
*)lParam
);
2290 if( lphc
->wState
& CBF_EDIT
)
2291 return SendMessageW(lphc
->hWndEdit
, EM_LIMITTEXT
, wParam
, lParam
);
2293 if (message
>= WM_USER
)
2294 WARN("unknown msg WM_USER+%04x wp=%04lx lp=%08lx\n",
2295 message
- WM_USER
, wParam
, lParam
);
2298 return unicode
? DefWindowProcW(hwnd
, message
, wParam
, lParam
) :
2299 DefWindowProcA(hwnd
, message
, wParam
, lParam
);
2302 /***********************************************************************
2305 * This is just a wrapper for the real ComboWndProc which locks/unlocks
2308 static LRESULT WINAPI
ComboWndProcA( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2310 if (!IsWindow(hwnd
)) return 0;
2311 return ComboWndProc_common( hwnd
, message
, wParam
, lParam
, FALSE
);
2314 /***********************************************************************
2317 static LRESULT WINAPI
ComboWndProcW( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2319 if (!IsWindow(hwnd
)) return 0;
2320 return ComboWndProc_common( hwnd
, message
, wParam
, lParam
, TRUE
);
2323 /*************************************************************************
2324 * GetComboBoxInfo (USER32.@)
2326 BOOL WINAPI
GetComboBoxInfo(HWND hwndCombo
, /* [in] handle to combo box */
2327 PCOMBOBOXINFO pcbi
/* [in/out] combo box information */)
2329 TRACE("(%p, %p)\n", hwndCombo
, pcbi
);
2330 return SendMessageW(hwndCombo
, CB_GETCOMBOBOXINFO
, 0, (LPARAM
)pcbi
);