4 * Copyright 1997 Alex Korobka
6 * FIXME: roll up in Netscape 3.01.
15 #include "wine/winuser16.h"
21 #include "debugtools.h"
23 DEFAULT_DEBUG_CHANNEL(combo
);
25 /* bits in the dwKeyData */
26 #define KEYDATA_ALT 0x2000
27 #define KEYDATA_PREVSTATE 0x4000
30 * Additional combo box definitions
33 #define CB_GETPTR( wnd ) (*(LPHEADCOMBO*)((wnd)->wExtra))
34 #define CB_NOTIFY( lphc, code ) \
35 (SendMessageW((lphc)->owner, WM_COMMAND, \
36 MAKEWPARAM((lphc)->self->wIDmenu, (code)), (lphc)->self->hwndSelf))
37 #define CB_GETEDITTEXTLENGTH( lphc ) \
38 (SendMessageW((lphc)->hWndEdit, WM_GETTEXTLENGTH, 0, 0 ))
40 #define ISWIN31 (LOWORD(GetVersion()) == 0x0a03)
45 static HBITMAP hComboBmp
= 0;
46 static UINT CBitHeight
, CBitWidth
;
49 * Look and feel dependant "constants"
52 #define COMBO_YBORDERGAP 5
53 #define COMBO_XBORDERSIZE() ( (TWEAK_WineLook == WIN31_LOOK) ? 0 : 2 )
54 #define COMBO_YBORDERSIZE() ( (TWEAK_WineLook == WIN31_LOOK) ? 0 : 2 )
55 #define COMBO_EDITBUTTONSPACE() ( (TWEAK_WineLook == WIN31_LOOK) ? 8 : 0 )
56 #define EDIT_CONTROL_PADDING() ( (TWEAK_WineLook == WIN31_LOOK) ? 0 : 1 )
58 static LRESULT WINAPI
ComboWndProcA( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
);
59 static LRESULT WINAPI
ComboWndProcW( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
);
61 /*********************************************************************
62 * combo class descriptor
64 const struct builtin_class_descr COMBO_builtin_class
=
66 "ComboBox", /* name */
67 CS_GLOBALCLASS
| CS_PARENTDC
| CS_DBLCLKS
, /* style */
68 ComboWndProcA
, /* procA */
69 ComboWndProcW
, /* procW */
70 sizeof(HEADCOMBO
*), /* extra */
71 IDC_ARROWA
, /* cursor */
76 /***********************************************************************
79 * Load combo button bitmap.
81 static BOOL
COMBO_Init()
85 if( hComboBmp
) return TRUE
;
86 if( (hDC
= CreateCompatibleDC(0)) )
89 if( (hComboBmp
= LoadBitmapW(0, MAKEINTRESOURCEW(OBM_COMBO
))) )
95 GetObjectW( hComboBmp
, sizeof(bm
), &bm
);
96 CBitHeight
= bm
.bmHeight
;
97 CBitWidth
= bm
.bmWidth
;
99 TRACE("combo bitmap [%i,%i]\n", CBitWidth
, CBitHeight
);
101 hPrevB
= SelectObject( hDC
, hComboBmp
);
102 SetRect( &r
, 0, 0, CBitWidth
, CBitHeight
);
103 InvertRect( hDC
, &r
);
104 SelectObject( hDC
, hPrevB
);
113 /***********************************************************************
116 static LRESULT
COMBO_NCCreate(WND
* wnd
, LONG style
)
120 if ( wnd
&& COMBO_Init() &&
121 (lphc
= HeapAlloc(GetProcessHeap(), 0, sizeof(HEADCOMBO
))) )
123 memset( lphc
, 0, sizeof(HEADCOMBO
) );
124 *(LPHEADCOMBO
*)wnd
->wExtra
= lphc
;
126 /* some braindead apps do try to use scrollbar/border flags */
128 lphc
->dwStyle
= style
& ~(WS_BORDER
| WS_HSCROLL
| WS_VSCROLL
);
129 wnd
->dwStyle
&= ~(WS_BORDER
| WS_HSCROLL
| WS_VSCROLL
);
132 * We also have to remove the client edge style to make sure
133 * we don't end-up with a non client area.
135 wnd
->dwExStyle
&= ~(WS_EX_CLIENTEDGE
);
137 if( !(style
& (CBS_OWNERDRAWFIXED
| CBS_OWNERDRAWVARIABLE
)) )
138 lphc
->dwStyle
|= CBS_HASSTRINGS
;
139 if( !(wnd
->dwExStyle
& WS_EX_NOPARENTNOTIFY
) )
140 lphc
->wState
|= CBF_NOTIFY
;
142 TRACE("[0x%08x], style = %08x\n",
143 (UINT
)lphc
, lphc
->dwStyle
);
145 return (LRESULT
)(UINT
)wnd
->hwndSelf
;
147 return (LRESULT
)FALSE
;
150 /***********************************************************************
153 static LRESULT
COMBO_NCDestroy( LPHEADCOMBO lphc
)
158 WND
* wnd
= lphc
->self
;
160 TRACE("[%04x]: freeing storage\n", CB_HWND(lphc
));
162 if( (CB_GETTYPE(lphc
) != CBS_SIMPLE
) && lphc
->hWndLBox
)
163 DestroyWindow( lphc
->hWndLBox
);
165 HeapFree( GetProcessHeap(), 0, lphc
);
171 /***********************************************************************
172 * CBGetTextAreaHeight
174 * This method will calculate the height of the text area of the
176 * The height of the text area is set in two ways.
177 * It can be set explicitely through a combobox message or through a
178 * WM_MEASUREITEM callback.
179 * If this is not the case, the height is set to 13 dialog units.
180 * This height was determined through experimentation.
182 static INT
CBGetTextAreaHeight(
188 if( lphc
->editHeight
) /* explicitly set height */
190 iTextItemHeight
= lphc
->editHeight
;
195 HDC hDC
= GetDC(hwnd
);
200 hPrevFont
= SelectObject( hDC
, lphc
->hFont
);
202 GetTextMetricsW(hDC
, &tm
);
204 baseUnitY
= tm
.tmHeight
;
207 SelectObject( hDC
, hPrevFont
);
209 ReleaseDC(hwnd
, hDC
);
211 iTextItemHeight
= ((13 * baseUnitY
) / 8);
214 * This "formula" calculates the height of the complete control.
215 * To calculate the height of the text area, we have to remove the
218 iTextItemHeight
-= 2*COMBO_YBORDERSIZE();
222 * Check the ownerdraw case if we haven't asked the parent the size
225 if ( CB_OWNERDRAWN(lphc
) &&
226 (lphc
->wState
& CBF_MEASUREITEM
) )
228 MEASUREITEMSTRUCT measureItem
;
230 INT originalItemHeight
= iTextItemHeight
;
233 * We use the client rect for the width of the item.
235 GetClientRect(hwnd
, &clientRect
);
237 lphc
->wState
&= ~CBF_MEASUREITEM
;
240 * Send a first one to measure the size of the text area
242 measureItem
.CtlType
= ODT_COMBOBOX
;
243 measureItem
.CtlID
= lphc
->self
->wIDmenu
;
244 measureItem
.itemID
= -1;
245 measureItem
.itemWidth
= clientRect
.right
;
246 measureItem
.itemHeight
= iTextItemHeight
- 6; /* ownerdrawn cb is taller */
247 measureItem
.itemData
= 0;
248 SendMessageW(lphc
->owner
, WM_MEASUREITEM
,
249 (WPARAM
)measureItem
.CtlID
, (LPARAM
)&measureItem
);
250 iTextItemHeight
= 6 + measureItem
.itemHeight
;
253 * Send a second one in the case of a fixed ownerdraw list to calculate the
254 * size of the list items. (we basically do this on behalf of the listbox)
256 if (lphc
->dwStyle
& CBS_OWNERDRAWFIXED
)
258 measureItem
.CtlType
= ODT_COMBOBOX
;
259 measureItem
.CtlID
= lphc
->self
->wIDmenu
;
260 measureItem
.itemID
= 0;
261 measureItem
.itemWidth
= clientRect
.right
;
262 measureItem
.itemHeight
= originalItemHeight
;
263 measureItem
.itemData
= 0;
264 SendMessageW(lphc
->owner
, WM_MEASUREITEM
,
265 (WPARAM
)measureItem
.CtlID
, (LPARAM
)&measureItem
);
266 lphc
->fixedOwnerDrawHeight
= measureItem
.itemHeight
;
270 * Keep the size for the next time
272 lphc
->editHeight
= iTextItemHeight
;
275 return iTextItemHeight
;
278 /***********************************************************************
281 * The dummy resize is used for listboxes that have a popup to trigger
282 * a re-arranging of the contents of the combobox and the recalculation
283 * of the size of the "real" control window.
285 static void CBForceDummyResize(
291 newComboHeight
= CBGetTextAreaHeight(CB_HWND(lphc
),lphc
) + 2*COMBO_YBORDERSIZE();
293 GetWindowRect(CB_HWND(lphc
), &windowRect
);
296 * We have to be careful, resizing a combobox also has the meaning that the
297 * dropped rect will be resized. In this case, we want to trigger a resize
298 * to recalculate layout but we don't want to change the dropped rectangle
299 * So, we pass the height of text area of control as the height.
300 * this will cancel-out in the processing of the WM_WINDOWPOSCHANGING
303 SetWindowPos( CB_HWND(lphc
),
306 windowRect
.right
- windowRect
.left
,
308 SWP_NOMOVE
| SWP_NOZORDER
| SWP_NOACTIVATE
);
311 /***********************************************************************
314 * Set up component coordinates given valid lphc->RectCombo.
316 static void CBCalcPlacement(
324 * Again, start with the client rectangle.
326 GetClientRect(hwnd
, lprEdit
);
331 InflateRect(lprEdit
, -COMBO_XBORDERSIZE(), -COMBO_YBORDERSIZE());
334 * Chop off the bottom part to fit with the height of the text area.
336 lprEdit
->bottom
= lprEdit
->top
+ CBGetTextAreaHeight(hwnd
, lphc
);
339 * The button starts the same vertical position as the text area.
341 CopyRect(lprButton
, lprEdit
);
344 * If the combobox is "simple" there is no button.
346 if( CB_GETTYPE(lphc
) == CBS_SIMPLE
)
347 lprButton
->left
= lprButton
->right
= lprButton
->bottom
= 0;
351 * Let's assume the combobox button is the same width as the
353 * size the button horizontally and cut-off the text area.
355 lprButton
->left
= lprButton
->right
- GetSystemMetrics(SM_CXVSCROLL
);
356 lprEdit
->right
= lprButton
->left
;
360 * In the case of a dropdown, there is an additional spacing between the
361 * text area and the button.
363 if( CB_GETTYPE(lphc
) == CBS_DROPDOWN
)
365 lprEdit
->right
-= COMBO_EDITBUTTONSPACE();
369 * If we have an edit control, we space it away from the borders slightly.
371 if (CB_GETTYPE(lphc
) != CBS_DROPDOWNLIST
)
373 InflateRect(lprEdit
, -EDIT_CONTROL_PADDING(), -EDIT_CONTROL_PADDING());
377 * Adjust the size of the listbox popup.
379 if( CB_GETTYPE(lphc
) == CBS_SIMPLE
)
382 * Use the client rectangle to initialize the listbox rectangle
384 GetClientRect(hwnd
, lprLB
);
387 * Then, chop-off the top part.
389 lprLB
->top
= lprEdit
->bottom
+ COMBO_YBORDERSIZE();
394 * Make sure the dropped width is as large as the combobox itself.
396 if (lphc
->droppedWidth
< (lprButton
->right
+ COMBO_XBORDERSIZE()))
398 lprLB
->right
= lprLB
->left
+ (lprButton
->right
+ COMBO_XBORDERSIZE());
401 * In the case of a dropdown, the popup listbox is offset to the right.
402 * so, we want to make sure it's flush with the right side of the
405 if( CB_GETTYPE(lphc
) == CBS_DROPDOWN
)
406 lprLB
->right
-= COMBO_EDITBUTTONSPACE();
409 lprLB
->right
= lprLB
->left
+ lphc
->droppedWidth
;
412 TRACE("\ttext\t= (%i,%i-%i,%i)\n",
413 lprEdit
->left
, lprEdit
->top
, lprEdit
->right
, lprEdit
->bottom
);
415 TRACE("\tbutton\t= (%i,%i-%i,%i)\n",
416 lprButton
->left
, lprButton
->top
, lprButton
->right
, lprButton
->bottom
);
418 TRACE("\tlbox\t= (%i,%i-%i,%i)\n",
419 lprLB
->left
, lprLB
->top
, lprLB
->right
, lprLB
->bottom
);
422 /***********************************************************************
423 * CBGetDroppedControlRect
425 static void CBGetDroppedControlRect( LPHEADCOMBO lphc
, LPRECT lpRect
)
427 /* In windows, CB_GETDROPPEDCONTROLRECT returns the upper left corner
428 of the combo box and the lower right corner of the listbox */
430 GetWindowRect(lphc
->self
->hwndSelf
, lpRect
);
432 lpRect
->right
= lpRect
->left
+ lphc
->droppedRect
.right
- lphc
->droppedRect
.left
;
433 lpRect
->bottom
= lpRect
->top
+ lphc
->droppedRect
.bottom
- lphc
->droppedRect
.top
;
437 /***********************************************************************
438 * COMBO_WindowPosChanging
440 static LRESULT
COMBO_WindowPosChanging(
443 WINDOWPOS
* posChanging
)
446 * We need to override the WM_WINDOWPOSCHANGING method to handle all
447 * the non-simple comboboxes. The problem is that those controls are
448 * always the same height. We have to make sure they are not resized
451 if ( ( CB_GETTYPE(lphc
) != CBS_SIMPLE
) &&
452 ((posChanging
->flags
& SWP_NOSIZE
) == 0) )
456 newComboHeight
= CBGetTextAreaHeight(hwnd
,lphc
) +
457 2*COMBO_YBORDERSIZE();
460 * Resizing a combobox has another side effect, it resizes the dropped
461 * rectangle as well. However, it does it only if the new height for the
462 * combobox is different from the height it should have. In other words,
463 * if the application resizing the combobox only had the intention to resize
464 * the actual control, for example, to do the layout of a dialog that is
465 * resized, the height of the dropdown is not changed.
467 if (posChanging
->cy
!= newComboHeight
)
469 lphc
->droppedRect
.bottom
= lphc
->droppedRect
.top
+ posChanging
->cy
- newComboHeight
;
471 posChanging
->cy
= newComboHeight
;
478 /***********************************************************************
481 static LRESULT
COMBO_Create( LPHEADCOMBO lphc
, WND
* wnd
, HWND hwndParent
, LONG style
)
483 static const WCHAR clbName
[] = {'C','o','m','b','o','L','B','o','x',0};
484 static const WCHAR editName
[] = {'E','d','i','t',0};
486 if( !CB_GETTYPE(lphc
) ) lphc
->dwStyle
|= CBS_SIMPLE
;
487 if( CB_GETTYPE(lphc
) != CBS_DROPDOWNLIST
) lphc
->wState
|= CBF_EDIT
;
490 lphc
->owner
= hwndParent
;
493 * The item height and dropped width are not set when the control
496 lphc
->droppedWidth
= lphc
->editHeight
= 0;
499 * The first time we go through, we want to measure the ownerdraw item
501 lphc
->wState
|= CBF_MEASUREITEM
;
503 /* M$ IE 3.01 actually creates (and rapidly destroys) an ownerless combobox */
505 if( lphc
->owner
|| !(style
& WS_VISIBLE
) )
511 * Initialize the dropped rect to the size of the client area of the
512 * control and then, force all the areas of the combobox to be
515 GetClientRect( wnd
->hwndSelf
, &lphc
->droppedRect
);
517 CBCalcPlacement(wnd
->hwndSelf
,
521 &lphc
->droppedRect
);
524 * Adjust the position of the popup listbox if it's necessary
526 if ( CB_GETTYPE(lphc
) != CBS_SIMPLE
)
528 lphc
->droppedRect
.top
= lphc
->textRect
.bottom
+ COMBO_YBORDERSIZE();
531 * If it's a dropdown, the listbox is offset
533 if( CB_GETTYPE(lphc
) == CBS_DROPDOWN
)
534 lphc
->droppedRect
.left
+= COMBO_EDITBUTTONSPACE();
536 ClientToScreen(wnd
->hwndSelf
, (LPPOINT
)&lphc
->droppedRect
);
537 ClientToScreen(wnd
->hwndSelf
, (LPPOINT
)&lphc
->droppedRect
.right
);
540 /* create listbox popup */
542 lbeStyle
= (LBS_NOTIFY
| WS_BORDER
| WS_CLIPSIBLINGS
| WS_CHILD
) |
543 (style
& (WS_VSCROLL
| CBS_OWNERDRAWFIXED
| CBS_OWNERDRAWVARIABLE
));
545 if( lphc
->dwStyle
& CBS_SORT
)
546 lbeStyle
|= LBS_SORT
;
547 if( lphc
->dwStyle
& CBS_HASSTRINGS
)
548 lbeStyle
|= LBS_HASSTRINGS
;
549 if( lphc
->dwStyle
& CBS_NOINTEGRALHEIGHT
)
550 lbeStyle
|= LBS_NOINTEGRALHEIGHT
;
551 if( lphc
->dwStyle
& CBS_DISABLENOSCROLL
)
552 lbeStyle
|= LBS_DISABLENOSCROLL
;
554 if( CB_GETTYPE(lphc
) == CBS_SIMPLE
) /* child listbox */
556 lbeStyle
|= WS_VISIBLE
;
559 * In win 95 look n feel, the listbox in the simple combobox has
560 * the WS_EXCLIENTEDGE style instead of the WS_BORDER style.
562 if (TWEAK_WineLook
> WIN31_LOOK
)
564 lbeStyle
&= ~WS_BORDER
;
565 lbeExStyle
|= WS_EX_CLIENTEDGE
;
569 lphc
->hWndLBox
= CreateWindowExW(lbeExStyle
,
573 lphc
->droppedRect
.left
,
574 lphc
->droppedRect
.top
,
575 lphc
->droppedRect
.right
- lphc
->droppedRect
.left
,
576 lphc
->droppedRect
.bottom
- lphc
->droppedRect
.top
,
577 lphc
->self
->hwndSelf
,
578 (HMENU
)ID_CB_LISTBOX
,
579 lphc
->self
->hInstance
,
585 lbeStyle
= WS_CHILD
| WS_VISIBLE
| ES_NOHIDESEL
| ES_LEFT
| ES_COMBO
;
588 * In Win95 look, the border fo the edit control is
589 * provided by the combobox
591 if (TWEAK_WineLook
== WIN31_LOOK
)
592 lbeStyle
|= WS_BORDER
;
594 if( lphc
->wState
& CBF_EDIT
)
596 if( lphc
->dwStyle
& CBS_OEMCONVERT
)
597 lbeStyle
|= ES_OEMCONVERT
;
598 if( lphc
->dwStyle
& CBS_AUTOHSCROLL
)
599 lbeStyle
|= ES_AUTOHSCROLL
;
600 if( lphc
->dwStyle
& CBS_LOWERCASE
)
601 lbeStyle
|= ES_LOWERCASE
;
602 else if( lphc
->dwStyle
& CBS_UPPERCASE
)
603 lbeStyle
|= ES_UPPERCASE
;
605 lphc
->hWndEdit
= CreateWindowExW(0,
609 lphc
->textRect
.left
, lphc
->textRect
.top
,
610 lphc
->textRect
.right
- lphc
->textRect
.left
,
611 lphc
->textRect
.bottom
- lphc
->textRect
.top
,
612 lphc
->self
->hwndSelf
,
614 lphc
->self
->hInstance
,
617 if( !lphc
->hWndEdit
)
623 if( CB_GETTYPE(lphc
) != CBS_SIMPLE
)
625 /* Now do the trick with parent */
626 SetParent(lphc
->hWndLBox
, HWND_DESKTOP
);
628 * If the combo is a dropdown, we must resize the control
629 * to fit only the text area and button. To do this,
630 * we send a dummy resize and the WM_WINDOWPOSCHANGING message
631 * will take care of setting the height for us.
633 CBForceDummyResize(lphc
);
636 TRACE("init done\n");
637 return wnd
->hwndSelf
;
639 ERR("edit control failure.\n");
640 } else ERR("listbox failure.\n");
641 } else ERR("no owner for visible combo.\n");
643 /* CreateWindow() will send WM_NCDESTROY to cleanup */
648 /***********************************************************************
651 * Paint combo button (normal, pressed, and disabled states).
653 static void CBPaintButton(
658 if( lphc
->wState
& CBF_NOREDRAW
)
661 if (TWEAK_WineLook
== WIN31_LOOK
)
667 COLORREF oldTextColor
, oldBkColor
;
670 hPrevBrush
= SelectObject(hdc
, GetSysColorBrush(COLOR_BTNFACE
));
673 * Draw the button background
678 rectButton
.right
-rectButton
.left
,
679 rectButton
.bottom
-rectButton
.top
,
682 if( (bBool
= lphc
->wState
& CBF_BUTTONDOWN
) )
684 DrawEdge( hdc
, &rectButton
, EDGE_SUNKEN
, BF_RECT
);
688 DrawEdge( hdc
, &rectButton
, EDGE_RAISED
, BF_RECT
);
692 * Remove the edge of the button from the rectangle
693 * and calculate the position of the bitmap.
695 InflateRect( &rectButton
, -2, -2);
697 x
= (rectButton
.left
+ rectButton
.right
- CBitWidth
) >> 1;
698 y
= (rectButton
.top
+ rectButton
.bottom
- CBitHeight
) >> 1;
701 hMemDC
= CreateCompatibleDC( hdc
);
702 SelectObject( hMemDC
, hComboBmp
);
703 oldTextColor
= SetTextColor( hdc
, GetSysColor(COLOR_BTNFACE
) );
704 oldBkColor
= SetBkColor( hdc
, CB_DISABLED(lphc
) ? RGB(128,128,128) :
706 BitBlt( hdc
, x
, y
, CBitWidth
, CBitHeight
, hMemDC
, 0, 0, SRCCOPY
);
707 SetBkColor( hdc
, oldBkColor
);
708 SetTextColor( hdc
, oldTextColor
);
710 SelectObject( hdc
, hPrevBrush
);
714 UINT buttonState
= DFCS_SCROLLCOMBOBOX
;
716 if (lphc
->wState
& CBF_BUTTONDOWN
)
718 buttonState
|= DFCS_PUSHED
;
721 if (CB_DISABLED(lphc
))
723 buttonState
|= DFCS_INACTIVE
;
726 DrawFrameControl(hdc
,
733 /***********************************************************************
736 * Paint CBS_DROPDOWNLIST text field / update edit control contents.
738 static void CBPaintText(
746 if( lphc
->wState
& CBF_NOREDRAW
) return;
748 /* follow Windows combobox that sends a bunch of text
749 * inquiries to its listbox while processing WM_PAINT. */
751 if( (id
= SendMessageW(lphc
->hWndLBox
, LB_GETCURSEL
, 0, 0) ) != LB_ERR
)
753 size
= SendMessageW(lphc
->hWndLBox
, LB_GETTEXTLEN
, id
, 0);
754 if( (pText
= HeapAlloc( GetProcessHeap(), 0, (size
+ 1) * sizeof(WCHAR
))) )
756 SendMessageW(lphc
->hWndLBox
, LB_GETTEXT
, (WPARAM
)id
, (LPARAM
)pText
);
757 pText
[size
] = '\0'; /* just in case */
761 if( !CB_OWNERDRAWN(lphc
) )
764 if( lphc
->wState
& CBF_EDIT
)
766 static const WCHAR empty_stringW
[] = { 0 };
767 if( CB_HASSTRINGS(lphc
) ) SetWindowTextW( lphc
->hWndEdit
, pText
? pText
: empty_stringW
);
768 if( lphc
->wState
& CBF_FOCUSED
)
769 SendMessageW(lphc
->hWndEdit
, EM_SETSEL
, 0, (LPARAM
)(-1));
771 else /* paint text field ourselves */
773 UINT itemState
= ODS_COMBOBOXEDIT
;
774 HFONT hPrevFont
= (lphc
->hFont
) ? SelectObject(hdc
, lphc
->hFont
) : 0;
777 * Give ourselves some space.
779 InflateRect( &rectEdit
, -1, -1 );
781 if( CB_OWNERDRAWN(lphc
) )
786 /* setup state for DRAWITEM message. Owner will highlight */
787 if ( (lphc
->wState
& CBF_FOCUSED
) &&
788 !(lphc
->wState
& CBF_DROPPED
) )
789 itemState
|= ODS_SELECTED
| ODS_FOCUS
;
792 * Save the current clip region.
793 * To retrieve the clip region, we need to create one "dummy"
796 clipRegion
= CreateRectRgnIndirect(&rectEdit
);
798 if (GetClipRgn(hdc
, clipRegion
)!=1)
800 DeleteObject(clipRegion
);
801 clipRegion
=(HRGN
)NULL
;
804 if ( lphc
->self
->dwStyle
& WS_DISABLED
)
805 itemState
|= ODS_DISABLED
;
807 dis
.CtlType
= ODT_COMBOBOX
;
808 dis
.CtlID
= lphc
->self
->wIDmenu
;
809 dis
.hwndItem
= lphc
->self
->hwndSelf
;
810 dis
.itemAction
= ODA_DRAWENTIRE
;
812 dis
.itemState
= itemState
;
814 dis
.rcItem
= rectEdit
;
815 dis
.itemData
= SendMessageW(lphc
->hWndLBox
, LB_GETITEMDATA
,
819 * Clip the DC and have the parent draw the item.
821 IntersectClipRect(hdc
,
822 rectEdit
.left
, rectEdit
.top
,
823 rectEdit
.right
, rectEdit
.bottom
);
825 SendMessageW(lphc
->owner
, WM_DRAWITEM
,
826 lphc
->self
->wIDmenu
, (LPARAM
)&dis
);
829 * Reset the clipping region.
831 SelectClipRgn(hdc
, clipRegion
);
835 static const WCHAR empty_stringW
[] = { 0 };
837 if ( (lphc
->wState
& CBF_FOCUSED
) &&
838 !(lphc
->wState
& CBF_DROPPED
) ) {
841 FillRect( hdc
, &rectEdit
, GetSysColorBrush(COLOR_HIGHLIGHT
) );
842 SetBkColor( hdc
, GetSysColor( COLOR_HIGHLIGHT
) );
843 SetTextColor( hdc
, GetSysColor( COLOR_HIGHLIGHTTEXT
) );
849 ETO_OPAQUE
| ETO_CLIPPED
,
851 pText
? pText
: empty_stringW
, size
, NULL
);
853 if(lphc
->wState
& CBF_FOCUSED
&& !(lphc
->wState
& CBF_DROPPED
))
854 DrawFocusRect( hdc
, &rectEdit
);
858 SelectObject(hdc
, hPrevFont
);
861 HeapFree( GetProcessHeap(), 0, pText
);
864 /***********************************************************************
867 static void CBPaintBorder(
874 if (CB_GETTYPE(lphc
) != CBS_SIMPLE
)
876 GetClientRect(hwnd
, &clientRect
);
880 CopyRect(&clientRect
, &lphc
->textRect
);
882 InflateRect(&clientRect
, EDIT_CONTROL_PADDING(), EDIT_CONTROL_PADDING());
883 InflateRect(&clientRect
, COMBO_XBORDERSIZE(), COMBO_YBORDERSIZE());
886 DrawEdge(hdc
, &clientRect
, EDGE_SUNKEN
, BF_RECT
);
889 /***********************************************************************
890 * COMBO_PrepareColors
892 * This method will sent the appropriate WM_CTLCOLOR message to
893 * prepare and setup the colors for the combo's DC.
895 * It also returns the brush to use for the background.
897 static HBRUSH
COMBO_PrepareColors(
904 * Get the background brush for this control.
906 if (CB_DISABLED(lphc
))
908 hBkgBrush
= SendMessageW(lphc
->owner
, WM_CTLCOLORSTATIC
,
909 hDC
, lphc
->self
->hwndSelf
);
912 * We have to change the text color since WM_CTLCOLORSTATIC will
913 * set it to the "enabled" color. This is the same behavior as the
916 SetTextColor(hDC
, GetSysColor(COLOR_GRAYTEXT
));
920 if (lphc
->wState
& CBF_EDIT
)
922 hBkgBrush
= SendMessageW(lphc
->owner
, WM_CTLCOLOREDIT
,
923 hDC
, lphc
->self
->hwndSelf
);
927 hBkgBrush
= SendMessageW(lphc
->owner
, WM_CTLCOLORLISTBOX
,
928 hDC
, lphc
->self
->hwndSelf
);
936 hBkgBrush
= GetSysColorBrush(COLOR_WINDOW
);
941 /***********************************************************************
942 * COMBO_EraseBackground
944 static LRESULT
COMBO_EraseBackground(
952 if(lphc
->wState
& CBF_EDIT
)
955 hDC
= (hParamDC
) ? hParamDC
958 * Retrieve the background brush
960 hBkgBrush
= COMBO_PrepareColors(lphc
, hDC
);
962 FillRect(hDC
, &lphc
->textRect
, hBkgBrush
);
965 ReleaseDC(hwnd
, hDC
);
970 /***********************************************************************
973 static LRESULT
COMBO_Paint(LPHEADCOMBO lphc
, HDC hParamDC
)
978 hDC
= (hParamDC
) ? hParamDC
979 : BeginPaint( lphc
->self
->hwndSelf
, &ps
);
982 if( hDC
&& !(lphc
->wState
& CBF_NOREDRAW
) )
984 HBRUSH hPrevBrush
, hBkgBrush
;
987 * Retrieve the background brush and select it in the
990 hBkgBrush
= COMBO_PrepareColors(lphc
, hDC
);
992 hPrevBrush
= SelectObject( hDC
, hBkgBrush
);
995 * In non 3.1 look, there is a sunken border on the combobox
997 if (TWEAK_WineLook
!= WIN31_LOOK
)
999 CBPaintBorder(CB_HWND(lphc
), lphc
, hDC
);
1002 if( !IsRectEmpty(&lphc
->buttonRect
) )
1004 CBPaintButton(lphc
, hDC
, lphc
->buttonRect
);
1007 if( !(lphc
->wState
& CBF_EDIT
) )
1010 * The text area has a border only in Win 3.1 look.
1012 if (TWEAK_WineLook
== WIN31_LOOK
)
1014 HPEN hPrevPen
= SelectObject( hDC
, GetSysColorPen(COLOR_WINDOWFRAME
) );
1017 lphc
->textRect
.left
, lphc
->textRect
.top
,
1018 lphc
->textRect
.right
- 1, lphc
->textRect
.bottom
- 1);
1020 SelectObject( hDC
, hPrevPen
);
1023 CBPaintText( lphc
, hDC
, lphc
->textRect
);
1027 SelectObject( hDC
, hPrevBrush
);
1031 EndPaint(lphc
->self
->hwndSelf
, &ps
);
1036 /***********************************************************************
1039 * Select listbox entry according to the contents of the edit control.
1041 static INT
CBUpdateLBox( LPHEADCOMBO lphc
, BOOL bSelect
)
1044 LPWSTR pText
= NULL
;
1047 length
= CB_GETEDITTEXTLENGTH( lphc
);
1050 pText
= HeapAlloc( GetProcessHeap(), 0, (length
+ 1) * sizeof(WCHAR
));
1052 TRACE("\t edit text length %i\n", length
);
1056 if( length
) GetWindowTextW( lphc
->hWndEdit
, pText
, length
+ 1);
1057 else pText
[0] = '\0';
1058 idx
= SendMessageW(lphc
->hWndLBox
, LB_FINDSTRING
,
1059 (WPARAM
)(-1), (LPARAM
)pText
);
1060 HeapFree( GetProcessHeap(), 0, pText
);
1063 SendMessageW(lphc
->hWndLBox
, LB_SETCURSEL
, (WPARAM
)(bSelect
? idx
: -1), 0);
1065 /* probably superfluous but Windows sends this too */
1066 SendMessageW(lphc
->hWndLBox
, LB_SETCARETINDEX
, (WPARAM
)(idx
< 0 ? 0 : idx
), 0);
1067 SendMessageW(lphc
->hWndLBox
, LB_SETTOPINDEX
, (WPARAM
)(idx
< 0 ? 0 : idx
), 0);
1072 /***********************************************************************
1075 * Copy a listbox entry to the edit control.
1077 static void CBUpdateEdit( LPHEADCOMBO lphc
, INT index
)
1080 LPWSTR pText
= NULL
;
1081 static const WCHAR empty_stringW
[] = { 0 };
1083 TRACE("\t %i\n", index
);
1085 if( index
>= 0 ) /* got an entry */
1087 length
= SendMessageW(lphc
->hWndLBox
, LB_GETTEXTLEN
, (WPARAM
)index
, 0);
1090 if( (pText
= HeapAlloc( GetProcessHeap(), 0, (length
+ 1) * sizeof(WCHAR
))) )
1092 SendMessageW(lphc
->hWndLBox
, LB_GETTEXT
,
1093 (WPARAM
)index
, (LPARAM
)pText
);
1098 lphc
->wState
|= (CBF_NOEDITNOTIFY
| CBF_NOLBSELECT
);
1099 SendMessageW(lphc
->hWndEdit
, WM_SETTEXT
, 0, pText
? (LPARAM
)pText
: (LPARAM
)empty_stringW
);
1100 lphc
->wState
&= ~(CBF_NOEDITNOTIFY
| CBF_NOLBSELECT
);
1102 if( lphc
->wState
& CBF_FOCUSED
)
1103 SendMessageW(lphc
->hWndEdit
, EM_SETSEL
, 0, (LPARAM
)(-1));
1106 HeapFree( GetProcessHeap(), 0, pText
);
1109 /***********************************************************************
1112 * Show listbox popup.
1114 static void CBDropDown( LPHEADCOMBO lphc
)
1120 TRACE("[%04x]: drop down\n", CB_HWND(lphc
));
1122 CB_NOTIFY( lphc
, CBN_DROPDOWN
);
1126 lphc
->wState
|= CBF_DROPPED
;
1127 if( CB_GETTYPE(lphc
) == CBS_DROPDOWN
)
1129 lphc
->droppedIndex
= CBUpdateLBox( lphc
, TRUE
);
1131 /* Update edit only if item is in the list */
1132 if( !(lphc
->wState
& CBF_CAPTURE
) && lphc
->droppedIndex
>= 0)
1133 CBUpdateEdit( lphc
, lphc
->droppedIndex
);
1137 lphc
->droppedIndex
= SendMessageW(lphc
->hWndLBox
, LB_GETCURSEL
, 0, 0);
1139 SendMessageW(lphc
->hWndLBox
, LB_SETTOPINDEX
,
1140 (WPARAM
)(lphc
->droppedIndex
== LB_ERR
? 0 : lphc
->droppedIndex
), 0 );
1141 SendMessageW(lphc
->hWndLBox
, LB_CARETON
, 0, 0);
1144 /* now set popup position */
1145 GetWindowRect( lphc
->self
->hwndSelf
, &rect
);
1148 * If it's a dropdown, the listbox is offset
1150 if( CB_GETTYPE(lphc
) == CBS_DROPDOWN
)
1151 rect
.left
+= COMBO_EDITBUTTONSPACE();
1153 /* if the dropped height is greater than the total height of the dropped
1154 items list, then force the drop down list height to be the total height
1155 of the items in the dropped list */
1157 /* And Remove any extra space (Best Fit) */
1158 nDroppedHeight
= lphc
->droppedRect
.bottom
- lphc
->droppedRect
.top
;
1159 /* if listbox length has been set directly by its handle */
1160 GetWindowRect(lphc
->hWndLBox
, &r
);
1161 if (nDroppedHeight
< r
.bottom
- r
.top
)
1162 nDroppedHeight
= r
.bottom
- r
.top
;
1163 nItems
= (int)SendMessageW(lphc
->hWndLBox
, LB_GETCOUNT
, 0, 0);
1169 nHeight
= (int)SendMessageW(lphc
->hWndLBox
, LB_GETITEMHEIGHT
, 0, 0);
1172 if (nHeight
< nDroppedHeight
- COMBO_YBORDERSIZE())
1173 nDroppedHeight
= nHeight
+ COMBO_YBORDERSIZE();
1176 /*If height of dropped rectangle gets beyond a screen size it should go up, otherwise down.*/
1177 if( (rect
.bottom
+ nDroppedHeight
) >= GetSystemMetrics( SM_CYSCREEN
) )
1178 rect
.bottom
= rect
.top
- nDroppedHeight
;
1180 SetWindowPos( lphc
->hWndLBox
, HWND_TOP
, rect
.left
, rect
.bottom
,
1181 lphc
->droppedRect
.right
- lphc
->droppedRect
.left
,
1183 SWP_NOACTIVATE
| SWP_SHOWWINDOW
);
1186 if( !(lphc
->wState
& CBF_NOREDRAW
) )
1187 RedrawWindow( lphc
->self
->hwndSelf
, NULL
, 0, RDW_INVALIDATE
|
1188 RDW_ERASE
| RDW_UPDATENOW
| RDW_NOCHILDREN
);
1190 EnableWindow( lphc
->hWndLBox
, TRUE
);
1191 if (GetCapture() != lphc
->self
->hwndSelf
)
1192 SetCapture(lphc
->hWndLBox
);
1195 /***********************************************************************
1198 * Hide listbox popup.
1200 static void CBRollUp( LPHEADCOMBO lphc
, BOOL ok
, BOOL bButton
)
1202 HWND hWnd
= lphc
->self
->hwndSelf
;
1204 TRACE("[%04x]: sel ok? [%i] dropped? [%i]\n",
1205 CB_HWND(lphc
), (INT
)ok
, (INT
)(lphc
->wState
& CBF_DROPPED
));
1207 CB_NOTIFY( lphc
, (ok
) ? CBN_SELENDOK
: CBN_SELENDCANCEL
);
1209 if( IsWindow( hWnd
) && CB_GETTYPE(lphc
) != CBS_SIMPLE
)
1212 if( lphc
->wState
& CBF_DROPPED
)
1216 lphc
->wState
&= ~CBF_DROPPED
;
1217 ShowWindow( lphc
->hWndLBox
, SW_HIDE
);
1219 if(GetCapture() == lphc
->hWndLBox
)
1224 if( CB_GETTYPE(lphc
) == CBS_DROPDOWN
)
1226 rect
= lphc
->buttonRect
;
1237 rect
= lphc
->textRect
;
1242 if( bButton
&& !(lphc
->wState
& CBF_NOREDRAW
) )
1243 RedrawWindow( hWnd
, &rect
, 0, RDW_INVALIDATE
|
1244 RDW_ERASE
| RDW_UPDATENOW
| RDW_NOCHILDREN
);
1245 CB_NOTIFY( lphc
, CBN_CLOSEUP
);
1250 /***********************************************************************
1253 * Used by the ComboLBox to show/hide itself in response to VK_F4, etc...
1255 BOOL
COMBO_FlipListbox( LPHEADCOMBO lphc
, BOOL ok
, BOOL bRedrawButton
)
1257 if( lphc
->wState
& CBF_DROPPED
)
1259 CBRollUp( lphc
, ok
, bRedrawButton
);
1267 /***********************************************************************
1270 static void CBRepaintButton( LPHEADCOMBO lphc
)
1272 InvalidateRect(CB_HWND(lphc
), &lphc
->buttonRect
, TRUE
);
1273 UpdateWindow(CB_HWND(lphc
));
1276 /***********************************************************************
1279 static void COMBO_SetFocus( LPHEADCOMBO lphc
)
1281 if( !(lphc
->wState
& CBF_FOCUSED
) )
1283 if( CB_GETTYPE(lphc
) == CBS_DROPDOWNLIST
)
1284 SendMessageW(lphc
->hWndLBox
, LB_CARETON
, 0, 0);
1286 /* This is wrong. Message sequences seem to indicate that this
1287 is set *after* the notify. */
1288 /* lphc->wState |= CBF_FOCUSED; */
1290 if( !(lphc
->wState
& CBF_EDIT
) )
1291 InvalidateRect(CB_HWND(lphc
), &lphc
->textRect
, TRUE
);
1293 CB_NOTIFY( lphc
, CBN_SETFOCUS
);
1294 lphc
->wState
|= CBF_FOCUSED
;
1298 /***********************************************************************
1301 static void COMBO_KillFocus( LPHEADCOMBO lphc
)
1303 HWND hWnd
= lphc
->self
->hwndSelf
;
1305 if( lphc
->wState
& CBF_FOCUSED
)
1307 CBRollUp( lphc
, FALSE
, TRUE
);
1308 if( IsWindow( hWnd
) )
1310 if( CB_GETTYPE(lphc
) == CBS_DROPDOWNLIST
)
1311 SendMessageW(lphc
->hWndLBox
, LB_CARETOFF
, 0, 0);
1313 lphc
->wState
&= ~CBF_FOCUSED
;
1316 if( !(lphc
->wState
& CBF_EDIT
) )
1317 InvalidateRect(CB_HWND(lphc
), &lphc
->textRect
, TRUE
);
1319 CB_NOTIFY( lphc
, CBN_KILLFOCUS
);
1324 /***********************************************************************
1327 static LRESULT
COMBO_Command( LPHEADCOMBO lphc
, WPARAM wParam
, HWND hWnd
)
1329 if ( lphc
->wState
& CBF_EDIT
&& lphc
->hWndEdit
== hWnd
)
1331 /* ">> 8" makes gcc generate jump-table instead of cmp ladder */
1333 switch( HIWORD(wParam
) >> 8 )
1335 case (EN_SETFOCUS
>> 8):
1337 TRACE("[%04x]: edit [%04x] got focus\n",
1338 CB_HWND(lphc
), lphc
->hWndEdit
);
1340 COMBO_SetFocus( lphc
);
1343 case (EN_KILLFOCUS
>> 8):
1345 TRACE("[%04x]: edit [%04x] lost focus\n",
1346 CB_HWND(lphc
), lphc
->hWndEdit
);
1348 /* NOTE: it seems that Windows' edit control sends an
1349 * undocumented message WM_USER + 0x1B instead of this
1350 * notification (only when it happens to be a part of
1351 * the combo). ?? - AK.
1354 COMBO_KillFocus( lphc
);
1358 case (EN_CHANGE
>> 8):
1360 * In some circumstances (when the selection of the combobox
1361 * is changed for example) we don't wans the EN_CHANGE notification
1362 * to be forwarded to the parent of the combobox. This code
1363 * checks a flag that is set in these occasions and ignores the
1366 if (lphc
->wState
& CBF_NOLBSELECT
)
1368 lphc
->wState
&= ~CBF_NOLBSELECT
;
1372 CBUpdateLBox( lphc
, lphc
->wState
& CBF_DROPPED
);
1375 if (!(lphc
->wState
& CBF_NOEDITNOTIFY
))
1376 CB_NOTIFY( lphc
, CBN_EDITCHANGE
);
1379 case (EN_UPDATE
>> 8):
1380 if (!(lphc
->wState
& CBF_NOEDITNOTIFY
))
1381 CB_NOTIFY( lphc
, CBN_EDITUPDATE
);
1384 case (EN_ERRSPACE
>> 8):
1385 CB_NOTIFY( lphc
, CBN_ERRSPACE
);
1388 else if( lphc
->hWndLBox
== hWnd
)
1390 switch( HIWORD(wParam
) )
1393 CB_NOTIFY( lphc
, CBN_ERRSPACE
);
1397 CB_NOTIFY( lphc
, CBN_DBLCLK
);
1403 TRACE("[%04x]: lbox selection change [%04x]\n",
1404 CB_HWND(lphc
), lphc
->wState
);
1406 if( HIWORD(wParam
) == LBN_SELCHANGE
)
1408 if( lphc
->wState
& CBF_EDIT
)
1410 INT index
= SendMessageW(lphc
->hWndLBox
, LB_GETCURSEL
, 0, 0);
1411 lphc
->wState
|= CBF_NOLBSELECT
;
1412 CBUpdateEdit( lphc
, index
);
1413 /* select text in edit, as Windows does */
1414 SendMessageW(lphc
->hWndEdit
, EM_SETSEL
, 0, (LPARAM
)(-1));
1417 InvalidateRect(CB_HWND(lphc
), &lphc
->textRect
, TRUE
);
1420 /* do not roll up if selection is being tracked
1421 * by arrowkeys in the dropdown listbox */
1423 if( (lphc
->dwStyle
& CBS_SIMPLE
) ||
1424 ((lphc
->wState
& CBF_DROPPED
) && !(lphc
->wState
& CBF_NOROLLUP
)) )
1426 CBRollUp( lphc
, (HIWORD(wParam
) == LBN_SELCHANGE
), TRUE
);
1428 else lphc
->wState
&= ~CBF_NOROLLUP
;
1430 CB_NOTIFY( lphc
, CBN_SELCHANGE
);
1436 /* nothing to do here since ComboLBox always resets the focus to its
1437 * combo/edit counterpart */
1444 /***********************************************************************
1447 * Fixup an ownerdrawn item operation and pass it up to the combobox owner.
1449 static LRESULT
COMBO_ItemOp( LPHEADCOMBO lphc
, UINT msg
, LPARAM lParam
)
1451 HWND hWnd
= lphc
->self
->hwndSelf
;
1453 TRACE("[%04x]: ownerdraw op %04x\n", CB_HWND(lphc
), msg
);
1455 #define lpIS ((LPDELETEITEMSTRUCT)lParam)
1457 /* two first items are the same in all 4 structs */
1458 lpIS
->CtlType
= ODT_COMBOBOX
;
1459 lpIS
->CtlID
= lphc
->self
->wIDmenu
;
1461 switch( msg
) /* patch window handle */
1464 lpIS
->hwndItem
= hWnd
;
1468 #define lpIS ((LPDRAWITEMSTRUCT)lParam)
1469 lpIS
->hwndItem
= hWnd
;
1472 case WM_COMPAREITEM
:
1473 #define lpIS ((LPCOMPAREITEMSTRUCT)lParam)
1474 lpIS
->hwndItem
= hWnd
;
1479 return SendMessageW(lphc
->owner
, msg
, lphc
->self
->wIDmenu
, lParam
);
1482 /***********************************************************************
1485 static LRESULT
COMBO_GetText( LPHEADCOMBO lphc
, INT N
, LPARAM lParam
, BOOL unicode
)
1487 if( lphc
->wState
& CBF_EDIT
)
1488 return unicode
? SendMessageW(lphc
->hWndEdit
, WM_GETTEXT
, (WPARAM
)N
, lParam
) :
1489 SendMessageA(lphc
->hWndEdit
, WM_GETTEXT
, (WPARAM
)N
, lParam
);
1491 /* get it from the listbox */
1493 if( lphc
->hWndLBox
)
1495 INT idx
= SendMessageW(lphc
->hWndLBox
, LB_GETCURSEL
, 0, 0);
1499 INT length
= SendMessageW(lphc
->hWndLBox
, LB_GETTEXTLEN
,
1504 LPWSTR lpBuffer
, lpText
= (LPWSTR
)lParam
;
1506 /* 'length' is without the terminating character */
1508 lpBuffer
= HeapAlloc(GetProcessHeap(), 0, (length
+ 1) * sizeof(WCHAR
));
1514 n
= SendMessageW(lphc
->hWndLBox
, LB_GETTEXT
, (WPARAM
)idx
, (LPARAM
)lpBuffer
);
1516 /* truncate if buffer is too short */
1522 strncpyW(lpText
, lpBuffer
, (N
> n
) ? n
+1 : N
-1);
1523 lpText
[N
- 1] = '\0';
1526 HeapFree( GetProcessHeap(), 0, lpBuffer
);
1531 LPSTR lpBuffer
, lpText
= (LPSTR
)lParam
;
1533 /* 'length' is without the terminating character */
1535 lpBuffer
= HeapAlloc(GetProcessHeap(), 0, length
+ 1);
1541 n
= SendMessageA(lphc
->hWndLBox
, LB_GETTEXT
, (WPARAM
)idx
, (LPARAM
)lpBuffer
);
1543 /* truncate if buffer is too short */
1549 strncpy(lpText
, lpBuffer
, (N
> n
) ? n
+1 : N
-1);
1550 lpText
[N
- 1] = '\0';
1553 HeapFree( GetProcessHeap(), 0, lpBuffer
);
1563 /***********************************************************************
1566 * This function sets window positions according to the updated
1567 * component placement struct.
1569 static void CBResetPos(
1575 BOOL bDrop
= (CB_GETTYPE(lphc
) != CBS_SIMPLE
);
1577 /* NOTE: logs sometimes have WM_LBUTTONUP before a cascade of
1578 * sizing messages */
1580 if( lphc
->wState
& CBF_EDIT
)
1581 SetWindowPos( lphc
->hWndEdit
, 0,
1582 rectEdit
->left
, rectEdit
->top
,
1583 rectEdit
->right
- rectEdit
->left
,
1584 rectEdit
->bottom
- rectEdit
->top
,
1585 SWP_NOZORDER
| SWP_NOACTIVATE
| ((bDrop
) ? SWP_NOREDRAW
: 0) );
1587 SetWindowPos( lphc
->hWndLBox
, 0,
1588 rectLB
->left
, rectLB
->top
,
1589 rectLB
->right
- rectLB
->left
,
1590 rectLB
->bottom
- rectLB
->top
,
1591 SWP_NOACTIVATE
| SWP_NOZORDER
| ((bDrop
) ? SWP_NOREDRAW
: 0) );
1595 if( lphc
->wState
& CBF_DROPPED
)
1597 lphc
->wState
&= ~CBF_DROPPED
;
1598 ShowWindow( lphc
->hWndLBox
, SW_HIDE
);
1601 if( bRedraw
&& !(lphc
->wState
& CBF_NOREDRAW
) )
1602 RedrawWindow( lphc
->self
->hwndSelf
, NULL
, 0,
1603 RDW_INVALIDATE
| RDW_ERASE
| RDW_UPDATENOW
);
1608 /***********************************************************************
1611 static void COMBO_Size( LPHEADCOMBO lphc
)
1613 CBCalcPlacement(lphc
->self
->hwndSelf
,
1617 &lphc
->droppedRect
);
1619 CBResetPos( lphc
, &lphc
->textRect
, &lphc
->droppedRect
, TRUE
);
1623 /***********************************************************************
1626 static void COMBO_Font( LPHEADCOMBO lphc
, HFONT hFont
, BOOL bRedraw
)
1631 lphc
->hFont
= hFont
;
1634 * Propagate to owned windows.
1636 if( lphc
->wState
& CBF_EDIT
)
1637 SendMessageW(lphc
->hWndEdit
, WM_SETFONT
, (WPARAM
)hFont
, bRedraw
);
1638 SendMessageW(lphc
->hWndLBox
, WM_SETFONT
, (WPARAM
)hFont
, bRedraw
);
1641 * Redo the layout of the control.
1643 if ( CB_GETTYPE(lphc
) == CBS_SIMPLE
)
1645 CBCalcPlacement(lphc
->self
->hwndSelf
,
1649 &lphc
->droppedRect
);
1651 CBResetPos( lphc
, &lphc
->textRect
, &lphc
->droppedRect
, TRUE
);
1655 CBForceDummyResize(lphc
);
1660 /***********************************************************************
1661 * COMBO_SetItemHeight
1663 static LRESULT
COMBO_SetItemHeight( LPHEADCOMBO lphc
, INT index
, INT height
)
1665 LRESULT lRet
= CB_ERR
;
1667 if( index
== -1 ) /* set text field height */
1669 if( height
< 32768 )
1671 lphc
->editHeight
= height
;
1674 * Redo the layout of the control.
1676 if ( CB_GETTYPE(lphc
) == CBS_SIMPLE
)
1678 CBCalcPlacement(lphc
->self
->hwndSelf
,
1682 &lphc
->droppedRect
);
1684 CBResetPos( lphc
, &lphc
->textRect
, &lphc
->droppedRect
, TRUE
);
1688 CBForceDummyResize(lphc
);
1694 else if ( CB_OWNERDRAWN(lphc
) ) /* set listbox item height */
1695 lRet
= SendMessageW(lphc
->hWndLBox
, LB_SETITEMHEIGHT
,
1696 (WPARAM
)index
, (LPARAM
)height
);
1700 /***********************************************************************
1701 * COMBO_SelectString
1703 static LRESULT
COMBO_SelectString( LPHEADCOMBO lphc
, INT start
, LPARAM pText
, BOOL unicode
)
1705 INT index
= unicode
? SendMessageW(lphc
->hWndLBox
, LB_SELECTSTRING
, (WPARAM
)start
, pText
) :
1706 SendMessageA(lphc
->hWndLBox
, LB_SELECTSTRING
, (WPARAM
)start
, pText
);
1709 if( lphc
->wState
& CBF_EDIT
)
1710 CBUpdateEdit( lphc
, index
);
1713 InvalidateRect(CB_HWND(lphc
), &lphc
->textRect
, TRUE
);
1716 return (LRESULT
)index
;
1719 /***********************************************************************
1722 static void COMBO_LButtonDown( LPHEADCOMBO lphc
, LPARAM lParam
)
1726 HWND hWnd
= lphc
->self
->hwndSelf
;
1728 pt
.x
= LOWORD(lParam
);
1729 pt
.y
= HIWORD(lParam
);
1730 bButton
= PtInRect(&lphc
->buttonRect
, pt
);
1732 if( (CB_GETTYPE(lphc
) == CBS_DROPDOWNLIST
) ||
1733 (bButton
&& (CB_GETTYPE(lphc
) == CBS_DROPDOWN
)) )
1735 lphc
->wState
|= CBF_BUTTONDOWN
;
1736 if( lphc
->wState
& CBF_DROPPED
)
1738 /* got a click to cancel selection */
1740 lphc
->wState
&= ~CBF_BUTTONDOWN
;
1741 CBRollUp( lphc
, TRUE
, FALSE
);
1742 if( !IsWindow( hWnd
) ) return;
1744 if( lphc
->wState
& CBF_CAPTURE
)
1746 lphc
->wState
&= ~CBF_CAPTURE
;
1752 /* drop down the listbox and start tracking */
1754 lphc
->wState
|= CBF_CAPTURE
;
1758 if( bButton
) CBRepaintButton( lphc
);
1762 /***********************************************************************
1765 * Release capture and stop tracking if needed.
1767 static void COMBO_LButtonUp( LPHEADCOMBO lphc
)
1769 if( lphc
->wState
& CBF_CAPTURE
)
1771 lphc
->wState
&= ~CBF_CAPTURE
;
1772 if( CB_GETTYPE(lphc
) == CBS_DROPDOWN
)
1774 INT index
= CBUpdateLBox( lphc
, TRUE
);
1775 /* Update edit only if item is in the list */
1778 lphc
->wState
|= CBF_NOLBSELECT
;
1779 CBUpdateEdit( lphc
, index
);
1780 lphc
->wState
&= ~CBF_NOLBSELECT
;
1784 SetCapture(lphc
->hWndLBox
);
1787 if( lphc
->wState
& CBF_BUTTONDOWN
)
1789 lphc
->wState
&= ~CBF_BUTTONDOWN
;
1790 CBRepaintButton( lphc
);
1794 /***********************************************************************
1797 * Two things to do - track combo button and release capture when
1798 * pointer goes into the listbox.
1800 static void COMBO_MouseMove( LPHEADCOMBO lphc
, WPARAM wParam
, LPARAM lParam
)
1805 pt
.x
= LOWORD(lParam
);
1806 pt
.y
= HIWORD(lParam
);
1808 if( lphc
->wState
& CBF_BUTTONDOWN
)
1812 bButton
= PtInRect(&lphc
->buttonRect
, pt
);
1816 lphc
->wState
&= ~CBF_BUTTONDOWN
;
1817 CBRepaintButton( lphc
);
1821 GetClientRect( lphc
->hWndLBox
, &lbRect
);
1822 MapWindowPoints( lphc
->self
->hwndSelf
, lphc
->hWndLBox
, &pt
, 1 );
1823 if( PtInRect(&lbRect
, pt
) )
1825 lphc
->wState
&= ~CBF_CAPTURE
;
1827 if( CB_GETTYPE(lphc
) == CBS_DROPDOWN
) CBUpdateLBox( lphc
, TRUE
);
1829 /* hand over pointer tracking */
1830 SendMessageW(lphc
->hWndLBox
, WM_LBUTTONDOWN
, wParam
, lParam
);
1835 /***********************************************************************
1836 * ComboWndProc_locked
1838 * http://www.microsoft.com/msdn/sdk/platforms/doc/sdk/win32/ctrl/src/combobox_15.htm
1840 static LRESULT
ComboWndProc_locked( WND
* pWnd
, UINT message
,
1841 WPARAM wParam
, LPARAM lParam
, BOOL unicode
)
1844 LPHEADCOMBO lphc
= CB_GETPTR(pWnd
);
1845 HWND hwnd
= pWnd
->hwndSelf
;
1847 TRACE("[%04x]: msg %s wp %08x lp %08lx\n",
1848 pWnd
->hwndSelf
, SPY_GetMsgName(message
), wParam
, lParam
);
1850 if( lphc
|| message
== WM_NCCREATE
)
1854 /* System messages */
1858 LONG style
= unicode
? ((LPCREATESTRUCTW
)lParam
)->style
:
1859 ((LPCREATESTRUCTA
)lParam
)->style
;
1860 return COMBO_NCCreate(pWnd
, style
);
1863 COMBO_NCDestroy(lphc
);
1864 break;/* -> DefWindowProc */
1872 hwndParent
= ((LPCREATESTRUCTW
)lParam
)->hwndParent
;
1873 style
= ((LPCREATESTRUCTW
)lParam
)->style
;
1877 hwndParent
= ((LPCREATESTRUCTA
)lParam
)->hwndParent
;
1878 style
= ((LPCREATESTRUCTA
)lParam
)->style
;
1880 return COMBO_Create(lphc
, pWnd
, hwndParent
, style
);
1883 case WM_PRINTCLIENT
:
1884 if (lParam
& PRF_ERASEBKGND
)
1885 COMBO_EraseBackground(hwnd
, lphc
, wParam
);
1889 /* wParam may contain a valid HDC! */
1890 return COMBO_Paint(lphc
, wParam
);
1892 return COMBO_EraseBackground(hwnd
, lphc
, wParam
);
1895 LRESULT result
= DLGC_WANTARROWS
| DLGC_WANTCHARS
;
1896 if (lParam
&& (((LPMSG
)lParam
)->message
== WM_KEYDOWN
))
1898 int vk
= (int)((LPMSG
)lParam
)->wParam
;
1900 if ((vk
== VK_RETURN
|| vk
== VK_ESCAPE
) && (lphc
->wState
& CBF_DROPPED
))
1901 result
|= DLGC_WANTMESSAGE
;
1905 case WM_WINDOWPOSCHANGING
:
1906 return COMBO_WindowPosChanging(hwnd
, lphc
, (LPWINDOWPOS
)lParam
);
1907 case WM_WINDOWPOSCHANGED
:
1908 /* SetWindowPos can be called on a Combobox to resize its Listbox.
1909 * In that case, the Combobox itself will not be resized, so we won't
1910 * get a WM_SIZE. Since we still want to update the Listbox, we have to
1915 if( lphc
->hWndLBox
&&
1916 !(lphc
->wState
& CBF_NORESIZE
) ) COMBO_Size( lphc
);
1919 COMBO_Font( lphc
, (HFONT16
)wParam
, (BOOL
)lParam
);
1922 return (LRESULT
)lphc
->hFont
;
1924 if( lphc
->wState
& CBF_EDIT
)
1925 SetFocus( lphc
->hWndEdit
);
1927 COMBO_SetFocus( lphc
);
1930 #define hwndFocus ((HWND16)wParam)
1932 (hwndFocus
!= lphc
->hWndEdit
&& hwndFocus
!= lphc
->hWndLBox
))
1933 COMBO_KillFocus( lphc
);
1937 return COMBO_Command( lphc
, wParam
, (HWND
)lParam
);
1939 return COMBO_GetText( lphc
, (INT
)wParam
, lParam
, unicode
);
1941 case WM_GETTEXTLENGTH
:
1943 if ((message
== WM_GETTEXTLENGTH
) && !ISWIN31
&& !(lphc
->wState
& CBF_EDIT
))
1945 int j
= SendMessageW(lphc
->hWndLBox
, LB_GETCURSEL
, 0, 0);
1946 if (j
== -1) return 0;
1947 return SendMessageW(lphc
->hWndLBox
, LB_GETTEXTLEN
, j
, 0);
1949 else if( lphc
->wState
& CBF_EDIT
)
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
;
1962 if( lphc
->wState
& CBF_EDIT
)
1964 return unicode
? SendMessageW(lphc
->hWndEdit
, message
, wParam
, lParam
) :
1965 SendMessageA(lphc
->hWndEdit
, message
, wParam
, lParam
);
1971 case WM_COMPAREITEM
:
1972 case WM_MEASUREITEM
:
1973 return COMBO_ItemOp(lphc
, message
, lParam
);
1975 if( lphc
->wState
& CBF_EDIT
)
1976 EnableWindow( lphc
->hWndEdit
, (BOOL
)wParam
);
1977 EnableWindow( lphc
->hWndLBox
, (BOOL
)wParam
);
1979 /* Force the control to repaint when the enabled state changes. */
1980 InvalidateRect(CB_HWND(lphc
), NULL
, TRUE
);
1984 lphc
->wState
&= ~CBF_NOREDRAW
;
1986 lphc
->wState
|= CBF_NOREDRAW
;
1988 if( lphc
->wState
& CBF_EDIT
)
1989 SendMessageW(lphc
->hWndEdit
, message
, wParam
, lParam
);
1990 SendMessageW(lphc
->hWndLBox
, message
, wParam
, lParam
);
1993 if( KEYDATA_ALT
& HIWORD(lParam
) )
1994 if( wParam
== VK_UP
|| wParam
== VK_DOWN
)
1995 COMBO_FlipListbox( lphc
, FALSE
, FALSE
);
2003 if ((wParam
== VK_RETURN
|| wParam
== VK_ESCAPE
) &&
2004 (lphc
->wState
& CBF_DROPPED
))
2006 CBRollUp( lphc
, wParam
== VK_RETURN
, FALSE
);
2010 if( lphc
->wState
& CBF_EDIT
)
2011 hwndTarget
= lphc
->hWndEdit
;
2013 hwndTarget
= lphc
->hWndLBox
;
2015 return unicode
? SendMessageW(hwndTarget
, message
, wParam
, lParam
) :
2016 SendMessageA(hwndTarget
, message
, wParam
, lParam
);
2018 case WM_LBUTTONDOWN
:
2019 if( !(lphc
->wState
& CBF_FOCUSED
) ) SetFocus( lphc
->self
->hwndSelf
);
2020 if( lphc
->wState
& CBF_FOCUSED
) COMBO_LButtonDown( lphc
, lParam
);
2023 COMBO_LButtonUp( lphc
);
2026 if( lphc
->wState
& CBF_CAPTURE
)
2027 COMBO_MouseMove( lphc
, wParam
, lParam
);
2031 if (wParam
& (MK_SHIFT
| MK_CONTROL
))
2032 return unicode
? DefWindowProcW(hwnd
, message
, wParam
, lParam
) :
2033 DefWindowProcA(hwnd
, message
, wParam
, lParam
);
2034 if (SHIWORD(wParam
) > 0) return SendMessageW(hwnd
, WM_KEYDOWN
, VK_UP
, 0);
2035 if (SHIWORD(wParam
) < 0) return SendMessageW(hwnd
, WM_KEYDOWN
, VK_DOWN
, 0);
2038 /* Combo messages */
2040 case CB_ADDSTRING16
:
2041 if( CB_HASSTRINGS(lphc
) ) lParam
= (LPARAM
)MapSL(lParam
);
2044 return unicode
? SendMessageW(lphc
->hWndLBox
, LB_ADDSTRING
, 0, lParam
) :
2045 SendMessageA(lphc
->hWndLBox
, LB_ADDSTRING
, 0, lParam
);
2046 case CB_INSERTSTRING16
:
2047 wParam
= (INT
)(INT16
)wParam
;
2048 if( CB_HASSTRINGS(lphc
) ) lParam
= (LPARAM
)MapSL(lParam
);
2050 case CB_INSERTSTRING
:
2051 return unicode
? SendMessageW(lphc
->hWndLBox
, LB_INSERTSTRING
, wParam
, lParam
) :
2052 SendMessageA(lphc
->hWndLBox
, LB_INSERTSTRING
, wParam
, lParam
);
2053 case CB_DELETESTRING16
:
2054 case CB_DELETESTRING
:
2055 return unicode
? SendMessageW(lphc
->hWndLBox
, LB_DELETESTRING
, wParam
, 0) :
2056 SendMessageA(lphc
->hWndLBox
, LB_DELETESTRING
, wParam
, 0);
2057 case CB_SELECTSTRING16
:
2058 wParam
= (INT
)(INT16
)wParam
;
2059 if( CB_HASSTRINGS(lphc
) ) lParam
= (LPARAM
)MapSL(lParam
);
2061 case CB_SELECTSTRING
:
2062 return COMBO_SelectString(lphc
, (INT
)wParam
, lParam
, unicode
);
2063 case CB_FINDSTRING16
:
2064 wParam
= (INT
)(INT16
)wParam
;
2065 if( CB_HASSTRINGS(lphc
) ) lParam
= (LPARAM
)MapSL(lParam
);
2068 return unicode
? SendMessageW(lphc
->hWndLBox
, LB_FINDSTRING
, wParam
, lParam
) :
2069 SendMessageA(lphc
->hWndLBox
, LB_FINDSTRING
, wParam
, lParam
);
2070 case CB_FINDSTRINGEXACT16
:
2071 wParam
= (INT
)(INT16
)wParam
;
2072 if( CB_HASSTRINGS(lphc
) ) lParam
= (LPARAM
)MapSL(lParam
);
2074 case CB_FINDSTRINGEXACT
:
2075 return unicode
? SendMessageW(lphc
->hWndLBox
, LB_FINDSTRINGEXACT
, wParam
, lParam
) :
2076 SendMessageA(lphc
->hWndLBox
, LB_FINDSTRINGEXACT
, wParam
, lParam
);
2077 case CB_SETITEMHEIGHT16
:
2078 wParam
= (INT
)(INT16
)wParam
; /* signed integer */
2080 case CB_SETITEMHEIGHT
:
2081 return COMBO_SetItemHeight( lphc
, (INT
)wParam
, (INT
)lParam
);
2082 case CB_GETITEMHEIGHT16
:
2083 wParam
= (INT
)(INT16
)wParam
;
2085 case CB_GETITEMHEIGHT
:
2086 if( (INT
)wParam
>= 0 ) /* listbox item */
2087 return SendMessageW(lphc
->hWndLBox
, LB_GETITEMHEIGHT
, wParam
, 0);
2088 return CBGetTextAreaHeight(hwnd
, lphc
);
2089 case CB_RESETCONTENT16
:
2090 case CB_RESETCONTENT
:
2091 SendMessageW(lphc
->hWndLBox
, LB_RESETCONTENT
, 0, 0);
2092 if( (lphc
->wState
& CBF_EDIT
) && CB_HASSTRINGS(lphc
) )
2094 static const WCHAR empty_stringW
[] = { 0 };
2095 SendMessageW(lphc
->hWndEdit
, WM_SETTEXT
, 0, (LPARAM
)empty_stringW
);
2098 InvalidateRect(CB_HWND(lphc
), NULL
, TRUE
);
2100 case CB_INITSTORAGE
:
2101 return SendMessageW(lphc
->hWndLBox
, LB_INITSTORAGE
, wParam
, lParam
);
2102 case CB_GETHORIZONTALEXTENT
:
2103 return SendMessageW(lphc
->hWndLBox
, LB_GETHORIZONTALEXTENT
, 0, 0);
2104 case CB_SETHORIZONTALEXTENT
:
2105 return SendMessageW(lphc
->hWndLBox
, LB_SETHORIZONTALEXTENT
, wParam
, 0);
2106 case CB_GETTOPINDEX
:
2107 return SendMessageW(lphc
->hWndLBox
, LB_GETTOPINDEX
, 0, 0);
2109 return SendMessageW(lphc
->hWndLBox
, LB_GETLOCALE
, 0, 0);
2111 return SendMessageW(lphc
->hWndLBox
, LB_SETLOCALE
, wParam
, 0);
2112 case CB_GETDROPPEDWIDTH
:
2113 if( lphc
->droppedWidth
)
2114 return lphc
->droppedWidth
;
2115 return lphc
->droppedRect
.right
- lphc
->droppedRect
.left
;
2116 case CB_SETDROPPEDWIDTH
:
2117 if( (CB_GETTYPE(lphc
) != CBS_SIMPLE
) &&
2118 (INT
)wParam
< 32768 ) lphc
->droppedWidth
= (INT
)wParam
;
2120 case CB_GETDROPPEDCONTROLRECT16
:
2121 lParam
= (LPARAM
)MapSL(lParam
);
2125 CBGetDroppedControlRect( lphc
, &r
);
2126 CONV_RECT32TO16( &r
, (LPRECT16
)lParam
);
2129 case CB_GETDROPPEDCONTROLRECT
:
2130 if( lParam
) CBGetDroppedControlRect(lphc
, (LPRECT
)lParam
);
2132 case CB_GETDROPPEDSTATE16
:
2133 case CB_GETDROPPEDSTATE
:
2134 return (lphc
->wState
& CBF_DROPPED
) ? TRUE
: FALSE
;
2136 lParam
= (LPARAM
)MapSL(lParam
);
2140 if(message
== CB_DIR
) message
= LB_DIR
;
2141 return unicode
? SendMessageW(lphc
->hWndLBox
, message
, wParam
, lParam
) :
2142 SendMessageA(lphc
->hWndLBox
, message
, wParam
, lParam
);
2144 case CB_SHOWDROPDOWN16
:
2145 case CB_SHOWDROPDOWN
:
2146 if( CB_GETTYPE(lphc
) != CBS_SIMPLE
)
2150 if( !(lphc
->wState
& CBF_DROPPED
) )
2154 if( lphc
->wState
& CBF_DROPPED
)
2155 CBRollUp( lphc
, FALSE
, TRUE
);
2160 return SendMessageW(lphc
->hWndLBox
, LB_GETCOUNT
, 0, 0);
2161 case CB_GETCURSEL16
:
2163 return SendMessageW(lphc
->hWndLBox
, LB_GETCURSEL
, 0, 0);
2164 case CB_SETCURSEL16
:
2165 wParam
= (INT
)(INT16
)wParam
;
2168 lParam
= SendMessageW(lphc
->hWndLBox
, LB_SETCURSEL
, wParam
, 0);
2170 SendMessageW(lphc
->hWndLBox
, LB_SETTOPINDEX
, wParam
, 0);
2172 /* no LBN_SELCHANGE in this case, update manually */
2173 if( lphc
->wState
& CBF_EDIT
)
2174 CBUpdateEdit( lphc
, (INT
)wParam
);
2176 InvalidateRect(CB_HWND(lphc
), &lphc
->textRect
, TRUE
);
2177 lphc
->wState
&= ~CBF_SELCHANGE
;
2179 case CB_GETLBTEXT16
:
2180 wParam
= (INT
)(INT16
)wParam
;
2181 lParam
= (LPARAM
)MapSL(lParam
);
2184 return unicode
? SendMessageW(lphc
->hWndLBox
, LB_GETTEXT
, wParam
, lParam
) :
2185 SendMessageA(lphc
->hWndLBox
, LB_GETTEXT
, wParam
, lParam
);
2186 case CB_GETLBTEXTLEN16
:
2187 wParam
= (INT
)(INT16
)wParam
;
2189 case CB_GETLBTEXTLEN
:
2190 return SendMessageW(lphc
->hWndLBox
, LB_GETTEXTLEN
, wParam
, 0);
2191 case CB_GETITEMDATA16
:
2192 wParam
= (INT
)(INT16
)wParam
;
2194 case CB_GETITEMDATA
:
2195 return SendMessageW(lphc
->hWndLBox
, LB_GETITEMDATA
, wParam
, 0);
2196 case CB_SETITEMDATA16
:
2197 wParam
= (INT
)(INT16
)wParam
;
2199 case CB_SETITEMDATA
:
2200 return SendMessageW(lphc
->hWndLBox
, LB_SETITEMDATA
, wParam
, lParam
);
2201 case CB_GETEDITSEL16
:
2202 wParam
= lParam
= 0; /* just in case */
2205 /* Edit checks passed parameters itself */
2206 if( lphc
->wState
& CBF_EDIT
)
2207 return SendMessageW(lphc
->hWndEdit
, EM_GETSEL
, wParam
, lParam
);
2209 case CB_SETEDITSEL16
:
2211 if( lphc
->wState
& CBF_EDIT
)
2212 return SendMessageW(lphc
->hWndEdit
, EM_SETSEL
,
2213 (INT
)(INT16
)LOWORD(lParam
), (INT
)(INT16
)HIWORD(lParam
) );
2215 case CB_SETEXTENDEDUI16
:
2216 case CB_SETEXTENDEDUI
:
2217 if( CB_GETTYPE(lphc
) == CBS_SIMPLE
)
2220 lphc
->wState
|= CBF_EUI
;
2221 else lphc
->wState
&= ~CBF_EUI
;
2223 case CB_GETEXTENDEDUI16
:
2224 case CB_GETEXTENDEDUI
:
2225 return (lphc
->wState
& CBF_EUI
) ? TRUE
: FALSE
;
2228 if (message
>= WM_USER
)
2229 WARN("unknown msg WM_USER+%04x wp=%04x lp=%08lx\n",
2230 message
- WM_USER
, wParam
, lParam
);
2233 return unicode
? DefWindowProcW(hwnd
, message
, wParam
, lParam
) :
2234 DefWindowProcA(hwnd
, message
, wParam
, lParam
);
2239 /***********************************************************************
2242 * This is just a wrapper for the real ComboWndProc which locks/unlocks
2245 static LRESULT WINAPI
ComboWndProcA( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2247 WND
* pWnd
= WIN_FindWndPtr(hwnd
);
2248 LRESULT retvalue
= ComboWndProc_locked(pWnd
, message
, wParam
, lParam
, FALSE
);
2250 WIN_ReleaseWndPtr(pWnd
);
2254 /***********************************************************************
2257 static LRESULT WINAPI
ComboWndProcW( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2259 WND
* pWnd
= WIN_FindWndPtr(hwnd
);
2260 LRESULT retvalue
= ComboWndProc_locked(pWnd
, message
, wParam
, lParam
, TRUE
);
2262 WIN_ReleaseWndPtr(pWnd
);