?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push(c) 7dcddf6204ed5518706a76fe66fd836d81e70dd4
[wine/hacks.git] / dlls / user32 / listbox.c
blobfad5a4831ff4681e0731fb7bd68545b326a50f6e
1 /*
2 * Listbox controls
3 *
4 * Copyright 1996 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 *
20 * NOTES
21 *
22 * This code was audited for completeness against the documented features
23 * of Comctl32.dll version 6.0 on Oct. 9, 2004, by Dimitrie O. Paun.
24 *
25 * Unless otherwise noted, we believe this code to be complete, as per
26 * the specification mentioned above.
27 * If you discover missing features, or bugs, please note them below.
28 *
29 * TODO:
30 * - GetListBoxInfo()
31 * - LB_GETLISTBOXINFO
32 * - LBS_NODATA
33 */
34
35 #include <string.h>
36 #include <stdlib.h>
37 #include <stdarg.h>
38 #include <stdio.h>
39 #include "windef.h"
40 #include "winbase.h"
41 #include "wingdi.h"
42 #include "wine/winuser16.h"
43 #include "wine/unicode.h"
44 #include "user_private.h"
45 #include "controls.h"
46 #include "wine/debug.h"
47
48 WINE_DEFAULT_DEBUG_CHANNEL(listbox);
49
50 /* Items array granularity */
51 #define LB_ARRAY_GRANULARITY 16
52
53 /* Scrolling timeout in ms */
54 #define LB_SCROLL_TIMEOUT 50
55
56 /* Listbox system timer id */
57 #define LB_TIMER_ID 2
58
59 /* flag listbox changed while setredraw false - internal style */
60 #define LBS_DISPLAYCHANGED 0x80000000
61
62 /* Item structure */
63 typedef struct
64 {
65 LPWSTR str; /* Item text */
66 BOOL selected; /* Is item selected? */
67 UINT height; /* Item height (only for OWNERDRAWVARIABLE) */
68 ULONG_PTR data; /* User data */
69 } LB_ITEMDATA;
70
71 /* Listbox structure */
72 typedef struct
73 {
74 HWND self; /* Our own window handle */
75 HWND owner; /* Owner window to send notifications to */
76 UINT style; /* Window style */
77 INT width; /* Window width */
78 INT height; /* Window height */
79 LB_ITEMDATA *items; /* Array of items */
80 INT nb_items; /* Number of items */
81 INT top_item; /* Top visible item */
82 INT selected_item; /* Selected item */
83 INT focus_item; /* Item that has the focus */
84 INT anchor_item; /* Anchor item for extended selection */
85 INT item_height; /* Default item height */
86 INT page_size; /* Items per listbox page */
87 INT column_width; /* Column width for multi-column listboxes */
88 INT horz_extent; /* Horizontal extent (0 if no hscroll) */
89 INT horz_pos; /* Horizontal position */
90 INT nb_tabs; /* Number of tabs in array */
91 INT *tabs; /* Array of tabs */
92 INT avg_char_width; /* Average width of characters */
93 BOOL caret_on; /* Is caret on? */
94 BOOL captured; /* Is mouse captured? */
95 BOOL in_focus;
96 HFONT font; /* Current font */
97 LCID locale; /* Current locale for string comparisons */
98 LPHEADCOMBO lphc; /* ComboLBox */
99 } LB_DESCR;
100
101
102 #define IS_OWNERDRAW(descr) \
103 ((descr)->style & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE))
104
105 #define HAS_STRINGS(descr) \
106 (!IS_OWNERDRAW(descr) || ((descr)->style & LBS_HASSTRINGS))
107
108
109 #define IS_MULTISELECT(descr) \
110 ((descr)->style & (LBS_MULTIPLESEL|LBS_EXTENDEDSEL) && \
111 !((descr)->style & LBS_NOSEL))
112
113 #define SEND_NOTIFICATION(descr,code) \
114 (SendMessageW( (descr)->owner, WM_COMMAND, \
115 MAKEWPARAM( GetWindowLongPtrW((descr->self),GWLP_ID), (code)), (LPARAM)(descr->self) ))
116
117 #define ISWIN31 (LOWORD(GetVersion()) == 0x0a03)
118
119 /* Current timer status */
120 typedef enum
121 {
122 LB_TIMER_NONE,
123 LB_TIMER_UP,
124 LB_TIMER_LEFT,
125 LB_TIMER_DOWN,
126 LB_TIMER_RIGHT
127 } TIMER_DIRECTION;
128
129 static TIMER_DIRECTION LISTBOX_Timer = LB_TIMER_NONE;
130
131 static LRESULT WINAPI ListBoxWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
132 static LRESULT WINAPI ListBoxWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
133
134 static LRESULT LISTBOX_GetItemRect( LB_DESCR *descr, INT index, RECT *rect );
135
136 /*********************************************************************
137 * listbox class descriptor
138 */
139 const struct builtin_class_descr LISTBOX_builtin_class =
140 {
141 "ListBox", /* name */
142 CS_DBLCLKS /*| CS_PARENTDC*/, /* style */
143 ListBoxWndProcA, /* procA */
144 ListBoxWndProcW, /* procW */
145 sizeof(LB_DESCR *), /* extra */
146 IDC_ARROW, /* cursor */
147 0 /* brush */
148 };
149
150
151 /*********************************************************************
152 * combolbox class descriptor
153 */
154 const struct builtin_class_descr COMBOLBOX_builtin_class =
155 {
156 "ComboLBox", /* name */
157 CS_DBLCLKS | CS_SAVEBITS, /* style */
158 ListBoxWndProcA, /* procA */
159 ListBoxWndProcW, /* procW */
160 sizeof(LB_DESCR *), /* extra */
161 IDC_ARROW, /* cursor */
162 0 /* brush */
163 };
164
165
166 /* check whether app is a Win 3.1 app */
167 static inline BOOL is_old_app( LB_DESCR *descr )
168 {
169 return (GetExpWinVer16( GetWindowLongPtrW(descr->self, GWLP_HINSTANCE) ) & 0xFF00 ) == 0x0300;
170 }
171
172
173 /***********************************************************************
174 * LISTBOX_GetCurrentPageSize
175 *
176 * Return the current page size
177 */
178 static INT LISTBOX_GetCurrentPageSize( LB_DESCR *descr )
179 {
180 INT i, height;
181 if (!(descr->style & LBS_OWNERDRAWVARIABLE)) return descr->page_size;
182 for (i = descr->top_item, height = 0; i < descr->nb_items; i++)
183 {
184 if ((height += descr->items[i].height) > descr->height) break;
185 }
186 if (i == descr->top_item) return 1;
187 else return i - descr->top_item;
188 }
189
190
191 /***********************************************************************
192 * LISTBOX_GetMaxTopIndex
193 *
194 * Return the maximum possible index for the top of the listbox.
195 */
196 static INT LISTBOX_GetMaxTopIndex( LB_DESCR *descr )
197 {
198 INT max, page;
199
200 if (descr->style & LBS_OWNERDRAWVARIABLE)
201 {
202 page = descr->height;
203 for (max = descr->nb_items - 1; max >= 0; max--)
204 if ((page -= descr->items[max].height) < 0) break;
205 if (max < descr->nb_items - 1) max++;
206 }
207 else if (descr->style & LBS_MULTICOLUMN)
208 {
209 if ((page = descr->width / descr->column_width) < 1) page = 1;
210 max = (descr->nb_items + descr->page_size - 1) / descr->page_size;
211 max = (max - page) * descr->page_size;
212 }
213 else
214 {
215 max = descr->nb_items - descr->page_size;
216 }
217 if (max < 0) max = 0;
218 return max;
219 }
220
221
222 /***********************************************************************
223 * LISTBOX_UpdateScroll
224 *
225 * Update the scrollbars. Should be called whenever the content
226 * of the listbox changes.
227 */
228 static void LISTBOX_UpdateScroll( LB_DESCR *descr )
229 {
230 SCROLLINFO info;
231
232 /* Check the listbox scroll bar flags individually before we call
233 SetScrollInfo otherwise when the listbox style is WS_HSCROLL and
234 no WS_VSCROLL, we end up with an uninitialized, visible horizontal
235 scroll bar when we do not need one.
236 if (!(descr->style & WS_VSCROLL)) return;
237 */
238
239 /* It is important that we check descr->style, and not wnd->dwStyle,
240 for WS_VSCROLL, as the former is exactly the one passed in
241 argument to CreateWindow.
242 In Windows (and from now on in Wine :) a listbox created
243 with such a style (no WS_SCROLL) does not update
244 the scrollbar with listbox-related data, thus letting
245 the programmer use it for his/her own purposes. */
246
247 if (descr->style & LBS_NOREDRAW) return;
248 info.cbSize = sizeof(info);
249
250 if (descr->style & LBS_MULTICOLUMN)
251 {
252 info.nMin = 0;
253 info.nMax = (descr->nb_items - 1) / descr->page_size;
254 info.nPos = descr->top_item / descr->page_size;
255 info.nPage = descr->width / descr->column_width;
256 if (info.nPage < 1) info.nPage = 1;
257 info.fMask = SIF_RANGE | SIF_POS | SIF_PAGE;
258 if (descr->style & LBS_DISABLENOSCROLL)
259 info.fMask |= SIF_DISABLENOSCROLL;
260 if (descr->style & WS_HSCROLL)
261 SetScrollInfo( descr->self, SB_HORZ, &info, TRUE );
262 info.nMax = 0;
263 info.fMask = SIF_RANGE;
264 if (descr->style & WS_VSCROLL)
265 SetScrollInfo( descr->self, SB_VERT, &info, TRUE );
266 }
267 else
268 {
269 info.nMin = 0;
270 info.nMax = descr->nb_items - 1;
271 info.nPos = descr->top_item;
272 info.nPage = LISTBOX_GetCurrentPageSize( descr );
273 info.fMask = SIF_RANGE | SIF_POS | SIF_PAGE;
274 if (descr->style & LBS_DISABLENOSCROLL)
275 info.fMask |= SIF_DISABLENOSCROLL;
276 if (descr->style & WS_VSCROLL)
277 SetScrollInfo( descr->self, SB_VERT, &info, TRUE );
278
279 if (descr->horz_extent)
280 {
281 info.nMin = 0;
282 info.nMax = descr->horz_extent - 1;
283 info.nPos = descr->horz_pos;
284 info.nPage = descr->width;
285 info.fMask = SIF_RANGE | SIF_POS | SIF_PAGE;
286 if (descr->style & LBS_DISABLENOSCROLL)
287 info.fMask |= SIF_DISABLENOSCROLL;
288 if (descr->style & WS_HSCROLL)
289 SetScrollInfo( descr->self, SB_HORZ, &info, TRUE );
290 }
291 }
292 }
293
294
295 /***********************************************************************
296 * LISTBOX_SetTopItem
297 *
298 * Set the top item of the listbox, scrolling up or down if necessary.
299 */
300 static LRESULT LISTBOX_SetTopItem( LB_DESCR *descr, INT index, BOOL scroll )
301 {
302 INT max = LISTBOX_GetMaxTopIndex( descr );
303 if (index > max) index = max;
304 if (index < 0) index = 0;
305 if (descr->style & LBS_MULTICOLUMN) index -= index % descr->page_size;
306 if (descr->top_item == index) return LB_OKAY;
307 if (descr->style & LBS_MULTICOLUMN)
308 {
309 INT diff = (descr->top_item - index) / descr->page_size * descr->column_width;
310 if (scroll && (abs(diff) < descr->width))
311 ScrollWindowEx( descr->self, diff, 0, NULL, NULL, 0, NULL,
312 SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN );
313
314 else
315 scroll = FALSE;
316 }
317 else if (scroll)
318 {
319 INT diff;
320 if (descr->style & LBS_OWNERDRAWVARIABLE)
321 {
322 INT i;
323 diff = 0;
324 if (index > descr->top_item)
325 {
326 for (i = index - 1; i >= descr->top_item; i--)
327 diff -= descr->items[i].height;
328 }
329 else
330 {
331 for (i = index; i < descr->top_item; i++)
332 diff += descr->items[i].height;
333 }
334 }
335 else
336 diff = (descr->top_item - index) * descr->item_height;
337
338 if (abs(diff) < descr->height)
339 ScrollWindowEx( descr->self, 0, diff, NULL, NULL, 0, NULL,
340 SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN );
341 else
342 scroll = FALSE;
343 }
344 if (!scroll) InvalidateRect( descr->self, NULL, TRUE );
345 descr->top_item = index;
346 LISTBOX_UpdateScroll( descr );
347 return LB_OKAY;
348 }
349
350
351 /***********************************************************************
352 * LISTBOX_UpdatePage
353 *
354 * Update the page size. Should be called when the size of
355 * the client area or the item height changes.
356 */
357 static void LISTBOX_UpdatePage( LB_DESCR *descr )
358 {
359 INT page_size;
360
361 if ((descr->item_height == 0) || (page_size = descr->height / descr->item_height) < 1)
362 page_size = 1;
363 if (page_size == descr->page_size) return;
364 descr->page_size = page_size;
365 if (descr->style & LBS_MULTICOLUMN)
366 InvalidateRect( descr->self, NULL, TRUE );
367 LISTBOX_SetTopItem( descr, descr->top_item, FALSE );
368 }
369
370
371 /***********************************************************************
372 * LISTBOX_UpdateSize
373 *
374 * Update the size of the listbox. Should be called when the size of
375 * the client area changes.
376 */
377 static void LISTBOX_UpdateSize( LB_DESCR *descr )
378 {
379 RECT rect;
380
381 GetClientRect( descr->self, &rect );
382 descr->width = rect.right - rect.left;
383 descr->height = rect.bottom - rect.top;
384 if (!(descr->style & LBS_NOINTEGRALHEIGHT) && !(descr->style & LBS_OWNERDRAWVARIABLE))
385 {
386 INT remaining;
387 RECT rect;
388
389 GetWindowRect( descr->self, &rect );
390 if(descr->item_height != 0)
391 remaining = descr->height % descr->item_height;
392 else
393 remaining = 0;
394 if ((descr->height > descr->item_height) && remaining)
395 {
396 if (is_old_app(descr))
397 { /* give a margin for error to 16 bits programs - if we need
398 less than the height of the nonclient area, round to the
399 *next* number of items */
400 int ncheight = rect.bottom - rect.top - descr->height;
401 if ((descr->item_height - remaining) <= ncheight)
402 remaining = remaining - descr->item_height;
403 }
404 TRACE("[%p]: changing height %d -> %d\n",
405 descr->self, descr->height, descr->height - remaining );
406 SetWindowPos( descr->self, 0, 0, 0, rect.right - rect.left,
407 rect.bottom - rect.top - remaining,
408 SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE );
409 return;
410 }
411 }
412 TRACE("[%p]: new size = %d,%d\n", descr->self, descr->width, descr->height );
413 LISTBOX_UpdatePage( descr );
414 LISTBOX_UpdateScroll( descr );
415
416 /* Invalidate the focused item so it will be repainted correctly */
417 if (LISTBOX_GetItemRect( descr, descr->focus_item, &rect ) == 1)
418 {
419 InvalidateRect( descr->self, &rect, FALSE );
420 }
421 }
422
423
424 /***********************************************************************
425 * LISTBOX_GetItemRect
426 *
427 * Get the rectangle enclosing an item, in listbox client coordinates.
428 * Return 1 if the rectangle is (partially) visible, 0 if hidden, -1 on error.
429 */
430 static LRESULT LISTBOX_GetItemRect( LB_DESCR *descr, INT index, RECT *rect )
431 {
432 /* Index <= 0 is legal even on empty listboxes */
433 if (index && (index >= descr->nb_items))
434 {
435 memset(rect, 0, sizeof(*rect));
436 SetLastError(ERROR_INVALID_INDEX);
437 return LB_ERR;
438 }
439 SetRect( rect, 0, 0, descr->width, descr->height );
440 if (descr->style & LBS_MULTICOLUMN)
441 {
442 INT col = (index / descr->page_size) -
443 (descr->top_item / descr->page_size);
444 rect->left += col * descr->column_width;
445 rect->right = rect->left + descr->column_width;
446 rect->top += (index % descr->page_size) * descr->item_height;
447 rect->bottom = rect->top + descr->item_height;
448 }
449 else if (descr->style & LBS_OWNERDRAWVARIABLE)
450 {
451 INT i;
452 rect->right += descr->horz_pos;
453 if ((index >= 0) && (index < descr->nb_items))
454 {
455 if (index < descr->top_item)
456 {
457 for (i = descr->top_item-1; i >= index; i--)
458 rect->top -= descr->items[i].height;
459 }
460 else
461 {
462 for (i = descr->top_item; i < index; i++)
463 rect->top += descr->items[i].height;
464 }
465 rect->bottom = rect->top + descr->items[index].height;
466
467 }
468 }
469 else
470 {
471 rect->top += (index - descr->top_item) * descr->item_height;
472 rect->bottom = rect->top + descr->item_height;
473 rect->right += descr->horz_pos;
474 }
475
476 return ((rect->left < descr->width) && (rect->right > 0) &&
477 (rect->top < descr->height) && (rect->bottom > 0));
478 }
479
480
481 /***********************************************************************
482 * LISTBOX_GetItemFromPoint
483 *
484 * Return the item nearest from point (x,y) (in client coordinates).
485 */
486 static INT LISTBOX_GetItemFromPoint( LB_DESCR *descr, INT x, INT y )
487 {
488 INT index = descr->top_item;
489
490 if (!descr->nb_items) return -1; /* No items */
491 if (descr->style & LBS_OWNERDRAWVARIABLE)
492 {
493 INT pos = 0;
494 if (y >= 0)
495 {
496 while (index < descr->nb_items)
497 {
498 if ((pos += descr->items[index].height) > y) break;
499 index++;
500 }
501 }
502 else
503 {
504 while (index > 0)
505 {
506 index--;
507 if ((pos -= descr->items[index].height) <= y) break;
508 }
509 }
510 }
511 else if (descr->style & LBS_MULTICOLUMN)
512 {
513 if (y >= descr->item_height * descr->page_size) return -1;
514 if (y >= 0) index += y / descr->item_height;
515 if (x >= 0) index += (x / descr->column_width) * descr->page_size;
516 else index -= (((x + 1) / descr->column_width) - 1) * descr->page_size;
517 }
518 else
519 {
520 index += (y / descr->item_height);
521 }
522 if (index < 0) return 0;
523 if (index >= descr->nb_items) return -1;
524 return index;
525 }
526
527
528 /***********************************************************************
529 * LISTBOX_PaintItem
530 *
531 * Paint an item.
532 */
533 static void LISTBOX_PaintItem( LB_DESCR *descr, HDC hdc, const RECT *rect,
534 INT index, UINT action, BOOL ignoreFocus )
535 {
536 LB_ITEMDATA *item = NULL;
537 if (index < descr->nb_items) item = &descr->items[index];
538
539 if (IS_OWNERDRAW(descr))
540 {
541 DRAWITEMSTRUCT dis;
542 RECT r;
543 HRGN hrgn;
544
545 if (!item)
546 {
547 if (action == ODA_FOCUS)
548 DrawFocusRect( hdc, rect );
549 else
550 ERR("called with an out of bounds index %d(%d) in owner draw, Not good.\n",index,descr->nb_items);
551 return;
552 }
553
554 /* some programs mess with the clipping region when
555 drawing the item, *and* restore the previous region
556 after they are done, so a region has better to exist
557 else everything ends clipped */
558 GetClientRect(descr->self, &r);
559 hrgn = CreateRectRgnIndirect(&r);
560 SelectClipRgn( hdc, hrgn);
561 DeleteObject( hrgn );
562
563 dis.CtlType = ODT_LISTBOX;
564 dis.CtlID = GetWindowLongPtrW( descr->self, GWLP_ID );
565 dis.hwndItem = descr->self;
566 dis.itemAction = action;
567 dis.hDC = hdc;
568 dis.itemID = index;
569 dis.itemState = 0;
570 if (item->selected) dis.itemState |= ODS_SELECTED;
571 if (!ignoreFocus && (descr->focus_item == index) &&
572 (descr->caret_on) &&
573 (descr->in_focus)) dis.itemState |= ODS_FOCUS;
574 if (!IsWindowEnabled(descr->self)) dis.itemState |= ODS_DISABLED;
575 dis.itemData = item->data;
576 dis.rcItem = *rect;
577 TRACE("[%p]: drawitem %d (%s) action=%02x state=%02x rect=%d,%d-%d,%d\n",
578 descr->self, index, item ? debugstr_w(item->str) : "", action,
579 dis.itemState, rect->left, rect->top, rect->right, rect->bottom );
580 SendMessageW(descr->owner, WM_DRAWITEM, dis.CtlID, (LPARAM)&dis);
581 }
582 else
583 {
584 COLORREF oldText = 0, oldBk = 0;
585
586 if (action == ODA_FOCUS)
587 {
588 DrawFocusRect( hdc, rect );
589 return;
590 }
591 if (item && item->selected)
592 {
593 oldBk = SetBkColor( hdc, GetSysColor( COLOR_HIGHLIGHT ) );
594 oldText = SetTextColor( hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
595 }
596
597 TRACE("[%p]: painting %d (%s) action=%02x rect=%d,%d-%d,%d\n",
598 descr->self, index, item ? debugstr_w(item->str) : "", action,
599 rect->left, rect->top, rect->right, rect->bottom );
600 if (!item)
601 ExtTextOutW( hdc, rect->left + 1, rect->top,
602 ETO_OPAQUE | ETO_CLIPPED, rect, NULL, 0, NULL );
603 else if (!(descr->style & LBS_USETABSTOPS))
604 ExtTextOutW( hdc, rect->left + 1, rect->top,
605 ETO_OPAQUE | ETO_CLIPPED, rect, item->str,
606 strlenW(item->str), NULL );
607 else
608 {
609 /* Output empty string to paint background in the full width. */
610 ExtTextOutW( hdc, rect->left + 1, rect->top,
611 ETO_OPAQUE | ETO_CLIPPED, rect, NULL, 0, NULL );
612 TabbedTextOutW( hdc, rect->left + 1 , rect->top,
613 item->str, strlenW(item->str),
614 descr->nb_tabs, descr->tabs, 0);
615 }
616 if (item && item->selected)
617 {
618 SetBkColor( hdc, oldBk );
619 SetTextColor( hdc, oldText );
620 }
621 if (!ignoreFocus && (descr->focus_item == index) &&
622 (descr->caret_on) &&
623 (descr->in_focus)) DrawFocusRect( hdc, rect );
624 }
625 }
626
627
628 /***********************************************************************
629 * LISTBOX_SetRedraw
630 *
631 * Change the redraw flag.
632 */
633 static void LISTBOX_SetRedraw( LB_DESCR *descr, BOOL on )
634 {
635 if (on)
636 {
637 if (!(descr->style & LBS_NOREDRAW)) return;
638 descr->style &= ~LBS_NOREDRAW;
639 if (descr->style & LBS_DISPLAYCHANGED)
640 { /* page was changed while setredraw false, refresh automatically */
641 InvalidateRect(descr->self, NULL, TRUE);
642 if ((descr->top_item + descr->page_size) > descr->nb_items)
643 { /* reset top of page if less than number of items/page */
644 descr->top_item = descr->nb_items - descr->page_size;
645 if (descr->top_item < 0) descr->top_item = 0;
646 }
647 descr->style &= ~LBS_DISPLAYCHANGED;
648 }
649 LISTBOX_UpdateScroll( descr );
650 }
651 else descr->style |= LBS_NOREDRAW;
652 }
653
654
655 /***********************************************************************
656 * LISTBOX_RepaintItem
657 *
658 * Repaint a single item synchronously.
659 */
660 static void LISTBOX_RepaintItem( LB_DESCR *descr, INT index, UINT action )
661 {
662 HDC hdc;
663 RECT rect;
664 HFONT oldFont = 0;
665 HBRUSH hbrush, oldBrush = 0;
666
667 /* Do not repaint the item if the item is not visible */
668 if (!IsWindowVisible(descr->self)) return;
669 if (descr->style & LBS_NOREDRAW)
670 {
671 descr->style |= LBS_DISPLAYCHANGED;
672 return;
673 }
674 if (LISTBOX_GetItemRect( descr, index, &rect ) != 1) return;
675 if (!(hdc = GetDCEx( descr->self, 0, DCX_CACHE ))) return;
676 if (descr->font) oldFont = SelectObject( hdc, descr->font );
677 hbrush = (HBRUSH)SendMessageW( descr->owner, WM_CTLCOLORLISTBOX,
678 (WPARAM)hdc, (LPARAM)descr->self );
679 if (hbrush) oldBrush = SelectObject( hdc, hbrush );
680 if (!IsWindowEnabled(descr->self))
681 SetTextColor( hdc, GetSysColor( COLOR_GRAYTEXT ) );
682 SetWindowOrgEx( hdc, descr->horz_pos, 0, NULL );
683 LISTBOX_PaintItem( descr, hdc, &rect, index, action, FALSE );
684 if (oldFont) SelectObject( hdc, oldFont );
685 if (oldBrush) SelectObject( hdc, oldBrush );
686 ReleaseDC( descr->self, hdc );
687 }
688
689
690 /***********************************************************************
691 * LISTBOX_InitStorage
692 */
693 static LRESULT LISTBOX_InitStorage( LB_DESCR *descr, INT nb_items )
694 {
695 LB_ITEMDATA *item;
696
697 nb_items += LB_ARRAY_GRANULARITY - 1;
698 nb_items -= (nb_items % LB_ARRAY_GRANULARITY);
699 if (descr->items) {
700 nb_items += HeapSize( GetProcessHeap(), 0, descr->items ) / sizeof(*item);
701 item = HeapReAlloc( GetProcessHeap(), 0, descr->items,
702 nb_items * sizeof(LB_ITEMDATA));
703 }
704 else {
705 item = HeapAlloc( GetProcessHeap(), 0,
706 nb_items * sizeof(LB_ITEMDATA));
707 }
708
709 if (!item)
710 {
711 SEND_NOTIFICATION( descr, LBN_ERRSPACE );
712 return LB_ERRSPACE;
713 }
714 descr->items = item;
715 return LB_OKAY;
716 }
717
718
719 /***********************************************************************
720 * LISTBOX_SetTabStops
721 */
722 static BOOL LISTBOX_SetTabStops( LB_DESCR *descr, INT count, LPINT tabs, BOOL short_ints )
723 {
724 INT i;
725
726 if (!(descr->style & LBS_USETABSTOPS))
727 {
728 SetLastError(ERROR_LB_WITHOUT_TABSTOPS);
729 return FALSE;
730 }
731
732 HeapFree( GetProcessHeap(), 0, descr->tabs );
733 if (!(descr->nb_tabs = count))
734 {
735 descr->tabs = NULL;
736 return TRUE;
737 }
738 if (!(descr->tabs = HeapAlloc( GetProcessHeap(), 0,
739 descr->nb_tabs * sizeof(INT) )))
740 return FALSE;
741 if (short_ints)
742 {
743 INT i;
744 LPINT16 p = (LPINT16)tabs;
745
746 TRACE("[%p]: settabstops ", descr->self );
747 for (i = 0; i < descr->nb_tabs; i++) {
748 descr->tabs[i] = *p++<<1; /* FIXME */
749 TRACE("%hd ", descr->tabs[i]);
750 }
751 TRACE("\n");
752 }
753 else memcpy( descr->tabs, tabs, descr->nb_tabs * sizeof(INT) );
754
755 /* convert into "dialog units"*/
756 for (i = 0; i < descr->nb_tabs; i++)
757 descr->tabs[i] = MulDiv(descr->tabs[i], descr->avg_char_width, 4);
758
759 return TRUE;
760 }
761
762
763 /***********************************************************************
764 * LISTBOX_GetText
765 */
766 static LRESULT LISTBOX_GetText( LB_DESCR *descr, INT index, LPWSTR buffer, BOOL unicode )
767 {
768 if ((index < 0) || (index >= descr->nb_items))
769 {
770 SetLastError(ERROR_INVALID_INDEX);
771 return LB_ERR;
772 }
773 if (HAS_STRINGS(descr))
774 {
775 if (!buffer)
776 {
777 DWORD len = strlenW(descr->items[index].str);
778 if( unicode )
779 return len;
780 return WideCharToMultiByte( CP_ACP, 0, descr->items[index].str, len,
781 NULL, 0, NULL, NULL );
782 }
783
784 TRACE("index %d (0x%04x) %s\n", index, index, debugstr_w(descr->items[index].str));
785
786 if(unicode)
787 {
788 strcpyW( buffer, descr->items[index].str );
789 return strlenW(buffer);
790 }
791 else
792 {
793 return WideCharToMultiByte(CP_ACP, 0, descr->items[index].str, -1, (LPSTR)buffer, 0x7FFFFFFF, NULL, NULL) - 1;
794 }
795 } else {
796 if (buffer)
797 *((LPDWORD)buffer)=*(LPDWORD)(&descr->items[index].data);
798 return sizeof(DWORD);
799 }
800 }
801
802 static inline INT LISTBOX_lstrcmpiW( LCID lcid, LPCWSTR str1, LPCWSTR str2 )
803 {
804 INT ret = CompareStringW( lcid, NORM_IGNORECASE, str1, -1, str2, -1 );
805 if (ret == CSTR_LESS_THAN)
806 return -1;
807 if (ret == CSTR_EQUAL)
808 return 0;
809 if (ret == CSTR_GREATER_THAN)
810 return 1;
811 return -1;
812 }
813
814 /***********************************************************************
815 * LISTBOX_FindStringPos
816 *
817 * Find the nearest string located before a given string in sort order.
818 * If 'exact' is TRUE, return an error if we don't get an exact match.
819 */
820 static INT LISTBOX_FindStringPos( LB_DESCR *descr, LPCWSTR str, BOOL exact )
821 {
822 INT index, min, max, res = -1;
823
824 if (!(descr->style & LBS_SORT)) return -1; /* Add it at the end */
825 min = 0;
826 max = descr->nb_items;
827 while (min != max)
828 {
829 index = (min + max) / 2;
830 if (HAS_STRINGS(descr))
831 res = LISTBOX_lstrcmpiW( descr->locale, str, descr->items[index].str);
832 else
833 {
834 COMPAREITEMSTRUCT cis;
835 UINT id = (UINT)GetWindowLongPtrW( descr->self, GWLP_ID );
836
837 cis.CtlType = ODT_LISTBOX;
838 cis.CtlID = id;
839 cis.hwndItem = descr->self;
840 /* note that some application (MetaStock) expects the second item
841 * to be in the listbox */
842 cis.itemID1 = -1;
843 cis.itemData1 = (ULONG_PTR)str;
844 cis.itemID2 = index;
845 cis.itemData2 = descr->items[index].data;
846 cis.dwLocaleId = descr->locale;
847 res = SendMessageW( descr->owner, WM_COMPAREITEM, id, (LPARAM)&cis );
848 }
849 if (!res) return index;
850 if (res < 0) max = index;
851 else min = index + 1;
852 }
853 return exact ? -1 : max;
854 }
855
856
857 /***********************************************************************
858 * LISTBOX_FindFileStrPos
859 *
860 * Find the nearest string located before a given string in directory
861 * sort order (i.e. first files, then directories, then drives).
862 */
863 static INT LISTBOX_FindFileStrPos( LB_DESCR *descr, LPCWSTR str )
864 {
865 INT min, max, res = -1;
866
867 if (!HAS_STRINGS(descr))
868 return LISTBOX_FindStringPos( descr, str, FALSE );
869 min = 0;
870 max = descr->nb_items;
871 while (min != max)
872 {
873 INT index = (min + max) / 2;
874 LPCWSTR p = descr->items[index].str;
875 if (*p == '[') /* drive or directory */
876 {
877 if (*str != '[') res = -1;
878 else if (p[1] == '-') /* drive */
879 {
880 if (str[1] == '-') res = str[2] - p[2];
881 else res = -1;
882 }
883 else /* directory */
884 {
885 if (str[1] == '-') res = 1;
886 else res = LISTBOX_lstrcmpiW( descr->locale, str, p );
887 }
888 }
889 else /* filename */
890 {
891 if (*str == '[') res = 1;
892 else res = LISTBOX_lstrcmpiW( descr->locale, str, p );
893 }
894 if (!res) return index;
895 if (res < 0) max = index;
896 else min = index + 1;
897 }
898 return max;
899 }
900
901
902 /***********************************************************************
903 * LISTBOX_FindString
904 *
905 * Find the item beginning with a given string.
906 */
907 static INT LISTBOX_FindString( LB_DESCR *descr, INT start, LPCWSTR str, BOOL exact )
908 {
909 INT i;
910 LB_ITEMDATA *item;
911
912 if (start >= descr->nb_items) start = -1;
913 item = descr->items + start + 1;
914 if (HAS_STRINGS(descr))
915 {
916 if (!str || ! str[0] ) return LB_ERR;
917 if (exact)
918 {
919 for (i = start + 1; i < descr->nb_items; i++, item++)
920 if (!LISTBOX_lstrcmpiW( descr->locale, str, item->str )) return i;
921 for (i = 0, item = descr->items; i <= start; i++, item++)
922 if (!LISTBOX_lstrcmpiW( descr->locale, str, item->str )) return i;
923 }
924 else
925 {
926 /* Special case for drives and directories: ignore prefix */
927 #define CHECK_DRIVE(item) \
928 if ((item)->str[0] == '[') \
929 { \
930 if (!strncmpiW( str, (item)->str+1, len )) return i; \
931 if (((item)->str[1] == '-') && !strncmpiW(str, (item)->str+2, len)) \
932 return i; \
933 }
934
935 INT len = strlenW(str);
936 for (i = start + 1; i < descr->nb_items; i++, item++)
937 {
938 if (!strncmpiW( str, item->str, len )) return i;
939 CHECK_DRIVE(item);
940 }
941 for (i = 0, item = descr->items; i <= start; i++, item++)
942 {
943 if (!strncmpiW( str, item->str, len )) return i;
944 CHECK_DRIVE(item);
945 }
946 #undef CHECK_DRIVE
947 }
948 }
949 else
950 {
951 if (exact && (descr->style & LBS_SORT))
952 /* If sorted, use a WM_COMPAREITEM binary search */
953 return LISTBOX_FindStringPos( descr, str, TRUE );
954
955 /* Otherwise use a linear search */
956 for (i = start + 1; i < descr->nb_items; i++, item++)
957 if (item->data == (ULONG_PTR)str) return i;
958 for (i = 0, item = descr->items; i <= start; i++, item++)
959 if (item->data == (ULONG_PTR)str) return i;
960 }
961 return LB_ERR;
962 }
963
964
965 /***********************************************************************
966 * LISTBOX_GetSelCount
967 */
968 static LRESULT LISTBOX_GetSelCount( LB_DESCR *descr )
969 {
970 INT i, count;
971 LB_ITEMDATA *item = descr->items;
972
973 if (!(descr->style & LBS_MULTIPLESEL) ||
974 (descr->style & LBS_NOSEL))
975 return LB_ERR;
976 for (i = count = 0; i < descr->nb_items; i++, item++)
977 if (item->selected) count++;
978 return count;
979 }
980
981
982 /***********************************************************************
983 * LISTBOX_GetSelItems16
984 */
985 static LRESULT LISTBOX_GetSelItems16( LB_DESCR *descr, INT16 max, LPINT16 array )
986 {
987 INT i, count;
988 LB_ITEMDATA *item = descr->items;
989
990 if (!(descr->style & LBS_MULTIPLESEL)) return LB_ERR;
991 for (i = count = 0; (i < descr->nb_items) && (count < max); i++, item++)
992 if (item->selected) array[count++] = (INT16)i;
993 return count;
994 }
995
996
997 /***********************************************************************
998 * LISTBOX_GetSelItems
999 */
1000 static LRESULT LISTBOX_GetSelItems( LB_DESCR *descr, INT max, LPINT array )
1001 {
1002 INT i, count;
1003 LB_ITEMDATA *item = descr->items;
1004
1005 if (!(descr->style & LBS_MULTIPLESEL)) return LB_ERR;
1006 for (i = count = 0; (i < descr->nb_items) && (count < max); i++, item++)
1007 if (item->selected) array[count++] = i;
1008 return count;
1009 }
1010
1011
1012 /***********************************************************************
1013 * LISTBOX_Paint
1014 */
1015 static LRESULT LISTBOX_Paint( LB_DESCR *descr, HDC hdc )
1016 {
1017 INT i, col_pos = descr->page_size - 1;
1018 RECT rect;
1019 RECT focusRect = {-1, -1, -1, -1};
1020 HFONT oldFont = 0;
1021 HBRUSH hbrush, oldBrush = 0;
1022
1023 if (descr->style & LBS_NOREDRAW) return 0;
1024
1025 SetRect( &rect, 0, 0, descr->width, descr->height );
1026 if (descr->style & LBS_MULTICOLUMN)
1027 rect.right = rect.left + descr->column_width;
1028 else if (descr->horz_pos)
1029 {
1030 SetWindowOrgEx( hdc, descr->horz_pos, 0, NULL );
1031 rect.right += descr->horz_pos;
1032 }
1033
1034 if (descr->font) oldFont = SelectObject( hdc, descr->font );
1035 hbrush = (HBRUSH)SendMessageW( descr->owner, WM_CTLCOLORLISTBOX,
1036 (WPARAM)hdc, (LPARAM)descr->self );
1037 if (hbrush) oldBrush = SelectObject( hdc, hbrush );
1038 if (!IsWindowEnabled(descr->self)) SetTextColor( hdc, GetSysColor( COLOR_GRAYTEXT ) );
1039
1040 if (!descr->nb_items && (descr->focus_item != -1) && descr->caret_on &&
1041 (descr->in_focus))
1042 {
1043 /* Special case for empty listbox: paint focus rect */
1044 rect.bottom = rect.top + descr->item_height;
1045 ExtTextOutW( hdc, 0, 0, ETO_OPAQUE | ETO_CLIPPED,
1046 &rect, NULL, 0, NULL );
1047 LISTBOX_PaintItem( descr, hdc, &rect, descr->focus_item, ODA_FOCUS, FALSE );
1048 rect.top = rect.bottom;
1049 }
1050
1051 /* Paint all the item, regarding the selection
1052 Focus state will be painted after */
1053
1054 for (i = descr->top_item; i < descr->nb_items; i++)
1055 {
1056 if (!(descr->style & LBS_OWNERDRAWVARIABLE))
1057 rect.bottom = rect.top + descr->item_height;
1058 else
1059 rect.bottom = rect.top + descr->items[i].height;
1060
1061 if (i == descr->focus_item)
1062 {
1063 /* keep the focus rect, to paint the focus item after */
1064 focusRect.left = rect.left;
1065 focusRect.right = rect.right;
1066 focusRect.top = rect.top;
1067 focusRect.bottom = rect.bottom;
1068 }
1069 LISTBOX_PaintItem( descr, hdc, &rect, i, ODA_DRAWENTIRE, TRUE );
1070 rect.top = rect.bottom;
1071
1072 if ((descr->style & LBS_MULTICOLUMN) && !col_pos)
1073 {
1074 if (!IS_OWNERDRAW(descr))
1075 {
1076 /* Clear the bottom of the column */
1077 if (rect.top < descr->height)
1078 {
1079 rect.bottom = descr->height;
1080 ExtTextOutW( hdc, 0, 0, ETO_OPAQUE | ETO_CLIPPED,
1081 &rect, NULL, 0, NULL );
1082 }
1083 }
1084
1085 /* Go to the next column */
1086 rect.left += descr->column_width;
1087 rect.right += descr->column_width;
1088 rect.top = 0;
1089 col_pos = descr->page_size - 1;
1090 }
1091 else
1092 {
1093 col_pos--;
1094 if (rect.top >= descr->height) break;
1095 }
1096 }
1097
1098 /* Paint the focus item now */
1099 if (focusRect.top != focusRect.bottom &&
1100 descr->caret_on && descr->in_focus)
1101 LISTBOX_PaintItem( descr, hdc, &focusRect, descr->focus_item, ODA_FOCUS, FALSE );
1102
1103 if (!IS_OWNERDRAW(descr))
1104 {
1105 /* Clear the remainder of the client area */
1106 if (rect.top < descr->height)
1107 {
1108 rect.bottom = descr->height;
1109 ExtTextOutW( hdc, 0, 0, ETO_OPAQUE | ETO_CLIPPED,
1110 &rect, NULL, 0, NULL );
1111 }
1112 if (rect.right < descr->width)
1113 {
1114 rect.left = rect.right;
1115 rect.right = descr->width;
1116 rect.top = 0;
1117 rect.bottom = descr->height;
1118 ExtTextOutW( hdc, 0, 0, ETO_OPAQUE | ETO_CLIPPED,
1119 &rect, NULL, 0, NULL );
1120 }
1121 }
1122 if (oldFont) SelectObject( hdc, oldFont );
1123 if (oldBrush) SelectObject( hdc, oldBrush );
1124 return 0;
1125 }
1126
1127
1128 /***********************************************************************
1129 * LISTBOX_InvalidateItems
1130 *
1131 * Invalidate all items from a given item. If the specified item is not
1132 * visible, nothing happens.
1133 */
1134 static void LISTBOX_InvalidateItems( LB_DESCR *descr, INT index )
1135 {
1136 RECT rect;
1137
1138 if (LISTBOX_GetItemRect( descr, index, &rect ) == 1)
1139 {
1140 if (descr->style & LBS_NOREDRAW)
1141 {
1142 descr->style |= LBS_DISPLAYCHANGED;
1143 return;
1144 }
1145 rect.bottom = descr->height;
1146 InvalidateRect( descr->self, &rect, TRUE );
1147 if (descr->style & LBS_MULTICOLUMN)
1148 {
1149 /* Repaint the other columns */
1150 rect.left = rect.right;
1151 rect.right = descr->width;
1152 rect.top = 0;
1153 InvalidateRect( descr->self, &rect, TRUE );
1154 }
1155 }
1156 }
1157
1158 static void LISTBOX_InvalidateItemRect( LB_DESCR *descr, INT index )
1159 {
1160 RECT rect;
1161
1162 if (LISTBOX_GetItemRect( descr, index, &rect ) == 1)
1163 InvalidateRect( descr->self, &rect, TRUE );
1164 }
1165
1166 /***********************************************************************
1167 * LISTBOX_GetItemHeight
1168 */
1169 static LRESULT LISTBOX_GetItemHeight( LB_DESCR *descr, INT index )
1170 {
1171 if (descr->style & LBS_OWNERDRAWVARIABLE && descr->nb_items > 0)
1172 {
1173 if ((index < 0) || (index >= descr->nb_items))
1174 {
1175 SetLastError(ERROR_INVALID_INDEX);
1176 return LB_ERR;
1177 }
1178 return descr->items[index].height;
1179 }
1180 else return descr->item_height;
1181 }
1182
1183
1184 /***********************************************************************
1185 * LISTBOX_SetItemHeight
1186 */
1187 static LRESULT LISTBOX_SetItemHeight( LB_DESCR *descr, INT index, INT height, BOOL repaint )
1188 {
1189 if (height > MAXBYTE)
1190 return -1;
1191
1192 if (!height) height = 1;
1193
1194 if (descr->style & LBS_OWNERDRAWVARIABLE)
1195 {
1196 if ((index < 0) || (index >= descr->nb_items))
1197 {
1198 SetLastError(ERROR_INVALID_INDEX);
1199 return LB_ERR;
1200 }
1201 TRACE("[%p]: item %d height = %d\n", descr->self, index, height );
1202 descr->items[index].height = height;
1203 LISTBOX_UpdateScroll( descr );
1204 if (repaint)
1205 LISTBOX_InvalidateItems( descr, index );
1206 }
1207 else if (height != descr->item_height)
1208 {
1209 TRACE("[%p]: new height = %d\n", descr->self, height );
1210 descr->item_height = height;
1211 LISTBOX_UpdatePage( descr );
1212 LISTBOX_UpdateScroll( descr );
1213 if (repaint)
1214 InvalidateRect( descr->self, 0, TRUE );
1215 }
1216 return LB_OKAY;
1217 }
1218
1219
1220 /***********************************************************************
1221 * LISTBOX_SetHorizontalPos
1222 */
1223 static void LISTBOX_SetHorizontalPos( LB_DESCR *descr, INT pos )
1224 {
1225 INT diff;
1226
1227 if (pos > descr->horz_extent - descr->width)
1228 pos = descr->horz_extent - descr->width;
1229 if (pos < 0) pos = 0;
1230 if (!(diff = descr->horz_pos - pos)) return;
1231 TRACE("[%p]: new horz pos = %d\n", descr->self, pos );
1232 descr->horz_pos = pos;
1233 LISTBOX_UpdateScroll( descr );
1234 if (abs(diff) < descr->width)
1235 {
1236 RECT rect;
1237 /* Invalidate the focused item so it will be repainted correctly */
1238 if (LISTBOX_GetItemRect( descr, descr->focus_item, &rect ) == 1)
1239 InvalidateRect( descr->self, &rect, TRUE );
1240 ScrollWindowEx( descr->self, diff, 0, NULL, NULL, 0, NULL,
1241 SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN );
1242 }
1243 else
1244 InvalidateRect( descr->self, NULL, TRUE );
1245 }
1246
1247
1248 /***********************************************************************
1249 * LISTBOX_SetHorizontalExtent
1250 */
1251 static LRESULT LISTBOX_SetHorizontalExtent( LB_DESCR *descr, INT extent )
1252 {
1253 if (!descr->horz_extent || (descr->style & LBS_MULTICOLUMN))
1254 return LB_OKAY;
1255 if (extent <= 0) extent = 1;
1256 if (extent == descr->horz_extent) return LB_OKAY;
1257 TRACE("[%p]: new horz extent = %d\n", descr->self, extent );
1258 descr->horz_extent = extent;
1259 if (descr->horz_pos > extent - descr->width)
1260 LISTBOX_SetHorizontalPos( descr, extent - descr->width );
1261 else
1262 LISTBOX_UpdateScroll( descr );
1263 return LB_OKAY;
1264 }
1265
1266
1267 /***********************************************************************
1268 * LISTBOX_SetColumnWidth
1269 */
1270 static LRESULT LISTBOX_SetColumnWidth( LB_DESCR *descr, INT width)
1271 {
1272 if (width == descr->column_width) return LB_OKAY;
1273 TRACE("[%p]: new column width = %d\n", descr->self, width );
1274 descr->column_width = width;
1275 LISTBOX_UpdatePage( descr );
1276 return LB_OKAY;
1277 }
1278
1279
1280 /***********************************************************************
1281 * LISTBOX_SetFont
1282 *
1283 * Returns the item height.
1284 */
1285 static INT LISTBOX_SetFont( LB_DESCR *descr, HFONT font )
1286 {
1287 HDC hdc;
1288 HFONT oldFont = 0;
1289 const char *alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
1290 SIZE sz;
1291
1292 descr->font = font;
1293
1294 if (!(hdc = GetDCEx( descr->self, 0, DCX_CACHE )))
1295 {
1296 ERR("unable to get DC.\n" );
1297 return 16;
1298 }
1299 if (font) oldFont = SelectObject( hdc, font );
1300 GetTextExtentPointA( hdc, alphabet, 52, &sz);
1301 if (oldFont) SelectObject( hdc, oldFont );
1302 ReleaseDC( descr->self, hdc );
1303
1304 descr->avg_char_width = (sz.cx / 26 + 1) / 2;
1305 if (!IS_OWNERDRAW(descr))
1306 LISTBOX_SetItemHeight( descr, 0, sz.cy, FALSE );
1307 return sz.cy;
1308 }
1309
1310
1311 /***********************************************************************
1312 * LISTBOX_MakeItemVisible
1313 *
1314 * Make sure that a given item is partially or fully visible.
1315 */
1316 static void LISTBOX_MakeItemVisible( LB_DESCR *descr, INT index, BOOL fully )
1317 {
1318 INT top;
1319
1320 if (index <= descr->top_item) top = index;
1321 else if (descr->style & LBS_MULTICOLUMN)
1322 {
1323 INT cols = descr->width;
1324 if (!fully) cols += descr->column_width - 1;
1325 if (cols >= descr->column_width) cols /= descr->column_width;
1326 else cols = 1;
1327 if (index < descr->top_item + (descr->page_size * cols)) return;
1328 top = index - descr->page_size * (cols - 1);
1329 }
1330 else if (descr->style & LBS_OWNERDRAWVARIABLE)
1331 {
1332 INT height = fully ? descr->items[index].height : 1;
1333 for (top = index; top > descr->top_item; top--)
1334 if ((height += descr->items[top-1].height) > descr->height) break;
1335 }
1336 else
1337 {
1338 if (index < descr->top_item + descr->page_size) return;
1339 if (!fully && (index == descr->top_item + descr->page_size) &&
1340 (descr->height > (descr->page_size * descr->item_height))) return;
1341 top = index - descr->page_size + 1;
1342 }
1343 LISTBOX_SetTopItem( descr, top, TRUE );
1344 }
1345
1346 /***********************************************************************
1347 * LISTBOX_SetCaretIndex
1348 *
1349 * NOTES
1350 * index must be between 0 and descr->nb_items-1, or LB_ERR is returned.
1351 *
1352 */
1353 static LRESULT LISTBOX_SetCaretIndex( LB_DESCR *descr, INT index, BOOL fully_visible )
1354 {
1355 INT oldfocus = descr->focus_item;
1356
1357 if (descr->style & LBS_NOSEL) return LB_ERR;
1358 if ((index < 0) || (index >= descr->nb_items)) return LB_ERR;
1359 if (index == oldfocus) return LB_OKAY;
1360 descr->focus_item = index;
1361 if ((oldfocus != -1) && descr->caret_on && (descr->in_focus))
1362 LISTBOX_RepaintItem( descr, oldfocus, ODA_FOCUS );
1363
1364 LISTBOX_MakeItemVisible( descr, index, fully_visible );
1365 if (descr->caret_on && (descr->in_focus))
1366 LISTBOX_RepaintItem( descr, index, ODA_FOCUS );
1367
1368 return LB_OKAY;
1369 }
1370
1371
1372 /***********************************************************************
1373 * LISTBOX_SelectItemRange
1374 *
1375 * Select a range of items. Should only be used on a MULTIPLESEL listbox.
1376 */
1377 static LRESULT LISTBOX_SelectItemRange( LB_DESCR *descr, INT first,
1378 INT last, BOOL on )
1379 {
1380 INT i;
1381
1382 /* A few sanity checks */
1383
1384 if (descr->style & LBS_NOSEL) return LB_ERR;
1385 if (!(descr->style & LBS_MULTIPLESEL)) return LB_ERR;
1386
1387 if (!descr->nb_items) return LB_OKAY;
1388
1389 if (last == -1 || last >= descr->nb_items) last = descr->nb_items - 1;
1390 if (first < 0) first = 0;
1391 if (last < first) return LB_OKAY;
1392
1393 if (on) /* Turn selection on */
1394 {
1395 for (i = first; i <= last; i++)
1396 {
1397 if (descr->items[i].selected) continue;
1398 descr->items[i].selected = TRUE;
1399 LISTBOX_InvalidateItemRect(descr, i);
1400 }
1401 }
1402 else /* Turn selection off */
1403 {
1404 for (i = first; i <= last; i++)
1405 {
1406 if (!descr->items[i].selected) continue;
1407 descr->items[i].selected = FALSE;
1408 LISTBOX_InvalidateItemRect(descr, i);
1409 }
1410 }
1411 return LB_OKAY;
1412 }
1413
1414 /***********************************************************************
1415 * LISTBOX_SetSelection
1416 */
1417 static LRESULT LISTBOX_SetSelection( LB_DESCR *descr, INT index,
1418 BOOL on, BOOL send_notify )
1419 {
1420 TRACE( "cur_sel=%d index=%d notify=%s\n",
1421 descr->selected_item, index, send_notify ? "YES" : "NO" );
1422
1423 if (descr->style & LBS_NOSEL)
1424 {
1425 descr->selected_item = index;
1426 return LB_ERR;
1427 }
1428 if ((index < -1) || (index >= descr->nb_items)) return LB_ERR;
1429 if (descr->style & LBS_MULTIPLESEL)
1430 {
1431 if (index == -1) /* Select all items */
1432 return LISTBOX_SelectItemRange( descr, 0, descr->nb_items, on );
1433 else /* Only one item */
1434 return LISTBOX_SelectItemRange( descr, index, index, on );
1435 }
1436 else
1437 {
1438 INT oldsel = descr->selected_item;
1439 if (index == oldsel) return LB_OKAY;
1440 if (oldsel != -1) descr->items[oldsel].selected = FALSE;
1441 if (index != -1) descr->items[index].selected = TRUE;
1442 descr->selected_item = index;
1443 if (oldsel != -1) LISTBOX_RepaintItem( descr, oldsel, ODA_SELECT );
1444 if (index != -1) LISTBOX_RepaintItem( descr, index, ODA_SELECT );
1445 if (send_notify && descr->nb_items) SEND_NOTIFICATION( descr,
1446 (index != -1) ? LBN_SELCHANGE : LBN_SELCANCEL );
1447 else
1448 if( descr->lphc ) /* set selection change flag for parent combo */
1449 descr->lphc->wState |= CBF_SELCHANGE;
1450 }
1451 return LB_OKAY;
1452 }
1453
1454
1455 /***********************************************************************
1456 * LISTBOX_MoveCaret
1457 *
1458 * Change the caret position and extend the selection to the new caret.
1459 */
1460 static void LISTBOX_MoveCaret( LB_DESCR *descr, INT index, BOOL fully_visible )
1461 {
1462 INT oldfocus = descr->focus_item;
1463
1464 if ((index < 0) || (index >= descr->nb_items))
1465 return;
1466
1467 /* Important, repaint needs to be done in this order if
1468 you want to mimic Windows behavior:
1469 1. Remove the focus and paint the item
1470 2. Remove the selection and paint the item(s)
1471 3. Set the selection and repaint the item(s)
1472 4. Set the focus to 'index' and repaint the item */
1473
1474 /* 1. remove the focus and repaint the item */
1475 descr->focus_item = -1;
1476 if ((oldfocus != -1) && descr->caret_on && (descr->in_focus))
1477 LISTBOX_RepaintItem( descr, oldfocus, ODA_FOCUS );
1478
1479 /* 2. then turn off the previous selection */
1480 /* 3. repaint the new selected item */
1481 if (descr->style & LBS_EXTENDEDSEL)
1482 {
1483 if (descr->anchor_item != -1)
1484 {
1485 INT first = min( index, descr->anchor_item );
1486 INT last = max( index, descr->anchor_item );
1487 if (first > 0)
1488 LISTBOX_SelectItemRange( descr, 0, first - 1, FALSE );
1489 LISTBOX_SelectItemRange( descr, last + 1, -1, FALSE );
1490 LISTBOX_SelectItemRange( descr, first, last, TRUE );
1491 }
1492 }
1493 else if (!(descr->style & LBS_MULTIPLESEL))
1494 {
1495 /* Set selection to new caret item */
1496 LISTBOX_SetSelection( descr, index, TRUE, FALSE );
1497 }
1498
1499 /* 4. repaint the new item with the focus */
1500 descr->focus_item = index;
1501 LISTBOX_MakeItemVisible( descr, index, fully_visible );
1502 if (descr->caret_on && (descr->in_focus))
1503 LISTBOX_RepaintItem( descr, index, ODA_FOCUS );
1504 }
1505
1506
1507 /***********************************************************************
1508 * LISTBOX_InsertItem
1509 */
1510 static LRESULT LISTBOX_InsertItem( LB_DESCR *descr, INT index,
1511 LPWSTR str, ULONG_PTR data )
1512 {
1513 LB_ITEMDATA *item;
1514 INT max_items;
1515 INT oldfocus = descr->focus_item;
1516
1517 if (index == -1) index = descr->nb_items;
1518 else if ((index < 0) || (index > descr->nb_items)) return LB_ERR;
1519 if (!descr->items) max_items = 0;
1520 else max_items = HeapSize( GetProcessHeap(), 0, descr->items ) / sizeof(*item);
1521 if (descr->nb_items == max_items)
1522 {
1523 /* We need to grow the array */
1524 max_items += LB_ARRAY_GRANULARITY;
1525 if (descr->items)
1526 item = HeapReAlloc( GetProcessHeap(), 0, descr->items,
1527 max_items * sizeof(LB_ITEMDATA) );
1528 else
1529 item = HeapAlloc( GetProcessHeap(), 0,
1530 max_items * sizeof(LB_ITEMDATA) );
1531 if (!item)
1532 {
1533 SEND_NOTIFICATION( descr, LBN_ERRSPACE );
1534 return LB_ERRSPACE;
1535 }
1536 descr->items = item;
1537 }
1538
1539 /* Insert the item structure */
1540
1541 item = &descr->items[index];
1542 if (index < descr->nb_items)
1543 RtlMoveMemory( item + 1, item,
1544 (descr->nb_items - index) * sizeof(LB_ITEMDATA) );
1545 item->str = str;
1546 item->data = data;
1547 item->height = 0;
1548 item->selected = FALSE;
1549 descr->nb_items++;
1550
1551 /* Get item height */
1552
1553 if (descr->style & LBS_OWNERDRAWVARIABLE)
1554 {
1555 MEASUREITEMSTRUCT mis;
1556 UINT id = (UINT)GetWindowLongPtrW( descr->self, GWLP_ID );
1557
1558 mis.CtlType = ODT_LISTBOX;
1559 mis.CtlID = id;
1560 mis.itemID = index;
1561 mis.itemData = descr->items[index].data;
1562 mis.itemHeight = descr->item_height;
1563 SendMessageW( descr->owner, WM_MEASUREITEM, id, (LPARAM)&mis );
1564 item->height = mis.itemHeight ? mis.itemHeight : 1;
1565 TRACE("[%p]: measure item %d (%s) = %d\n",
1566 descr->self, index, str ? debugstr_w(str) : "", item->height );
1567 }
1568
1569 /* Repaint the items */
1570
1571 LISTBOX_UpdateScroll( descr );
1572 LISTBOX_InvalidateItems( descr, index );
1573
1574 /* Move selection and focused item */
1575 /* If listbox was empty, set focus to the first item */
1576 if (descr->nb_items == 1)
1577 LISTBOX_SetCaretIndex( descr, 0, FALSE );
1578 /* single select don't change selection index in win31 */
1579 else if ((ISWIN31) && !(IS_MULTISELECT(descr)))
1580 {
1581 descr->selected_item++;
1582 LISTBOX_SetSelection( descr, descr->selected_item-1, TRUE, FALSE );
1583 }
1584 else
1585 {
1586 if (index <= descr->selected_item)
1587 {
1588 descr->selected_item++;
1589 descr->focus_item = oldfocus; /* focus not changed */
1590 }
1591 }
1592 return LB_OKAY;
1593 }
1594
1595
1596 /***********************************************************************
1597 * LISTBOX_InsertString
1598 */
1599 static LRESULT LISTBOX_InsertString( LB_DESCR *descr, INT index, LPCWSTR str )
1600 {
1601 LPWSTR new_str = NULL;
1602 ULONG_PTR data = 0;
1603 LRESULT ret;
1604
1605 if (HAS_STRINGS(descr))
1606 {
1607 static const WCHAR empty_stringW[] = { 0 };
1608 if (!str) str = empty_stringW;
1609 if (!(new_str = HeapAlloc( GetProcessHeap(), 0, (strlenW(str) + 1) * sizeof(WCHAR) )))
1610 {
1611 SEND_NOTIFICATION( descr, LBN_ERRSPACE );
1612 return LB_ERRSPACE;
1613 }
1614 strcpyW(new_str, str);
1615 }
1616 else data = (ULONG_PTR)str;
1617
1618 if (index == -1) index = descr->nb_items;
1619 if ((ret = LISTBOX_InsertItem( descr, index, new_str, data )) != 0)
1620 {
1621 HeapFree( GetProcessHeap(), 0, new_str );
1622 return ret;
1623 }
1624
1625 TRACE("[%p]: added item %d %s\n",
1626 descr->self, index, HAS_STRINGS(descr) ? debugstr_w(new_str) : "" );
1627 return index;
1628 }
1629
1630
1631 /***********************************************************************
1632 * LISTBOX_DeleteItem
1633 *
1634 * Delete the content of an item. 'index' must be a valid index.
1635 */
1636 static void LISTBOX_DeleteItem( LB_DESCR *descr, INT index )
1637 {
1638 /* Note: Win 3.1 only sends DELETEITEM on owner-draw items,
1639 * while Win95 sends it for all items with user data.
1640 * It's probably better to send it too often than not
1641 * often enough, so this is what we do here.
1642 */
1643 if (IS_OWNERDRAW(descr) || descr->items[index].data)
1644 {
1645 DELETEITEMSTRUCT dis;
1646 UINT id = (UINT)GetWindowLongPtrW( descr->self, GWLP_ID );
1647
1648 dis.CtlType = ODT_LISTBOX;
1649 dis.CtlID = id;
1650 dis.itemID = index;
1651 dis.hwndItem = descr->self;
1652 dis.itemData = descr->items[index].data;
1653 SendMessageW( descr->owner, WM_DELETEITEM, id, (LPARAM)&dis );
1654 }
1655 if (HAS_STRINGS(descr))
1656 HeapFree( GetProcessHeap(), 0, descr->items[index].str );
1657 }
1658
1659
1660 /***********************************************************************
1661 * LISTBOX_RemoveItem
1662 *
1663 * Remove an item from the listbox and delete its content.
1664 */
1665 static LRESULT LISTBOX_RemoveItem( LB_DESCR *descr, INT index )
1666 {
1667 LB_ITEMDATA *item;
1668 INT max_items;
1669
1670 if ((index < 0) || (index >= descr->nb_items)) return LB_ERR;
1671
1672 /* We need to invalidate the original rect instead of the updated one. */
1673 LISTBOX_InvalidateItems( descr, index );
1674
1675 LISTBOX_DeleteItem( descr, index );
1676
1677 /* Remove the item */
1678
1679 item = &descr->items[index];
1680 if (index < descr->nb_items-1)
1681 RtlMoveMemory( item, item + 1,
1682 (descr->nb_items - index - 1) * sizeof(LB_ITEMDATA) );
1683 descr->nb_items--;
1684 if (descr->anchor_item == descr->nb_items) descr->anchor_item--;
1685
1686 /* Shrink the item array if possible */
1687
1688 max_items = HeapSize( GetProcessHeap(), 0, descr->items ) / sizeof(LB_ITEMDATA);
1689 if (descr->nb_items < max_items - 2*LB_ARRAY_GRANULARITY)
1690 {
1691 max_items -= LB_ARRAY_GRANULARITY;
1692 item = HeapReAlloc( GetProcessHeap(), 0, descr->items,
1693 max_items * sizeof(LB_ITEMDATA) );
1694 if (item) descr->items = item;
1695 }
1696 /* Repaint the items */
1697
1698 LISTBOX_UpdateScroll( descr );
1699 /* if we removed the scrollbar, reset the top of the list
1700 (correct for owner-drawn ???) */
1701 if (descr->nb_items == descr->page_size)
1702 LISTBOX_SetTopItem( descr, 0, TRUE );
1703
1704 /* Move selection and focused item */
1705 if (!IS_MULTISELECT(descr))
1706 {
1707 if (index == descr->selected_item)
1708 descr->selected_item = -1;
1709 else if (index < descr->selected_item)
1710 {
1711 descr->selected_item--;
1712 if (ISWIN31) /* win 31 do not change the selected item number */
1713 LISTBOX_SetSelection( descr, descr->selected_item + 1, TRUE, FALSE);
1714 }
1715 }
1716
1717 if (descr->focus_item >= descr->nb_items)
1718 {
1719 descr->focus_item = descr->nb_items - 1;
1720 if (descr->focus_item < 0) descr->focus_item = 0;
1721 }
1722 return LB_OKAY;
1723 }
1724
1725
1726 /***********************************************************************
1727 * LISTBOX_ResetContent
1728 */
1729 static void LISTBOX_ResetContent( LB_DESCR *descr )
1730 {
1731 INT i;
1732
1733 for(i = descr->nb_items - 1; i>=0; i--) LISTBOX_DeleteItem( descr, i);
1734 HeapFree( GetProcessHeap(), 0, descr->items );
1735 descr->nb_items = 0;
1736 descr->top_item = 0;
1737 descr->selected_item = -1;
1738 descr->focus_item = 0;
1739 descr->anchor_item = -1;
1740 descr->items = NULL;
1741 }
1742
1743
1744 /***********************************************************************
1745 * LISTBOX_SetCount
1746 */
1747 static LRESULT LISTBOX_SetCount( LB_DESCR *descr, INT count )
1748 {
1749 LRESULT ret;
1750
1751 if (HAS_STRINGS(descr))
1752 {
1753 SetLastError(ERROR_SETCOUNT_ON_BAD_LB);
1754 return LB_ERR;
1755 }
1756
1757 /* FIXME: this is far from optimal... */
1758 if (count > descr->nb_items)
1759 {
1760 while (count > descr->nb_items)
1761 if ((ret = LISTBOX_InsertString( descr, -1, 0 )) < 0)
1762 return ret;
1763 }
1764 else if (count < descr->nb_items)
1765 {
1766 while (count < descr->nb_items)
1767 if ((ret = LISTBOX_RemoveItem( descr, (descr->nb_items - 1) )) < 0)
1768 return ret;
1769 }
1770 return LB_OKAY;
1771 }
1772
1773
1774 /***********************************************************************
1775 * LISTBOX_Directory
1776 */
1777 static LRESULT LISTBOX_Directory( LB_DESCR *descr, UINT attrib,
1778 LPCWSTR filespec, BOOL long_names )
1779 {
1780 HANDLE handle;
1781 LRESULT ret = LB_OKAY;
1782 WIN32_FIND_DATAW entry;
1783 int pos;
1784
1785 /* don't scan directory if we just want drives exclusively */
1786 if (attrib != (DDL_DRIVES | DDL_EXCLUSIVE)) {
1787 /* scan directory */
1788 if ((handle = FindFirstFileW(filespec, &entry)) == INVALID_HANDLE_VALUE)
1789 {
1790 int le = GetLastError();
1791 if ((le != ERROR_NO_MORE_FILES) && (le != ERROR_FILE_NOT_FOUND)) return LB_ERR;
1792 }
1793 else
1794 {
1795 do
1796 {
1797 WCHAR buffer[270];
1798 if (entry.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
1799 {
1800 static const WCHAR bracketW[] = { ']',0 };
1801 static const WCHAR dotW[] = { '.',0 };
1802 if (!(attrib & DDL_DIRECTORY) ||
1803 !strcmpW( entry.cFileName, dotW )) continue;
1804 buffer[0] = '[';
1805 if (!long_names && entry.cAlternateFileName[0])
1806 strcpyW( buffer + 1, entry.cAlternateFileName );
1807 else
1808 strcpyW( buffer + 1, entry.cFileName );
1809 strcatW(buffer, bracketW);
1810 }
1811 else /* not a directory */
1812 {
1813 #define ATTRIBS (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN | \
1814 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_ARCHIVE)
1815
1816 if ((attrib & DDL_EXCLUSIVE) &&
1817 ((attrib & ATTRIBS) != (entry.dwFileAttributes & ATTRIBS)))
1818 continue;
1819 #undef ATTRIBS
1820 if (!long_names && entry.cAlternateFileName[0])
1821 strcpyW( buffer, entry.cAlternateFileName );
1822 else
1823 strcpyW( buffer, entry.cFileName );
1824 }
1825 if (!long_names) CharLowerW( buffer );
1826 pos = LISTBOX_FindFileStrPos( descr, buffer );
1827 if ((ret = LISTBOX_InsertString( descr, pos, buffer )) < 0)
1828 break;
1829 } while (FindNextFileW( handle, &entry ));
1830 FindClose( handle );
1831 }
1832 }
1833
1834 /* scan drives */
1835 if ((ret >= 0) && (attrib & DDL_DRIVES))
1836 {
1837 WCHAR buffer[] = {'[','-','a','-',']',0};
1838 WCHAR root[] = {'A',':','\\',0};
1839 int drive;
1840 for (drive = 0; drive < 26; drive++, buffer[2]++, root[0]++)
1841 {
1842 if (GetDriveTypeW(root) <= DRIVE_NO_ROOT_DIR) continue;
1843 if ((ret = LISTBOX_InsertString( descr, -1, buffer )) < 0)
1844 break;
1845 }
1846 }
1847 return ret;
1848 }
1849
1850
1851 /***********************************************************************
1852 * LISTBOX_HandleVScroll
1853 */
1854 static LRESULT LISTBOX_HandleVScroll( LB_DESCR *descr, WORD scrollReq, WORD pos )
1855 {
1856 SCROLLINFO info;
1857
1858 if (descr->style & LBS_MULTICOLUMN) return 0;
1859 switch(scrollReq)
1860 {
1861 case SB_LINEUP:
1862 LISTBOX_SetTopItem( descr, descr->top_item - 1, TRUE );
1863 break;
1864 case SB_LINEDOWN:
1865 LISTBOX_SetTopItem( descr, descr->top_item + 1, TRUE );
1866 break;
1867 case SB_PAGEUP:
1868 LISTBOX_SetTopItem( descr, descr->top_item -
1869 LISTBOX_GetCurrentPageSize( descr ), TRUE );
1870 break;
1871 case SB_PAGEDOWN:
1872 LISTBOX_SetTopItem( descr, descr->top_item +
1873 LISTBOX_GetCurrentPageSize( descr ), TRUE );
1874 break;
1875 case SB_THUMBPOSITION:
1876 LISTBOX_SetTopItem( descr, pos, TRUE );
1877 break;
1878 case SB_THUMBTRACK:
1879 info.cbSize = sizeof(info);
1880 info.fMask = SIF_TRACKPOS;
1881 GetScrollInfo( descr->self, SB_VERT, &info );
1882 LISTBOX_SetTopItem( descr, info.nTrackPos, TRUE );
1883 break;
1884 case SB_TOP:
1885 LISTBOX_SetTopItem( descr, 0, TRUE );
1886 break;
1887 case SB_BOTTOM:
1888 LISTBOX_SetTopItem( descr, descr->nb_items, TRUE );
1889 break;
1890 }
1891 return 0;
1892 }
1893
1894
1895 /***********************************************************************
1896 * LISTBOX_HandleHScroll
1897 */
1898 static LRESULT LISTBOX_HandleHScroll( LB_DESCR *descr, WORD scrollReq, WORD pos )
1899 {
1900 SCROLLINFO info;
1901 INT page;
1902
1903 if (descr->style & LBS_MULTICOLUMN)
1904 {
1905 switch(scrollReq)
1906 {
1907 case SB_LINELEFT:
1908 LISTBOX_SetTopItem( descr, descr->top_item-descr->page_size,
1909 TRUE );
1910 break;
1911 case SB_LINERIGHT:
1912 LISTBOX_SetTopItem( descr, descr->top_item+descr->page_size,
1913 TRUE );
1914 break;
1915 case SB_PAGELEFT:
1916 page = descr->width / descr->column_width;
1917 if (page < 1) page = 1;
1918 LISTBOX_SetTopItem( descr,
1919 descr->top_item - page * descr->page_size, TRUE );
1920 break;
1921 case SB_PAGERIGHT:
1922 page = descr->width / descr->column_width;
1923 if (page < 1) page = 1;
1924 LISTBOX_SetTopItem( descr,
1925 descr->top_item + page * descr->page_size, TRUE );
1926 break;
1927 case SB_THUMBPOSITION:
1928 LISTBOX_SetTopItem( descr, pos*descr->page_size, TRUE );
1929 break;
1930 case SB_THUMBTRACK:
1931 info.cbSize = sizeof(info);
1932 info.fMask = SIF_TRACKPOS;
1933 GetScrollInfo( descr->self, SB_VERT, &info );
1934 LISTBOX_SetTopItem( descr, info.nTrackPos*descr->page_size,
1935 TRUE );
1936 break;
1937 case SB_LEFT:
1938 LISTBOX_SetTopItem( descr, 0, TRUE );
1939 break;
1940 case SB_RIGHT:
1941 LISTBOX_SetTopItem( descr, descr->nb_items, TRUE );
1942 break;
1943 }
1944 }
1945 else if (descr->horz_extent)
1946 {
1947 switch(scrollReq)
1948 {
1949 case SB_LINELEFT:
1950 LISTBOX_SetHorizontalPos( descr, descr->horz_pos - 1 );
1951 break;
1952 case SB_LINERIGHT:
1953 LISTBOX_SetHorizontalPos( descr, descr->horz_pos + 1 );
1954 break;
1955 case SB_PAGELEFT:
1956 LISTBOX_SetHorizontalPos( descr,
1957 descr->horz_pos - descr->width );
1958 break;
1959 case SB_PAGERIGHT:
1960 LISTBOX_SetHorizontalPos( descr,
1961 descr->horz_pos + descr->width );
1962 break;
1963 case SB_THUMBPOSITION:
1964 LISTBOX_SetHorizontalPos( descr, pos );
1965 break;
1966 case SB_THUMBTRACK:
1967 info.cbSize = sizeof(info);
1968 info.fMask = SIF_TRACKPOS;
1969 GetScrollInfo( descr->self, SB_HORZ, &info );
1970 LISTBOX_SetHorizontalPos( descr, info.nTrackPos );
1971 break;
1972 case SB_LEFT:
1973 LISTBOX_SetHorizontalPos( descr, 0 );
1974 break;
1975 case SB_RIGHT:
1976 LISTBOX_SetHorizontalPos( descr,
1977 descr->horz_extent - descr->width );
1978 break;
1979 }
1980 }
1981 return 0;
1982 }
1983
1984 static LRESULT LISTBOX_HandleMouseWheel(LB_DESCR *descr, SHORT delta )
1985 {
1986 short gcWheelDelta = 0;
1987 UINT pulScrollLines = 3;
1988
1989 SystemParametersInfoW(SPI_GETWHEELSCROLLLINES,0, &pulScrollLines, 0);
1990
1991 gcWheelDelta -= delta;
1992
1993 if (abs(gcWheelDelta) >= WHEEL_DELTA && pulScrollLines)
1994 {
1995 int cLineScroll = (int) min((UINT) descr->page_size, pulScrollLines);
1996 cLineScroll *= (gcWheelDelta / WHEEL_DELTA);
1997 LISTBOX_SetTopItem( descr, descr->top_item + cLineScroll, TRUE );
1998 }
1999 return 0;
2000 }
2001
2002 /***********************************************************************
2003 * LISTBOX_HandleLButtonDown
2004 */
2005 static LRESULT LISTBOX_HandleLButtonDown( LB_DESCR *descr, DWORD keys, INT x, INT y )
2006 {
2007 INT index = LISTBOX_GetItemFromPoint( descr, x, y );
2008 TRACE("[%p]: lbuttondown %d,%d item %d\n", descr->self, x, y, index );
2009 if (!descr->caret_on && (descr->in_focus)) return 0;
2010
2011 if (!descr->in_focus)
2012 {
2013 if( !descr->lphc ) SetFocus( descr->self );
2014 else SetFocus( (descr->lphc->hWndEdit) ? descr->lphc->hWndEdit : descr->lphc->self );
2015 }
2016
2017 if (index == -1) return 0;
2018
2019 if (descr->style & (LBS_EXTENDEDSEL | LBS_MULTIPLESEL))
2020 {
2021 /* we should perhaps make sure that all items are deselected
2022 FIXME: needed for !LBS_EXTENDEDSEL, too ?
2023 if (!(keys & (MK_SHIFT|MK_CONTROL)))
2024 LISTBOX_SetSelection( descr, -1, FALSE, FALSE);
2025 */
2026
2027 if (!(keys & MK_SHIFT)) descr->anchor_item = index;
2028 if (keys & MK_CONTROL)
2029 {
2030 LISTBOX_SetCaretIndex( descr, index, FALSE );
2031 LISTBOX_SetSelection( descr, index,
2032 !descr->items[index].selected,
2033 (descr->style & LBS_NOTIFY) != 0);
2034 }
2035 else
2036 {
2037 LISTBOX_MoveCaret( descr, index, FALSE );
2038
2039 if (descr->style & LBS_EXTENDEDSEL)
2040 {
2041 LISTBOX_SetSelection( descr, index,
2042 descr->items[index].selected,
2043 (descr->style & LBS_NOTIFY) != 0 );
2044 }
2045 else
2046 {
2047 LISTBOX_SetSelection( descr, index,
2048 !descr->items[index].selected,
2049 (descr->style & LBS_NOTIFY) != 0 );
2050 }
2051 }
2052 }
2053 else
2054 {
2055 descr->anchor_item = index;
2056 LISTBOX_MoveCaret( descr, index, FALSE );
2057 LISTBOX_SetSelection( descr, index,
2058 TRUE, (descr->style & LBS_NOTIFY) != 0 );
2059 }
2060
2061 descr->captured = TRUE;
2062 SetCapture( descr->self );
2063
2064 if (!descr->lphc)
2065 {
2066 if (descr->style & LBS_NOTIFY )
2067 SendMessageW( descr->owner, WM_LBTRACKPOINT, index,
2068 MAKELPARAM( x, y ) );
2069 if (GetWindowLongW( descr->self, GWL_EXSTYLE ) & WS_EX_DRAGDETECT)
2070 {
2071 POINT pt;
2072
2073 pt.x = x;
2074 pt.y = y;
2075
2076 if (DragDetect( descr->self, pt ))
2077 SendMessageW( descr->owner, WM_BEGINDRAG, 0, 0 );
2078 }
2079 }
2080 return 0;
2081 }
2082
2083
2084 /*************************************************************************
2085 * LISTBOX_HandleLButtonDownCombo [Internal]
2086 *
2087 * Process LButtonDown message for the ComboListBox
2088 *
2089 * PARAMS
2090 * pWnd [I] The windows internal structure
2091 * pDescr [I] The ListBox internal structure
2092 * keys [I] Key Flag (WM_LBUTTONDOWN doc for more info)
2093 * x [I] X Mouse Coordinate
2094 * y [I] Y Mouse Coordinate
2095 *
2096 * RETURNS
2097 * 0 since we are processing the WM_LBUTTONDOWN Message
2098 *
2099 * NOTES
2100 * This function is only to be used when a ListBox is a ComboListBox
2101 */
2102
2103 static LRESULT LISTBOX_HandleLButtonDownCombo( LB_DESCR *descr, UINT msg, DWORD keys, INT x, INT y)
2104 {
2105 RECT clientRect, screenRect;
2106 POINT mousePos;
2107
2108 mousePos.x = x;
2109 mousePos.y = y;
2110
2111 GetClientRect(descr->self, &clientRect);
2112
2113 if(PtInRect(&clientRect, mousePos))
2114 {
2115 /* MousePos is in client, resume normal processing */
2116 if (msg == WM_LBUTTONDOWN)
2117 {
2118 descr->lphc->droppedIndex = descr->nb_items ? descr->selected_item : -1;
2119 return LISTBOX_HandleLButtonDown( descr, keys, x, y);
2120 }
2121 else if (descr->style & LBS_NOTIFY)
2122 SEND_NOTIFICATION( descr, LBN_DBLCLK );
2123 }
2124 else
2125 {
2126 POINT screenMousePos;
2127 HWND hWndOldCapture;
2128
2129 /* Check the Non-Client Area */
2130 screenMousePos = mousePos;
2131 hWndOldCapture = GetCapture();
2132 ReleaseCapture();
2133 GetWindowRect(descr->self, &screenRect);
2134 ClientToScreen(descr->self, &screenMousePos);
2135
2136 if(!PtInRect(&screenRect, screenMousePos))
2137 {
2138 LISTBOX_SetCaretIndex( descr, descr->lphc->droppedIndex, FALSE );
2139 LISTBOX_SetSelection( descr, descr->lphc->droppedIndex, FALSE, FALSE );
2140 COMBO_FlipListbox( descr->lphc, FALSE, FALSE );
2141 }
2142 else
2143 {
2144 /* Check to see the NC is a scrollbar */
2145 INT nHitTestType=0;
2146 LONG style = GetWindowLongW( descr->self, GWL_STYLE );
2147 /* Check Vertical scroll bar */
2148 if (style & WS_VSCROLL)
2149 {
2150 clientRect.right += GetSystemMetrics(SM_CXVSCROLL);
2151 if (PtInRect( &clientRect, mousePos ))
2152 nHitTestType = HTVSCROLL;
2153 }
2154 /* Check horizontal scroll bar */
2155 if (style & WS_HSCROLL)
2156 {
2157 clientRect.bottom += GetSystemMetrics(SM_CYHSCROLL);
2158 if (PtInRect( &clientRect, mousePos ))
2159 nHitTestType = HTHSCROLL;
2160 }
2161 /* Windows sends this message when a scrollbar is clicked
2162 */
2163
2164 if(nHitTestType != 0)
2165 {
2166 SendMessageW(descr->self, WM_NCLBUTTONDOWN, nHitTestType,
2167 MAKELONG(screenMousePos.x, screenMousePos.y));
2168 }
2169 /* Resume the Capture after scrolling is complete
2170 */
2171 if(hWndOldCapture != 0)
2172 SetCapture(hWndOldCapture);
2173 }
2174 }
2175 return 0;
2176 }
2177
2178 /***********************************************************************
2179 * LISTBOX_HandleLButtonUp
2180 */
2181 static LRESULT LISTBOX_HandleLButtonUp( LB_DESCR *descr )
2182 {
2183 if (LISTBOX_Timer != LB_TIMER_NONE)
2184 KillSystemTimer( descr->self, LB_TIMER_ID );
2185 LISTBOX_Timer = LB_TIMER_NONE;
2186 if (descr->captured)
2187 {
2188 descr->captured = FALSE;
2189 if (GetCapture() == descr->self) ReleaseCapture();
2190 if ((descr->style & LBS_NOTIFY) && descr->nb_items)
2191 SEND_NOTIFICATION( descr, LBN_SELCHANGE );
2192 }
2193 return 0;
2194 }
2195
2196
2197 /***********************************************************************
2198 * LISTBOX_HandleTimer
2199 *
2200 * Handle scrolling upon a timer event.
2201 * Return TRUE if scrolling should continue.
2202 */
2203 static LRESULT LISTBOX_HandleTimer( LB_DESCR *descr, INT index, TIMER_DIRECTION dir )
2204 {
2205 switch(dir)
2206 {
2207 case LB_TIMER_UP:
2208 if (descr->top_item) index = descr->top_item - 1;
2209 else index = 0;
2210 break;
2211 case LB_TIMER_LEFT:
2212 if (descr->top_item) index -= descr->page_size;
2213 break;
2214 case LB_TIMER_DOWN:
2215 index = descr->top_item + LISTBOX_GetCurrentPageSize( descr );
2216 if (index == descr->focus_item) index++;
2217 if (index >= descr->nb_items) index = descr->nb_items - 1;
2218 break;
2219 case LB_TIMER_RIGHT:
2220 if (index + descr->page_size < descr->nb_items)
2221 index += descr->page_size;
2222 break;
2223 case LB_TIMER_NONE:
2224 break;
2225 }
2226 if (index == descr->focus_item) return FALSE;
2227 LISTBOX_MoveCaret( descr, index, FALSE );
2228 return TRUE;
2229 }
2230
2231
2232 /***********************************************************************
2233 * LISTBOX_HandleSystemTimer
2234 *
2235 * WM_SYSTIMER handler.
2236 */
2237 static LRESULT LISTBOX_HandleSystemTimer( LB_DESCR *descr )
2238 {
2239 if (!LISTBOX_HandleTimer( descr, descr->focus_item, LISTBOX_Timer ))
2240 {
2241 KillSystemTimer( descr->self, LB_TIMER_ID );
2242 LISTBOX_Timer = LB_TIMER_NONE;
2243 }
2244 return 0;
2245 }
2246
2247
2248 /***********************************************************************
2249 * LISTBOX_HandleMouseMove
2250 *
2251 * WM_MOUSEMOVE handler.
2252 */
2253 static void LISTBOX_HandleMouseMove( LB_DESCR *descr,
2254 INT x, INT y )
2255 {
2256 INT index;
2257 TIMER_DIRECTION dir = LB_TIMER_NONE;
2258
2259 if (!descr->captured) return;
2260
2261 if (descr->style & LBS_MULTICOLUMN)
2262 {
2263 if (y < 0) y = 0;
2264 else if (y >= descr->item_height * descr->page_size)
2265 y = descr->item_height * descr->page_size - 1;
2266
2267 if (x < 0)
2268 {
2269 dir = LB_TIMER_LEFT;
2270 x = 0;
2271 }
2272 else if (x >= descr->width)
2273 {
2274 dir = LB_TIMER_RIGHT;
2275 x = descr->width - 1;
2276 }
2277 }
2278 else
2279 {
2280 if (y < 0) dir = LB_TIMER_UP; /* above */
2281 else if (y >= descr->height) dir = LB_TIMER_DOWN; /* below */
2282 }
2283
2284 index = LISTBOX_GetItemFromPoint( descr, x, y );
2285 if (index == -1) index = descr->focus_item;
2286 if (!LISTBOX_HandleTimer( descr, index, dir )) dir = LB_TIMER_NONE;
2287
2288 /* Start/stop the system timer */
2289
2290 if (dir != LB_TIMER_NONE)
2291 SetSystemTimer( descr->self, LB_TIMER_ID, LB_SCROLL_TIMEOUT, NULL);
2292 else if (LISTBOX_Timer != LB_TIMER_NONE)
2293 KillSystemTimer( descr->self, LB_TIMER_ID );
2294 LISTBOX_Timer = dir;
2295 }
2296
2297
2298 /***********************************************************************
2299 * LISTBOX_HandleKeyDown
2300 */
2301 static LRESULT LISTBOX_HandleKeyDown( LB_DESCR *descr, DWORD key )
2302 {
2303 INT caret = -1;
2304 BOOL bForceSelection = TRUE; /* select item pointed to by focus_item */
2305 if ((IS_MULTISELECT(descr)) || (descr->selected_item == descr->focus_item))
2306 bForceSelection = FALSE; /* only for single select list */
2307
2308 if (descr->style & LBS_WANTKEYBOARDINPUT)
2309 {
2310 caret = SendMessageW( descr->owner, WM_VKEYTOITEM,
2311 MAKEWPARAM(LOWORD(key), descr->focus_item),
2312 (LPARAM)descr->self );
2313 if (caret == -2) return 0;
2314 }
2315 if (caret == -1) switch(key)
2316 {
2317 case VK_LEFT:
2318 if (descr->style & LBS_MULTICOLUMN)
2319 {
2320 bForceSelection = FALSE;
2321 if (descr->focus_item >= descr->page_size)
2322 caret = descr->focus_item - descr->page_size;
2323 break;
2324 }
2325 /* fall through */
2326 case VK_UP:
2327 caret = descr->focus_item - 1;
2328 if (caret < 0) caret = 0;
2329 break;
2330 case VK_RIGHT:
2331 if (descr->style & LBS_MULTICOLUMN)
2332 {
2333 bForceSelection = FALSE;
2334 if (descr->focus_item + descr->page_size < descr->nb_items)
2335 caret = descr->focus_item + descr->page_size;
2336 break;
2337 }
2338 /* fall through */
2339 case VK_DOWN:
2340 caret = descr->focus_item + 1;
2341 if (caret >= descr->nb_items) caret = descr->nb_items - 1;
2342 break;
2343
2344 case VK_PRIOR:
2345 if (descr->style & LBS_MULTICOLUMN)
2346 {
2347 INT page = descr->width / descr->column_width;
2348 if (page < 1) page = 1;
2349 caret = descr->focus_item - (page * descr->page_size) + 1;
2350 }
2351 else caret = descr->focus_item-LISTBOX_GetCurrentPageSize(descr) + 1;
2352 if (caret < 0) caret = 0;
2353 break;
2354 case VK_NEXT:
2355 if (descr->style & LBS_MULTICOLUMN)
2356 {
2357 INT page = descr->width / descr->column_width;
2358 if (page < 1) page = 1;
2359 caret = descr->focus_item + (page * descr->page_size) - 1;
2360 }
2361 else caret = descr->focus_item + LISTBOX_GetCurrentPageSize(descr) - 1;
2362 if (caret >= descr->nb_items) caret = descr->nb_items - 1;
2363 break;
2364 case VK_HOME:
2365 caret = 0;
2366 break;
2367 case VK_END:
2368 caret = descr->nb_items - 1;
2369 break;
2370 case VK_SPACE:
2371 if (descr->style & LBS_EXTENDEDSEL) caret = descr->focus_item;
2372 else if (descr->style & LBS_MULTIPLESEL)
2373 {
2374 LISTBOX_SetSelection( descr, descr->focus_item,
2375 !descr->items[descr->focus_item].selected,
2376 (descr->style & LBS_NOTIFY) != 0 );
2377 }
2378 break;
2379 default:
2380 bForceSelection = FALSE;
2381 }
2382 if (bForceSelection) /* focused item is used instead of key */
2383 caret = descr->focus_item;
2384 if (caret >= 0)
2385 {
2386 if (((descr->style & LBS_EXTENDEDSEL) &&
2387 !(GetKeyState( VK_SHIFT ) & 0x8000)) ||
2388 !IS_MULTISELECT(descr))
2389 descr->anchor_item = caret;
2390 LISTBOX_MoveCaret( descr, caret, TRUE );
2391
2392 if (descr->style & LBS_MULTIPLESEL)
2393 descr->selected_item = caret;
2394 else
2395 LISTBOX_SetSelection( descr, caret, TRUE, FALSE);
2396 if (descr->style & LBS_NOTIFY)
2397 {
2398 if( descr->lphc )
2399 {
2400 /* make sure that combo parent doesn't hide us */
2401 descr->lphc->wState |= CBF_NOROLLUP;
2402 }
2403 if (descr->nb_items) SEND_NOTIFICATION( descr, LBN_SELCHANGE );
2404 }
2405 }
2406 return 0;
2407 }
2408
2409
2410 /***********************************************************************
2411 * LISTBOX_HandleChar
2412 */
2413 static LRESULT LISTBOX_HandleChar( LB_DESCR *descr, WCHAR charW )
2414 {
2415 INT caret = -1;
2416 WCHAR str[2];
2417
2418 str[0] = charW;
2419 str[1] = '\0';
2420
2421 if (descr->style & LBS_WANTKEYBOARDINPUT)
2422 {
2423 caret = SendMessageW( descr->owner, WM_CHARTOITEM,
2424 MAKEWPARAM(charW, descr->focus_item),
2425 (LPARAM)descr->self );
2426 if (caret == -2) return 0;
2427 }
2428 if (caret == -1)
2429 caret = LISTBOX_FindString( descr, descr->focus_item, str, FALSE);
2430 if (caret != -1)
2431 {
2432 if ((!IS_MULTISELECT(descr)) && descr->selected_item == -1)
2433 LISTBOX_SetSelection( descr, caret, TRUE, FALSE);
2434 LISTBOX_MoveCaret( descr, caret, TRUE );
2435 if ((descr->style & LBS_NOTIFY) && descr->nb_items)
2436 SEND_NOTIFICATION( descr, LBN_SELCHANGE );
2437 }
2438 return 0;
2439 }
2440
2441
2442 /***********************************************************************
2443 * LISTBOX_Create
2444 */
2445 static BOOL LISTBOX_Create( HWND hwnd, LPHEADCOMBO lphc )
2446 {
2447 LB_DESCR *descr;
2448 MEASUREITEMSTRUCT mis;
2449 RECT rect;
2450
2451 if (!(descr = HeapAlloc( GetProcessHeap(), 0, sizeof(*descr) )))
2452 return FALSE;
2453
2454 GetClientRect( hwnd, &rect );
2455 descr->self = hwnd;
2456 descr->owner = GetParent( descr->self );
2457 descr->style = GetWindowLongW( descr->self, GWL_STYLE );
2458 descr->width = rect.right - rect.left;
2459 descr->height = rect.bottom - rect.top;
2460 descr->items = NULL;
2461 descr->nb_items = 0;
2462 descr->top_item = 0;
2463 descr->selected_item = -1;
2464 descr->focus_item = 0;
2465 descr->anchor_item = -1;
2466 descr->item_height = 1;
2467 descr->page_size = 1;
2468 descr->column_width = 150;
2469 descr->horz_extent = (descr->style & WS_HSCROLL) ? 1 : 0;
2470 descr->horz_pos = 0;
2471 descr->nb_tabs = 0;
2472 descr->tabs = NULL;
2473 descr->caret_on = lphc ? FALSE : TRUE;
2474 if (descr->style & LBS_NOSEL) descr->caret_on = FALSE;
2475 descr->in_focus = FALSE;
2476 descr->captured = FALSE;
2477 descr->font = 0;
2478 descr->locale = GetUserDefaultLCID();
2479 descr->lphc = lphc;
2480
2481 if (is_old_app(descr) && ( descr->style & ( WS_VSCROLL | WS_HSCROLL ) ) )
2482 {
2483 /* Win95 document "List Box Differences" from MSDN:
2484 If a list box in a version 3.x application has either the
2485 WS_HSCROLL or WS_VSCROLL style, the list box receives both
2486 horizontal and vertical scroll bars.
2487 */
2488 descr->style |= WS_VSCROLL | WS_HSCROLL;
2489 }
2490
2491 if( lphc )
2492 {
2493 TRACE("[%p]: resetting owner %p -> %p\n", descr->self, descr->owner, lphc->self );
2494 descr->owner = lphc->self;
2495 }
2496
2497 SetWindowLongPtrW( descr->self, 0, (LONG_PTR)descr );
2498
2499 /* if (wnd->dwExStyle & WS_EX_NOPARENTNOTIFY) descr->style &= ~LBS_NOTIFY;
2500 */
2501 if (descr->style & LBS_EXTENDEDSEL) descr->style |= LBS_MULTIPLESEL;
2502 if (descr->style & LBS_MULTICOLUMN) descr->style &= ~LBS_OWNERDRAWVARIABLE;
2503 if (descr->style & LBS_OWNERDRAWVARIABLE) descr->style |= LBS_NOINTEGRALHEIGHT;
2504 descr->item_height = LISTBOX_SetFont( descr, 0 );
2505
2506 if (descr->style & LBS_OWNERDRAWFIXED)
2507 {
2508 if( descr->lphc && (descr->lphc->dwStyle & CBS_DROPDOWN))
2509 {
2510 /* WinWord gets VERY unhappy if we send WM_MEASUREITEM from here */
2511 descr->item_height = lphc->fixedOwnerDrawHeight;
2512 }
2513 else
2514 {
2515 UINT id = (UINT)GetWindowLongPtrW( descr->self, GWLP_ID );
2516 mis.CtlType = ODT_LISTBOX;
2517 mis.CtlID = id;
2518 mis.itemID = -1;
2519 mis.itemWidth = 0;
2520 mis.itemData = 0;
2521 mis.itemHeight = descr->item_height;
2522 SendMessageW( descr->owner, WM_MEASUREITEM, id, (LPARAM)&mis );
2523 descr->item_height = mis.itemHeight ? mis.itemHeight : 1;
2524 }
2525 }
2526
2527 TRACE("owner: %p, style: %08x, width: %d, height: %d\n", descr->owner, descr->style, descr->width, descr->height);
2528 return TRUE;
2529 }
2530
2531
2532 /***********************************************************************
2533 * LISTBOX_Destroy
2534 */
2535 static BOOL LISTBOX_Destroy( LB_DESCR *descr )
2536 {
2537 LISTBOX_ResetContent( descr );
2538 SetWindowLongPtrW( descr->self, 0, 0 );
2539 HeapFree( GetProcessHeap(), 0, descr );
2540 return TRUE;
2541 }
2542
2543
2544 /***********************************************************************
2545 * ListBoxWndProc_common
2546 */
2547 static LRESULT WINAPI ListBoxWndProc_common( HWND hwnd, UINT msg,
2548 WPARAM wParam, LPARAM lParam, BOOL unicode )
2549 {
2550 LB_DESCR *descr = (LB_DESCR *)GetWindowLongPtrW( hwnd, 0 );
2551 LPHEADCOMBO lphc = 0;
2552 LRESULT ret;
2553
2554 if (!descr)
2555 {
2556 if (!IsWindow(hwnd)) return 0;
2557
2558 if (msg == WM_CREATE)
2559 {
2560 CREATESTRUCTW *lpcs = (CREATESTRUCTW *)lParam;
2561 if (lpcs->style & LBS_COMBOBOX) lphc = (LPHEADCOMBO)lpcs->lpCreateParams;
2562 if (!LISTBOX_Create( hwnd, lphc )) return -1;
2563 TRACE("creating wnd=%p descr=%x\n", hwnd, GetWindowLongPtrW( hwnd, 0 ) );
2564 return 0;
2565 }
2566 /* Ignore all other messages before we get a WM_CREATE */
2567 return unicode ? DefWindowProcW( hwnd, msg, wParam, lParam ) :
2568 DefWindowProcA( hwnd, msg, wParam, lParam );
2569 }
2570 if (descr->style & LBS_COMBOBOX) lphc = descr->lphc;
2571
2572 TRACE("[%p]: msg %s wp %08lx lp %08lx\n",
2573 descr->self, SPY_GetMsgName(msg, descr->self), wParam, lParam );
2574
2575 switch(msg)
2576 {
2577 case LB_RESETCONTENT16:
2578 case LB_RESETCONTENT:
2579 LISTBOX_ResetContent( descr );
2580 LISTBOX_UpdateScroll( descr );
2581 InvalidateRect( descr->self, NULL, TRUE );
2582 return 0;
2583
2584 case LB_ADDSTRING16:
2585 if (HAS_STRINGS(descr)) lParam = (LPARAM)MapSL(lParam);
2586 /* fall through */
2587 case LB_ADDSTRING:
2588 {
2589 INT ret;
2590 LPWSTR textW;
2591 if(unicode || !HAS_STRINGS(descr))
2592 textW = (LPWSTR)lParam;
2593 else
2594 {
2595 LPSTR textA = (LPSTR)lParam;
2596 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
2597 if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
2598 MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
2599 }
2600 wParam = LISTBOX_FindStringPos( descr, textW, FALSE );
2601 ret = LISTBOX_InsertString( descr, wParam, textW );
2602 if (!unicode && HAS_STRINGS(descr))
2603 HeapFree(GetProcessHeap(), 0, textW);
2604 return ret;
2605 }
2606
2607 case LB_INSERTSTRING16:
2608 if (HAS_STRINGS(descr)) lParam = (LPARAM)MapSL(lParam);
2609 wParam = (INT)(INT16)wParam;
2610 /* fall through */
2611 case LB_INSERTSTRING:
2612 {
2613 INT ret;
2614 LPWSTR textW;
2615 if(unicode || !HAS_STRINGS(descr))
2616 textW = (LPWSTR)lParam;
2617 else
2618 {
2619 LPSTR textA = (LPSTR)lParam;
2620 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
2621 if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
2622 MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
2623 }
2624 ret = LISTBOX_InsertString( descr, wParam, textW );
2625 if(!unicode && HAS_STRINGS(descr))
2626 HeapFree(GetProcessHeap(), 0, textW);
2627 return ret;
2628 }
2629
2630 case LB_ADDFILE16:
2631 if (HAS_STRINGS(descr)) lParam = (LPARAM)MapSL(lParam);
2632 /* fall through */
2633 case LB_ADDFILE:
2634 {
2635 INT ret;
2636 LPWSTR textW;
2637 if(unicode || !HAS_STRINGS(descr))
2638 textW = (LPWSTR)lParam;
2639 else
2640 {
2641 LPSTR textA = (LPSTR)lParam;
2642 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
2643 if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
2644 MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
2645 }
2646 wParam = LISTBOX_FindFileStrPos( descr, textW );
2647 ret = LISTBOX_InsertString( descr, wParam, textW );
2648 if(!unicode && HAS_STRINGS(descr))
2649 HeapFree(GetProcessHeap(), 0, textW);
2650 return ret;
2651 }
2652
2653 case LB_DELETESTRING16:
2654 case LB_DELETESTRING:
2655 if (LISTBOX_RemoveItem( descr, wParam) != LB_ERR)
2656 return descr->nb_items;
2657 else
2658 {
2659 SetLastError(ERROR_INVALID_INDEX);
2660 return LB_ERR;
2661 }
2662
2663 case LB_GETITEMDATA16:
2664 case LB_GETITEMDATA:
2665 if (((INT)wParam < 0) || ((INT)wParam >= descr->nb_items))
2666 {
2667 SetLastError(ERROR_INVALID_INDEX);
2668 return LB_ERR;
2669 }
2670 return descr->items[wParam].data;
2671
2672 case LB_SETITEMDATA16:
2673 case LB_SETITEMDATA:
2674 if (((INT)wParam < 0) || ((INT)wParam >= descr->nb_items))
2675 {
2676 SetLastError(ERROR_INVALID_INDEX);
2677 return LB_ERR;
2678 }
2679 descr->items[wParam].data = lParam;
2680 /* undocumented: returns TRUE, not LB_OKAY (0) */
2681 return TRUE;
2682
2683 case LB_GETCOUNT16:
2684 case LB_GETCOUNT:
2685 return descr->nb_items;
2686
2687 case LB_GETTEXT16:
2688 lParam = (LPARAM)MapSL(lParam);
2689 /* fall through */
2690 case LB_GETTEXT:
2691 return LISTBOX_GetText( descr, wParam, (LPWSTR)lParam, unicode );
2692
2693 case LB_GETTEXTLEN16:
2694 /* fall through */
2695 case LB_GETTEXTLEN:
2696 if ((INT)wParam >= descr->nb_items || (INT)wParam < 0)
2697 {
2698 SetLastError(ERROR_INVALID_INDEX);
2699 return LB_ERR;
2700 }
2701 if (!HAS_STRINGS(descr)) return sizeof(DWORD);
2702 if (unicode) return strlenW( descr->items[wParam].str );
2703 return WideCharToMultiByte( CP_ACP, 0, descr->items[wParam].str,
2704 strlenW(descr->items[wParam].str), NULL, 0, NULL, NULL );
2705
2706 case LB_GETCURSEL16:
2707 case LB_GETCURSEL:
2708 if (descr->nb_items == 0)
2709 return LB_ERR;
2710 if (!IS_MULTISELECT(descr))
2711 return descr->selected_item;
2712 if (descr->selected_item != -1)
2713 return descr->selected_item;
2714 return descr->focus_item;
2715 /* otherwise, if the user tries to move the selection with the */
2716 /* arrow keys, we will give the application something to choke on */
2717 case LB_GETTOPINDEX16:
2718 case LB_GETTOPINDEX:
2719 return descr->top_item;
2720
2721 case LB_GETITEMHEIGHT16:
2722 case LB_GETITEMHEIGHT:
2723 return LISTBOX_GetItemHeight( descr, wParam );
2724
2725 case LB_SETITEMHEIGHT16:
2726 lParam = LOWORD(lParam);
2727 /* fall through */
2728 case LB_SETITEMHEIGHT:
2729 return LISTBOX_SetItemHeight( descr, wParam, lParam, TRUE );
2730
2731 case LB_ITEMFROMPOINT:
2732 {
2733 POINT pt;
2734 RECT rect;
2735 int index;
2736 BOOL hit = TRUE;
2737
2738 /* The hiword of the return value is not a client area
2739 hittest as suggested by MSDN, but rather a hittest on
2740 the returned listbox item. */
2741
2742 if(descr->nb_items == 0)
2743 return 0x1ffff; /* win9x returns 0x10000, we copy winnt */
2744
2745 pt.x = (short)LOWORD(lParam);
2746 pt.y = (short)HIWORD(lParam);
2747
2748 SetRect(&rect, 0, 0, descr->width, descr->height);
2749
2750 if(!PtInRect(&rect, pt))
2751 {
2752 pt.x = min(pt.x, rect.right - 1);
2753 pt.x = max(pt.x, 0);
2754 pt.y = min(pt.y, rect.bottom - 1);
2755 pt.y = max(pt.y, 0);
2756 hit = FALSE;
2757 }
2758
2759 index = LISTBOX_GetItemFromPoint(descr, pt.x, pt.y);
2760
2761 if(index == -1)
2762 {
2763 index = descr->nb_items - 1;
2764 hit = FALSE;
2765 }
2766 return MAKELONG(index, hit ? 0 : 1);
2767 }
2768
2769 case LB_SETCARETINDEX16:
2770 case LB_SETCARETINDEX:
2771 if ((!IS_MULTISELECT(descr)) && (descr->selected_item != -1)) return LB_ERR;
2772 if (LISTBOX_SetCaretIndex( descr, wParam, !lParam ) == LB_ERR)
2773 return LB_ERR;
2774 else if (ISWIN31)
2775 return wParam;
2776 else
2777 return LB_OKAY;
2778
2779 case LB_GETCARETINDEX16:
2780 case LB_GETCARETINDEX:
2781 return descr->focus_item;
2782
2783 case LB_SETTOPINDEX16:
2784 case LB_SETTOPINDEX:
2785 return LISTBOX_SetTopItem( descr, wParam, TRUE );
2786
2787 case LB_SETCOLUMNWIDTH16:
2788 case LB_SETCOLUMNWIDTH:
2789 return LISTBOX_SetColumnWidth( descr, wParam );
2790
2791 case LB_GETITEMRECT16:
2792 {
2793 RECT rect;
2794 RECT16 *r16 = MapSL(lParam);
2795 ret = LISTBOX_GetItemRect( descr, (INT16)wParam, &rect );
2796 r16->left = rect.left;
2797 r16->top = rect.top;
2798 r16->right = rect.right;
2799 r16->bottom = rect.bottom;
2800 }
2801 return ret;
2802
2803 case LB_GETITEMRECT:
2804 return LISTBOX_GetItemRect( descr, wParam, (RECT *)lParam );
2805
2806 case LB_FINDSTRING16:
2807 wParam = (INT)(INT16)wParam;
2808 if (HAS_STRINGS(descr)) lParam = (LPARAM)MapSL(lParam);
2809 /* fall through */
2810 case LB_FINDSTRING:
2811 {
2812 INT ret;
2813 LPWSTR textW;
2814 if(unicode || !HAS_STRINGS(descr))
2815 textW = (LPWSTR)lParam;
2816 else
2817 {
2818 LPSTR textA = (LPSTR)lParam;
2819 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
2820 if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
2821 MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
2822 }
2823 ret = LISTBOX_FindString( descr, wParam, textW, FALSE );
2824 if(!unicode && HAS_STRINGS(descr))
2825 HeapFree(GetProcessHeap(), 0, textW);
2826 return ret;
2827 }
2828
2829 case LB_FINDSTRINGEXACT16:
2830 wParam = (INT)(INT16)wParam;
2831 if (HAS_STRINGS(descr)) lParam = (LPARAM)MapSL(lParam);
2832 /* fall through */
2833 case LB_FINDSTRINGEXACT:
2834 {
2835 INT ret;
2836 LPWSTR textW;
2837 if(unicode || !HAS_STRINGS(descr))
2838 textW = (LPWSTR)lParam;
2839 else
2840 {
2841 LPSTR textA = (LPSTR)lParam;
2842 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
2843 if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
2844 MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
2845 }
2846 ret = LISTBOX_FindString( descr, wParam, textW, TRUE );
2847 if(!unicode && HAS_STRINGS(descr))
2848 HeapFree(GetProcessHeap(), 0, textW);
2849 return ret;
2850 }
2851
2852 case LB_SELECTSTRING16:
2853 wParam = (INT)(INT16)wParam;
2854 if (HAS_STRINGS(descr)) lParam = (LPARAM)MapSL(lParam);
2855 /* fall through */
2856 case LB_SELECTSTRING:
2857 {
2858 INT index;
2859 LPWSTR textW;
2860
2861 if(HAS_STRINGS(descr))
2862 TRACE("LB_SELECTSTRING: %s\n", unicode ? debugstr_w((LPWSTR)lParam) :
2863 debugstr_a((LPSTR)lParam));
2864 if(unicode || !HAS_STRINGS(descr))
2865 textW = (LPWSTR)lParam;
2866 else
2867 {
2868 LPSTR textA = (LPSTR)lParam;
2869 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
2870 if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
2871 MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
2872 }
2873 index = LISTBOX_FindString( descr, wParam, textW, FALSE );
2874 if(!unicode && HAS_STRINGS(descr))
2875 HeapFree(GetProcessHeap(), 0, textW);
2876 if (index != LB_ERR)
2877 {
2878 LISTBOX_MoveCaret( descr, index, TRUE );
2879 LISTBOX_SetSelection( descr, index, TRUE, FALSE );
2880 }
2881 return index;
2882 }
2883
2884 case LB_GETSEL16:
2885 wParam = (INT)(INT16)wParam;
2886 /* fall through */
2887 case LB_GETSEL:
2888 if (((INT)wParam < 0) || ((INT)wParam >= descr->nb_items))
2889 return LB_ERR;
2890 return descr->items[wParam].selected;
2891
2892 case LB_SETSEL16:
2893 lParam = (INT)(INT16)lParam;
2894 /* fall through */
2895 case LB_SETSEL:
2896 return LISTBOX_SetSelection( descr, lParam, wParam, FALSE );
2897
2898 case LB_SETCURSEL16:
2899 wParam = (INT)(INT16)wParam;
2900 /* fall through */
2901 case LB_SETCURSEL:
2902 if (IS_MULTISELECT(descr)) return LB_ERR;
2903 LISTBOX_SetCaretIndex( descr, wParam, FALSE );
2904 ret = LISTBOX_SetSelection( descr, wParam, TRUE, FALSE );
2905 if (lphc && ret != LB_ERR) ret = descr->selected_item;
2906 return ret;
2907
2908 case LB_GETSELCOUNT16:
2909 case LB_GETSELCOUNT:
2910 return LISTBOX_GetSelCount( descr );
2911
2912 case LB_GETSELITEMS16:
2913 return LISTBOX_GetSelItems16( descr, wParam, (LPINT16)MapSL(lParam) );
2914
2915 case LB_GETSELITEMS:
2916 return LISTBOX_GetSelItems( descr, wParam, (LPINT)lParam );
2917
2918 case LB_SELITEMRANGE16:
2919 case LB_SELITEMRANGE:
2920 if (LOWORD(lParam) <= HIWORD(lParam))
2921 return LISTBOX_SelectItemRange( descr, LOWORD(lParam),
2922 HIWORD(lParam), wParam );
2923 else
2924 return LISTBOX_SelectItemRange( descr, HIWORD(lParam),
2925 LOWORD(lParam), wParam );
2926
2927 case LB_SELITEMRANGEEX16:
2928 case LB_SELITEMRANGEEX:
2929 if ((INT)lParam >= (INT)wParam)
2930 return LISTBOX_SelectItemRange( descr, wParam, lParam, TRUE );
2931 else
2932 return LISTBOX_SelectItemRange( descr, lParam, wParam, FALSE);
2933
2934 case LB_GETHORIZONTALEXTENT16:
2935 case LB_GETHORIZONTALEXTENT:
2936 return descr->horz_extent;
2937
2938 case LB_SETHORIZONTALEXTENT16:
2939 case LB_SETHORIZONTALEXTENT:
2940 return LISTBOX_SetHorizontalExtent( descr, wParam );
2941
2942 case LB_GETANCHORINDEX16:
2943 case LB_GETANCHORINDEX:
2944 return descr->anchor_item;
2945
2946 case LB_SETANCHORINDEX16:
2947 wParam = (INT)(INT16)wParam;
2948 /* fall through */
2949 case LB_SETANCHORINDEX:
2950 if (((INT)wParam < -1) || ((INT)wParam >= descr->nb_items))
2951 {
2952 SetLastError(ERROR_INVALID_INDEX);
2953 return LB_ERR;
2954 }
2955 descr->anchor_item = (INT)wParam;
2956 return LB_OKAY;
2957
2958 case LB_DIR16:
2959 /* according to Win16 docs, DDL_DRIVES should make DDL_EXCLUSIVE
2960 * be set automatically (this is different in Win32) */
2961 if (wParam & DDL_DRIVES) wParam |= DDL_EXCLUSIVE;
2962 lParam = (LPARAM)MapSL(lParam);
2963 /* fall through */
2964 case LB_DIR:
2965 {
2966 INT ret;
2967 LPWSTR textW;
2968 if(unicode)
2969 textW = (LPWSTR)lParam;
2970 else
2971 {
2972 LPSTR textA = (LPSTR)lParam;
2973 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
2974 if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
2975 MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
2976 }
2977 ret = LISTBOX_Directory( descr, wParam, textW, msg == LB_DIR );
2978 if(!unicode)
2979 HeapFree(GetProcessHeap(), 0, textW);
2980 return ret;
2981 }
2982
2983 case LB_GETLOCALE:
2984 return descr->locale;
2985
2986 case LB_SETLOCALE:
2987 {
2988 LCID ret;
2989 if (!IsValidLocale((LCID)wParam, LCID_INSTALLED))
2990 return LB_ERR;
2991 ret = descr->locale;
2992 descr->locale = (LCID)wParam;
2993 return ret;
2994 }
2995
2996 case LB_INITSTORAGE:
2997 return LISTBOX_InitStorage( descr, wParam );
2998
2999 case LB_SETCOUNT:
3000 return LISTBOX_SetCount( descr, (INT)wParam );
3001
3002 case LB_SETTABSTOPS16:
3003 return LISTBOX_SetTabStops( descr, (INT)(INT16)wParam, MapSL(lParam), TRUE );
3004
3005 case LB_SETTABSTOPS:
3006 return LISTBOX_SetTabStops( descr, wParam, (LPINT)lParam, FALSE );
3007
3008 case LB_CARETON16:
3009 case LB_CARETON:
3010 if (descr->caret_on)
3011 return LB_OKAY;
3012 descr->caret_on = TRUE;
3013 if ((descr->focus_item != -1) && (descr->in_focus))
3014 LISTBOX_RepaintItem( descr, descr->focus_item, ODA_FOCUS );
3015 return LB_OKAY;
3016
3017 case LB_CARETOFF16:
3018 case LB_CARETOFF:
3019 if (!descr->caret_on)
3020 return LB_OKAY;
3021 descr->caret_on = FALSE;
3022 if ((descr->focus_item != -1) && (descr->in_focus))
3023 LISTBOX_RepaintItem( descr, descr->focus_item, ODA_FOCUS );
3024 return LB_OKAY;
3025
3026 case LB_GETLISTBOXINFO:
3027 FIXME("LB_GETLISTBOXINFO: stub!\n");
3028 return 0;
3029
3030 case WM_DESTROY:
3031 return LISTBOX_Destroy( descr );
3032
3033 case WM_ENABLE:
3034 InvalidateRect( descr->self, NULL, TRUE );
3035 return 0;
3036
3037 case WM_SETREDRAW:
3038 LISTBOX_SetRedraw( descr, wParam != 0 );
3039 return 0;
3040
3041 case WM_GETDLGCODE:
3042 return DLGC_WANTARROWS | DLGC_WANTCHARS;
3043
3044 case WM_PRINTCLIENT:
3045 case WM_PAINT:
3046 {
3047 PAINTSTRUCT ps;
3048 HDC hdc = ( wParam ) ? ((HDC)wParam) : BeginPaint( descr->self, &ps );
3049 ret = LISTBOX_Paint( descr, hdc );
3050 if( !wParam ) EndPaint( descr->self, &ps );
3051 }
3052 return ret;
3053 case WM_SIZE:
3054 LISTBOX_UpdateSize( descr );
3055 return 0;
3056 case WM_GETFONT:
3057 return (LRESULT)descr->font;
3058 case WM_SETFONT:
3059 LISTBOX_SetFont( descr, (HFONT)wParam );
3060 if (lParam) InvalidateRect( descr->self, 0, TRUE );
3061 return 0;
3062 case WM_SETFOCUS:
3063 descr->in_focus = TRUE;
3064 descr->caret_on = TRUE;
3065 if (descr->focus_item != -1)
3066 LISTBOX_RepaintItem( descr, descr->focus_item, ODA_FOCUS );
3067 SEND_NOTIFICATION( descr, LBN_SETFOCUS );
3068 return 0;
3069 case WM_KILLFOCUS:
3070 descr->in_focus = FALSE;
3071 if ((descr->focus_item != -1) && descr->caret_on)
3072 LISTBOX_RepaintItem( descr, descr->focus_item, ODA_FOCUS );
3073 SEND_NOTIFICATION( descr, LBN_KILLFOCUS );
3074 return 0;
3075 case WM_HSCROLL:
3076 return LISTBOX_HandleHScroll( descr, LOWORD(wParam), HIWORD(wParam) );
3077 case WM_VSCROLL:
3078 return LISTBOX_HandleVScroll( descr, LOWORD(wParam), HIWORD(wParam) );
3079 case WM_MOUSEWHEEL:
3080 if (wParam & (MK_SHIFT | MK_CONTROL))
3081 return DefWindowProcW( descr->self, msg, wParam, lParam );
3082 return LISTBOX_HandleMouseWheel( descr, (SHORT)HIWORD(wParam) );
3083 case WM_LBUTTONDOWN:
3084 if (lphc)
3085 return LISTBOX_HandleLButtonDownCombo(descr, msg, wParam,
3086 (INT16)LOWORD(lParam),
3087 (INT16)HIWORD(lParam) );
3088 return LISTBOX_HandleLButtonDown( descr, wParam,
3089 (INT16)LOWORD(lParam),
3090 (INT16)HIWORD(lParam) );
3091 case WM_LBUTTONDBLCLK:
3092 if (lphc)
3093 return LISTBOX_HandleLButtonDownCombo(descr, msg, wParam,
3094 (INT16)LOWORD(lParam),
3095 (INT16)HIWORD(lParam) );
3096 if (descr->style & LBS_NOTIFY)
3097 SEND_NOTIFICATION( descr, LBN_DBLCLK );
3098 return 0;
3099 case WM_MOUSEMOVE:
3100 if ( lphc && ((lphc->dwStyle & CBS_DROPDOWNLIST) != CBS_SIMPLE) )
3101 {
3102 BOOL captured = descr->captured;
3103 POINT mousePos;
3104 RECT clientRect;
3105
3106 mousePos.x = (INT16)LOWORD(lParam);
3107 mousePos.y = (INT16)HIWORD(lParam);
3108
3109 /*
3110 * If we are in a dropdown combobox, we simulate that
3111 * the mouse is captured to show the tracking of the item.
3112 */
3113 if (GetClientRect(descr->self, &clientRect) && PtInRect( &clientRect, mousePos ))
3114 descr->captured = TRUE;
3115
3116 LISTBOX_HandleMouseMove( descr, mousePos.x, mousePos.y);
3117
3118 descr->captured = captured;
3119 }
3120 else if (GetCapture() == descr->self)
3121 {
3122 LISTBOX_HandleMouseMove( descr, (INT16)LOWORD(lParam),
3123 (INT16)HIWORD(lParam) );
3124 }
3125 return 0;
3126 case WM_LBUTTONUP:
3127 if (lphc)
3128 {
3129 POINT mousePos;
3130 RECT clientRect;
3131
3132 /*
3133 * If the mouse button "up" is not in the listbox,
3134 * we make sure there is no selection by re-selecting the
3135 * item that was selected when the listbox was made visible.
3136 */
3137 mousePos.x = (INT16)LOWORD(lParam);
3138 mousePos.y = (INT16)HIWORD(lParam);
3139
3140 GetClientRect(descr->self, &clientRect);
3141
3142 /*
3143 * When the user clicks outside the combobox and the focus
3144 * is lost, the owning combobox will send a fake buttonup with
3145 * 0xFFFFFFF as the mouse location, we must also revert the
3146 * selection to the original selection.
3147 */
3148 if ( (lParam == (LPARAM)-1) || (!PtInRect( &clientRect, mousePos )) )
3149 LISTBOX_MoveCaret( descr, lphc->droppedIndex, FALSE );
3150 }
3151 return LISTBOX_HandleLButtonUp( descr );
3152 case WM_KEYDOWN:
3153 if( lphc && (lphc->dwStyle & CBS_DROPDOWNLIST) != CBS_SIMPLE )
3154 {
3155 /* for some reason Windows makes it possible to
3156 * show/hide ComboLBox by sending it WM_KEYDOWNs */
3157
3158 if( (!(lphc->wState & CBF_EUI) && wParam == VK_F4) ||
3159 ( (lphc->wState & CBF_EUI) && !(lphc->wState & CBF_DROPPED)
3160 && (wParam == VK_DOWN || wParam == VK_UP)) )
3161 {
3162 COMBO_FlipListbox( lphc, FALSE, FALSE );
3163 return 0;
3164 }
3165 }
3166 return LISTBOX_HandleKeyDown( descr, wParam );
3167 case WM_CHAR:
3168 {
3169 WCHAR charW;
3170 if(unicode)
3171 charW = (WCHAR)wParam;
3172 else
3173 {
3174 CHAR charA = (CHAR)wParam;
3175 MultiByteToWideChar(CP_ACP, 0, &charA, 1, &charW, 1);
3176 }
3177 return LISTBOX_HandleChar( descr, charW );
3178 }
3179 case WM_SYSTIMER:
3180 return LISTBOX_HandleSystemTimer( descr );
3181 case WM_ERASEBKGND:
3182 if ((IS_OWNERDRAW(descr)) && !(descr->style & LBS_DISPLAYCHANGED))
3183 {
3184 RECT rect;
3185 HBRUSH hbrush = (HBRUSH)SendMessageW( descr->owner, WM_CTLCOLORLISTBOX,
3186 wParam, (LPARAM)descr->self );
3187 TRACE("hbrush = %p\n", hbrush);
3188 if(!hbrush)
3189 hbrush = GetSysColorBrush(COLOR_WINDOW);
3190 if(hbrush)
3191 {
3192 GetClientRect(descr->self, &rect);
3193 FillRect((HDC)wParam, &rect, hbrush);
3194 }
3195 }
3196 return 1;
3197 case WM_DROPFILES:
3198 if( lphc ) return 0;
3199 return unicode ? SendMessageW( descr->owner, msg, wParam, lParam ) :
3200 SendMessageA( descr->owner, msg, wParam, lParam );
3201
3202 case WM_NCDESTROY:
3203 if( lphc && (lphc->dwStyle & CBS_DROPDOWNLIST) != CBS_SIMPLE )
3204 lphc->hWndLBox = 0;
3205 break;
3206
3207 case WM_NCACTIVATE:
3208 if (lphc) return 0;
3209 break;
3210
3211 default:
3212 if ((msg >= WM_USER) && (msg < 0xc000))
3213 WARN("[%p]: unknown msg %04x wp %08lx lp %08lx\n",
3214 hwnd, msg, wParam, lParam );
3215 }
3216
3217 return unicode ? DefWindowProcW( hwnd, msg, wParam, lParam ) :
3218 DefWindowProcA( hwnd, msg, wParam, lParam );
3219 }
3220
3221 /***********************************************************************
3222 * ListBoxWndProcA
3223 */
3224 static LRESULT WINAPI ListBoxWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
3225 {
3226 return ListBoxWndProc_common( hwnd, msg, wParam, lParam, FALSE );
3227 }
3228
3229 /***********************************************************************
3230 * ListBoxWndProcW
3231 */
3232 static LRESULT WINAPI ListBoxWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
3233 {
3234 return ListBoxWndProc_common( hwnd, msg, wParam, lParam, TRUE );
3235 }
useful hacks and other patches not (yet) suitable for mainline